Line data Source code
1 : // MACHINE GENERATED SOURCE FILE WITH ROSE (Grammar.h)--- DO NOT MODIFY!
2 :
3 : #include "sage3basic.h"
4 :
5 : #ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
6 : #include "AST_FILE_IO.h"
7 : #endif
8 : // The header file ("rose_config.h") should only be included by source files that require it.
9 : #include "rose_config.h"
10 :
11 : #if _MSC_VER
12 : #define USE_CPP_NEW_DELETE_OPERATORS 0
13 : #endif
14 :
15 : #define ROSE_ALLOC_TRACE 0
16 : #undef mprintf
17 : #define mprintf Rose::Diagnostics::mfprintf(Rose::ir_node_mlog[Rose::Diagnostics::DEBUG])
18 :
19 :
20 : using namespace std;
21 :
22 : #include "Cxx_GrammarMemoryPoolSupport.h"
23 :
24 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25 :
26 : void
27 0 : SgNode::checkDataMemberPointersIfInMemoryPool()
28 : {
29 : // ------------ checking pointers of SgNode -------------------
30 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31 :
32 0 : if ( p_parent != NULL )
33 : {
34 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35 : {
36 0 : if ( p_parent->isInMemoryPool() == false )
37 : {
38 0 : std::cout << "SgNode :: ";
39 0 : std::cout << " p_parent is not in memory pool of ";
40 0 : std::cout << p_parent->class_name() << std::endl;
41 : }
42 : }
43 : else
44 : {
45 0 : std::cout << "SgNode :: " << std::flush;
46 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
47 0 : std::cout << " not valid " << std::endl;
48 : }
49 : }
50 :
51 :
52 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
53 :
54 0 : }
55 :
56 :
57 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
58 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
59 : bool
60 0 : SgNode::isInMemoryPool ()
61 : {
62 0 : typedef unsigned char* TestType;
63 :
64 0 : bool found = false;
65 :
66 0 : ROSE_ASSERT(this != NULL);
67 :
68 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
69 :
70 0 : TestType tested = (TestType) ( this ) ;
71 :
72 0 : std::vector < unsigned char* > :: const_iterator block = SgNode::pools.begin();
73 :
74 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
75 : // while (found == false && block < Memory_Block_List.end())
76 0 : while ( (found == false) && (block != SgNode::pools.end()) )
77 : {
78 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNode::pool_size * sizeof(SgNode) ) ) ;
79 0 : ++block;
80 : }
81 :
82 : // Special handling for static data
83 :
84 :
85 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
86 0 : ROSE_ASSERT(found == true);
87 :
88 0 : return found;
89 : }
90 : /* #line 91 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
91 :
92 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
93 :
94 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
95 :
96 : /* #line 97 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
97 :
98 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
99 :
100 : void
101 0 : SgSupport::checkDataMemberPointersIfInMemoryPool()
102 : {
103 : // ------------ checking pointers of SgSupport -------------------
104 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
105 :
106 0 : if ( p_parent != NULL )
107 : {
108 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109 : {
110 0 : if ( p_parent->isInMemoryPool() == false )
111 : {
112 0 : std::cout << "SgSupport :: ";
113 0 : std::cout << " p_parent is not in memory pool of ";
114 0 : std::cout << p_parent->class_name() << std::endl;
115 : }
116 : }
117 : else
118 : {
119 0 : std::cout << "SgSupport :: " << std::flush;
120 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
121 0 : std::cout << " not valid " << std::endl;
122 : }
123 : }
124 :
125 :
126 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
127 :
128 0 : }
129 :
130 :
131 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
132 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
133 : bool
134 0 : SgSupport::isInMemoryPool ()
135 : {
136 0 : typedef unsigned char* TestType;
137 :
138 0 : bool found = false;
139 :
140 0 : ROSE_ASSERT(this != NULL);
141 :
142 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
143 :
144 0 : TestType tested = (TestType) ( this ) ;
145 :
146 0 : std::vector < unsigned char* > :: const_iterator block = SgSupport::pools.begin();
147 :
148 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
149 : // while (found == false && block < Memory_Block_List.end())
150 0 : while ( (found == false) && (block != SgSupport::pools.end()) )
151 : {
152 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSupport::pool_size * sizeof(SgSupport) ) ) ;
153 0 : ++block;
154 : }
155 :
156 : // Special handling for static data
157 :
158 :
159 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
160 0 : ROSE_ASSERT(found == true);
161 :
162 0 : return found;
163 : }
164 : /* #line 165 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
165 :
166 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
167 :
168 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
169 :
170 : /* #line 171 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
171 :
172 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
173 :
174 : void
175 0 : SgModifier::checkDataMemberPointersIfInMemoryPool()
176 : {
177 : // ------------ checking pointers of SgModifier -------------------
178 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
179 :
180 0 : if ( p_parent != NULL )
181 : {
182 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
183 : {
184 0 : if ( p_parent->isInMemoryPool() == false )
185 : {
186 0 : std::cout << "SgModifier :: ";
187 0 : std::cout << " p_parent is not in memory pool of ";
188 0 : std::cout << p_parent->class_name() << std::endl;
189 : }
190 : }
191 : else
192 : {
193 0 : std::cout << "SgModifier :: " << std::flush;
194 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
195 0 : std::cout << " not valid " << std::endl;
196 : }
197 : }
198 :
199 :
200 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
201 :
202 0 : }
203 :
204 :
205 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
206 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
207 : bool
208 0 : SgModifier::isInMemoryPool ()
209 : {
210 0 : typedef unsigned char* TestType;
211 :
212 0 : bool found = false;
213 :
214 0 : ROSE_ASSERT(this != NULL);
215 :
216 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
217 :
218 0 : TestType tested = (TestType) ( this ) ;
219 :
220 0 : std::vector < unsigned char* > :: const_iterator block = SgModifier::pools.begin();
221 :
222 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
223 : // while (found == false && block < Memory_Block_List.end())
224 0 : while ( (found == false) && (block != SgModifier::pools.end()) )
225 : {
226 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgModifier::pool_size * sizeof(SgModifier) ) ) ;
227 0 : ++block;
228 : }
229 :
230 : // Special handling for static data
231 :
232 :
233 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
234 0 : ROSE_ASSERT(found == true);
235 :
236 0 : return found;
237 : }
238 : /* #line 239 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
239 :
240 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
241 :
242 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
243 :
244 : /* #line 245 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
245 :
246 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
247 :
248 : void
249 0 : SgModifierNodes::checkDataMemberPointersIfInMemoryPool()
250 : {
251 : // ------------ checking pointers of SgModifierNodes -------------------
252 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
253 :
254 0 : SgModifierTypePtrVector::iterator i_nodes = p_nodes.begin() ;
255 0 : for ( ; i_nodes != p_nodes.end(); ++i_nodes )
256 : {
257 0 : if ( (*i_nodes) != NULL )
258 : {
259 0 : if ( (*i_nodes)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
260 : {
261 0 : if ( (*i_nodes)->isInMemoryPool() == false )
262 : {
263 0 : std::cout << "SgModifierNodes :: ";
264 0 : std::cout << " p_nodes ( list of poitners to IR nodes ), entry is not in memory pool of ";
265 0 : std::cout << (*i_nodes)->class_name() << std::endl;
266 : }
267 : }
268 : else
269 : {
270 0 : std::cout << "SgModifierNodes :: " << std::flush;
271 0 : std::cout << "SgModifierTypePtrVector p_nodes --> " << std::flush;
272 0 : std::cout << " entry not valid " << std::endl;
273 : }
274 : }
275 : else
276 : {
277 0 : std::cout << "SgModifierTypePtrVector p_nodes --> NULL " << std::endl;
278 : }
279 : }
280 :
281 0 : if ( p_next != NULL )
282 : {
283 0 : if ( p_next->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
284 : {
285 0 : if ( p_next->isInMemoryPool() == false )
286 : {
287 0 : std::cout << "SgModifierNodes :: ";
288 0 : std::cout << " p_next is not in memory pool of ";
289 0 : std::cout << p_next->class_name() << std::endl;
290 : }
291 : }
292 : else
293 : {
294 0 : std::cout << "SgModifierNodes :: " << std::flush;
295 0 : std::cout << "SgModifierNodes* p_next = " << p_next << " --> " << std::flush;
296 0 : std::cout << " not valid " << std::endl;
297 : }
298 : }
299 :
300 0 : if ( p_parent != NULL )
301 : {
302 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
303 : {
304 0 : if ( p_parent->isInMemoryPool() == false )
305 : {
306 0 : std::cout << "SgModifierNodes :: ";
307 0 : std::cout << " p_parent is not in memory pool of ";
308 0 : std::cout << p_parent->class_name() << std::endl;
309 : }
310 : }
311 : else
312 : {
313 0 : std::cout << "SgModifierNodes :: " << std::flush;
314 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
315 0 : std::cout << " not valid " << std::endl;
316 : }
317 : }
318 :
319 :
320 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
321 :
322 0 : }
323 :
324 :
325 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
326 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
327 : bool
328 0 : SgModifierNodes::isInMemoryPool ()
329 : {
330 0 : typedef unsigned char* TestType;
331 :
332 0 : bool found = false;
333 :
334 0 : ROSE_ASSERT(this != NULL);
335 :
336 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
337 :
338 0 : TestType tested = (TestType) ( this ) ;
339 :
340 0 : std::vector < unsigned char* > :: const_iterator block = SgModifierNodes::pools.begin();
341 :
342 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
343 : // while (found == false && block < Memory_Block_List.end())
344 0 : while ( (found == false) && (block != SgModifierNodes::pools.end()) )
345 : {
346 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgModifierNodes::pool_size * sizeof(SgModifierNodes) ) ) ;
347 0 : ++block;
348 : }
349 :
350 : // Special handling for static data
351 :
352 :
353 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
354 0 : ROSE_ASSERT(found == true);
355 :
356 0 : return found;
357 : }
358 : /* #line 359 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
359 :
360 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
361 :
362 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
363 :
364 : /* #line 365 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
365 :
366 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
367 :
368 : void
369 0 : SgConstVolatileModifier::checkDataMemberPointersIfInMemoryPool()
370 : {
371 : // ------------ checking pointers of SgConstVolatileModifier -------------------
372 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
373 :
374 0 : if ( p_parent != NULL )
375 : {
376 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
377 : {
378 0 : if ( p_parent->isInMemoryPool() == false )
379 : {
380 0 : std::cout << "SgConstVolatileModifier :: ";
381 0 : std::cout << " p_parent is not in memory pool of ";
382 0 : std::cout << p_parent->class_name() << std::endl;
383 : }
384 : }
385 : else
386 : {
387 0 : std::cout << "SgConstVolatileModifier :: " << std::flush;
388 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
389 0 : std::cout << " not valid " << std::endl;
390 : }
391 : }
392 :
393 :
394 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
395 :
396 0 : }
397 :
398 :
399 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
400 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
401 : bool
402 0 : SgConstVolatileModifier::isInMemoryPool ()
403 : {
404 0 : typedef unsigned char* TestType;
405 :
406 0 : bool found = false;
407 :
408 0 : ROSE_ASSERT(this != NULL);
409 :
410 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
411 :
412 0 : TestType tested = (TestType) ( this ) ;
413 :
414 0 : std::vector < unsigned char* > :: const_iterator block = SgConstVolatileModifier::pools.begin();
415 :
416 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
417 : // while (found == false && block < Memory_Block_List.end())
418 0 : while ( (found == false) && (block != SgConstVolatileModifier::pools.end()) )
419 : {
420 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgConstVolatileModifier::pool_size * sizeof(SgConstVolatileModifier) ) ) ;
421 0 : ++block;
422 : }
423 :
424 : // Special handling for static data
425 :
426 :
427 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
428 0 : ROSE_ASSERT(found == true);
429 :
430 0 : return found;
431 : }
432 : /* #line 433 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
433 :
434 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
435 :
436 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
437 :
438 : /* #line 439 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
439 :
440 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
441 :
442 : void
443 0 : SgStorageModifier::checkDataMemberPointersIfInMemoryPool()
444 : {
445 : // ------------ checking pointers of SgStorageModifier -------------------
446 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
447 :
448 0 : if ( p_parent != NULL )
449 : {
450 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
451 : {
452 0 : if ( p_parent->isInMemoryPool() == false )
453 : {
454 0 : std::cout << "SgStorageModifier :: ";
455 0 : std::cout << " p_parent is not in memory pool of ";
456 0 : std::cout << p_parent->class_name() << std::endl;
457 : }
458 : }
459 : else
460 : {
461 0 : std::cout << "SgStorageModifier :: " << std::flush;
462 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
463 0 : std::cout << " not valid " << std::endl;
464 : }
465 : }
466 :
467 :
468 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
469 :
470 0 : }
471 :
472 :
473 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
474 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
475 : bool
476 0 : SgStorageModifier::isInMemoryPool ()
477 : {
478 0 : typedef unsigned char* TestType;
479 :
480 0 : bool found = false;
481 :
482 0 : ROSE_ASSERT(this != NULL);
483 :
484 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
485 :
486 0 : TestType tested = (TestType) ( this ) ;
487 :
488 0 : std::vector < unsigned char* > :: const_iterator block = SgStorageModifier::pools.begin();
489 :
490 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
491 : // while (found == false && block < Memory_Block_List.end())
492 0 : while ( (found == false) && (block != SgStorageModifier::pools.end()) )
493 : {
494 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgStorageModifier::pool_size * sizeof(SgStorageModifier) ) ) ;
495 0 : ++block;
496 : }
497 :
498 : // Special handling for static data
499 :
500 :
501 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
502 0 : ROSE_ASSERT(found == true);
503 :
504 0 : return found;
505 : }
506 : /* #line 507 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
507 :
508 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
509 :
510 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
511 :
512 : /* #line 513 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
513 :
514 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
515 :
516 : void
517 0 : SgAccessModifier::checkDataMemberPointersIfInMemoryPool()
518 : {
519 : // ------------ checking pointers of SgAccessModifier -------------------
520 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
521 :
522 0 : if ( p_parent != NULL )
523 : {
524 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
525 : {
526 0 : if ( p_parent->isInMemoryPool() == false )
527 : {
528 0 : std::cout << "SgAccessModifier :: ";
529 0 : std::cout << " p_parent is not in memory pool of ";
530 0 : std::cout << p_parent->class_name() << std::endl;
531 : }
532 : }
533 : else
534 : {
535 0 : std::cout << "SgAccessModifier :: " << std::flush;
536 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
537 0 : std::cout << " not valid " << std::endl;
538 : }
539 : }
540 :
541 :
542 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
543 :
544 0 : }
545 :
546 :
547 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
548 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
549 : bool
550 0 : SgAccessModifier::isInMemoryPool ()
551 : {
552 0 : typedef unsigned char* TestType;
553 :
554 0 : bool found = false;
555 :
556 0 : ROSE_ASSERT(this != NULL);
557 :
558 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
559 :
560 0 : TestType tested = (TestType) ( this ) ;
561 :
562 0 : std::vector < unsigned char* > :: const_iterator block = SgAccessModifier::pools.begin();
563 :
564 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
565 : // while (found == false && block < Memory_Block_List.end())
566 0 : while ( (found == false) && (block != SgAccessModifier::pools.end()) )
567 : {
568 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAccessModifier::pool_size * sizeof(SgAccessModifier) ) ) ;
569 0 : ++block;
570 : }
571 :
572 : // Special handling for static data
573 :
574 :
575 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
576 0 : ROSE_ASSERT(found == true);
577 :
578 0 : return found;
579 : }
580 : /* #line 581 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
581 :
582 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
583 :
584 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
585 :
586 : /* #line 587 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
587 :
588 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
589 :
590 : void
591 0 : SgFunctionModifier::checkDataMemberPointersIfInMemoryPool()
592 : {
593 : // ------------ checking pointers of SgFunctionModifier -------------------
594 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
595 :
596 0 : if ( p_opencl_vec_type != NULL )
597 : {
598 0 : if ( p_opencl_vec_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
599 : {
600 0 : if ( p_opencl_vec_type->isInMemoryPool() == false )
601 : {
602 0 : std::cout << "SgFunctionModifier :: ";
603 0 : std::cout << " p_opencl_vec_type is not in memory pool of ";
604 0 : std::cout << p_opencl_vec_type->class_name() << std::endl;
605 : }
606 : }
607 : else
608 : {
609 0 : std::cout << "SgFunctionModifier :: " << std::flush;
610 0 : std::cout << "SgType * p_opencl_vec_type = " << p_opencl_vec_type << " --> " << std::flush;
611 0 : std::cout << " not valid " << std::endl;
612 : }
613 : }
614 :
615 0 : if ( p_parent != NULL )
616 : {
617 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
618 : {
619 0 : if ( p_parent->isInMemoryPool() == false )
620 : {
621 0 : std::cout << "SgFunctionModifier :: ";
622 0 : std::cout << " p_parent is not in memory pool of ";
623 0 : std::cout << p_parent->class_name() << std::endl;
624 : }
625 : }
626 : else
627 : {
628 0 : std::cout << "SgFunctionModifier :: " << std::flush;
629 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
630 0 : std::cout << " not valid " << std::endl;
631 : }
632 : }
633 :
634 :
635 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
636 :
637 0 : }
638 :
639 :
640 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
641 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
642 : bool
643 0 : SgFunctionModifier::isInMemoryPool ()
644 : {
645 0 : typedef unsigned char* TestType;
646 :
647 0 : bool found = false;
648 :
649 0 : ROSE_ASSERT(this != NULL);
650 :
651 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
652 :
653 0 : TestType tested = (TestType) ( this ) ;
654 :
655 0 : std::vector < unsigned char* > :: const_iterator block = SgFunctionModifier::pools.begin();
656 :
657 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
658 : // while (found == false && block < Memory_Block_List.end())
659 0 : while ( (found == false) && (block != SgFunctionModifier::pools.end()) )
660 : {
661 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFunctionModifier::pool_size * sizeof(SgFunctionModifier) ) ) ;
662 0 : ++block;
663 : }
664 :
665 : // Special handling for static data
666 :
667 :
668 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
669 0 : ROSE_ASSERT(found == true);
670 :
671 0 : return found;
672 : }
673 : /* #line 674 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
674 :
675 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
676 :
677 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
678 :
679 : /* #line 680 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
680 :
681 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
682 :
683 : void
684 0 : SgUPC_AccessModifier::checkDataMemberPointersIfInMemoryPool()
685 : {
686 : // ------------ checking pointers of SgUPC_AccessModifier -------------------
687 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
688 :
689 0 : if ( p_parent != NULL )
690 : {
691 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
692 : {
693 0 : if ( p_parent->isInMemoryPool() == false )
694 : {
695 0 : std::cout << "SgUPC_AccessModifier :: ";
696 0 : std::cout << " p_parent is not in memory pool of ";
697 0 : std::cout << p_parent->class_name() << std::endl;
698 : }
699 : }
700 : else
701 : {
702 0 : std::cout << "SgUPC_AccessModifier :: " << std::flush;
703 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
704 0 : std::cout << " not valid " << std::endl;
705 : }
706 : }
707 :
708 :
709 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
710 :
711 0 : }
712 :
713 :
714 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
715 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
716 : bool
717 0 : SgUPC_AccessModifier::isInMemoryPool ()
718 : {
719 0 : typedef unsigned char* TestType;
720 :
721 0 : bool found = false;
722 :
723 0 : ROSE_ASSERT(this != NULL);
724 :
725 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
726 :
727 0 : TestType tested = (TestType) ( this ) ;
728 :
729 0 : std::vector < unsigned char* > :: const_iterator block = SgUPC_AccessModifier::pools.begin();
730 :
731 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
732 : // while (found == false && block < Memory_Block_List.end())
733 0 : while ( (found == false) && (block != SgUPC_AccessModifier::pools.end()) )
734 : {
735 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUPC_AccessModifier::pool_size * sizeof(SgUPC_AccessModifier) ) ) ;
736 0 : ++block;
737 : }
738 :
739 : // Special handling for static data
740 :
741 :
742 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
743 0 : ROSE_ASSERT(found == true);
744 :
745 0 : return found;
746 : }
747 : /* #line 748 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
748 :
749 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
750 :
751 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
752 :
753 : /* #line 754 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
754 :
755 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
756 :
757 : void
758 0 : SgSpecialFunctionModifier::checkDataMemberPointersIfInMemoryPool()
759 : {
760 : // ------------ checking pointers of SgSpecialFunctionModifier -------------------
761 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
762 :
763 0 : if ( p_parent != NULL )
764 : {
765 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
766 : {
767 0 : if ( p_parent->isInMemoryPool() == false )
768 : {
769 0 : std::cout << "SgSpecialFunctionModifier :: ";
770 0 : std::cout << " p_parent is not in memory pool of ";
771 0 : std::cout << p_parent->class_name() << std::endl;
772 : }
773 : }
774 : else
775 : {
776 0 : std::cout << "SgSpecialFunctionModifier :: " << std::flush;
777 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
778 0 : std::cout << " not valid " << std::endl;
779 : }
780 : }
781 :
782 :
783 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
784 :
785 0 : }
786 :
787 :
788 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
789 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
790 : bool
791 0 : SgSpecialFunctionModifier::isInMemoryPool ()
792 : {
793 0 : typedef unsigned char* TestType;
794 :
795 0 : bool found = false;
796 :
797 0 : ROSE_ASSERT(this != NULL);
798 :
799 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
800 :
801 0 : TestType tested = (TestType) ( this ) ;
802 :
803 0 : std::vector < unsigned char* > :: const_iterator block = SgSpecialFunctionModifier::pools.begin();
804 :
805 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
806 : // while (found == false && block < Memory_Block_List.end())
807 0 : while ( (found == false) && (block != SgSpecialFunctionModifier::pools.end()) )
808 : {
809 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSpecialFunctionModifier::pool_size * sizeof(SgSpecialFunctionModifier) ) ) ;
810 0 : ++block;
811 : }
812 :
813 : // Special handling for static data
814 :
815 :
816 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
817 0 : ROSE_ASSERT(found == true);
818 :
819 0 : return found;
820 : }
821 : /* #line 822 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
822 :
823 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
824 :
825 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
826 :
827 : /* #line 828 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
828 :
829 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
830 :
831 : void
832 0 : SgElaboratedTypeModifier::checkDataMemberPointersIfInMemoryPool()
833 : {
834 : // ------------ checking pointers of SgElaboratedTypeModifier -------------------
835 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
836 :
837 0 : if ( p_parent != NULL )
838 : {
839 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
840 : {
841 0 : if ( p_parent->isInMemoryPool() == false )
842 : {
843 0 : std::cout << "SgElaboratedTypeModifier :: ";
844 0 : std::cout << " p_parent is not in memory pool of ";
845 0 : std::cout << p_parent->class_name() << std::endl;
846 : }
847 : }
848 : else
849 : {
850 0 : std::cout << "SgElaboratedTypeModifier :: " << std::flush;
851 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
852 0 : std::cout << " not valid " << std::endl;
853 : }
854 : }
855 :
856 :
857 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
858 :
859 0 : }
860 :
861 :
862 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
863 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
864 : bool
865 0 : SgElaboratedTypeModifier::isInMemoryPool ()
866 : {
867 0 : typedef unsigned char* TestType;
868 :
869 0 : bool found = false;
870 :
871 0 : ROSE_ASSERT(this != NULL);
872 :
873 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
874 :
875 0 : TestType tested = (TestType) ( this ) ;
876 :
877 0 : std::vector < unsigned char* > :: const_iterator block = SgElaboratedTypeModifier::pools.begin();
878 :
879 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
880 : // while (found == false && block < Memory_Block_List.end())
881 0 : while ( (found == false) && (block != SgElaboratedTypeModifier::pools.end()) )
882 : {
883 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgElaboratedTypeModifier::pool_size * sizeof(SgElaboratedTypeModifier) ) ) ;
884 0 : ++block;
885 : }
886 :
887 : // Special handling for static data
888 :
889 :
890 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
891 0 : ROSE_ASSERT(found == true);
892 :
893 0 : return found;
894 : }
895 : /* #line 896 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
896 :
897 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
898 :
899 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
900 :
901 : /* #line 902 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
902 :
903 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
904 :
905 : void
906 0 : SgLinkageModifier::checkDataMemberPointersIfInMemoryPool()
907 : {
908 : // ------------ checking pointers of SgLinkageModifier -------------------
909 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
910 :
911 0 : if ( p_parent != NULL )
912 : {
913 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
914 : {
915 0 : if ( p_parent->isInMemoryPool() == false )
916 : {
917 0 : std::cout << "SgLinkageModifier :: ";
918 0 : std::cout << " p_parent is not in memory pool of ";
919 0 : std::cout << p_parent->class_name() << std::endl;
920 : }
921 : }
922 : else
923 : {
924 0 : std::cout << "SgLinkageModifier :: " << std::flush;
925 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
926 0 : std::cout << " not valid " << std::endl;
927 : }
928 : }
929 :
930 :
931 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
932 :
933 0 : }
934 :
935 :
936 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
937 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
938 : bool
939 0 : SgLinkageModifier::isInMemoryPool ()
940 : {
941 0 : typedef unsigned char* TestType;
942 :
943 0 : bool found = false;
944 :
945 0 : ROSE_ASSERT(this != NULL);
946 :
947 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
948 :
949 0 : TestType tested = (TestType) ( this ) ;
950 :
951 0 : std::vector < unsigned char* > :: const_iterator block = SgLinkageModifier::pools.begin();
952 :
953 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
954 : // while (found == false && block < Memory_Block_List.end())
955 0 : while ( (found == false) && (block != SgLinkageModifier::pools.end()) )
956 : {
957 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLinkageModifier::pool_size * sizeof(SgLinkageModifier) ) ) ;
958 0 : ++block;
959 : }
960 :
961 : // Special handling for static data
962 :
963 :
964 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
965 0 : ROSE_ASSERT(found == true);
966 :
967 0 : return found;
968 : }
969 : /* #line 970 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
970 :
971 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
972 :
973 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
974 :
975 : /* #line 976 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
976 :
977 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
978 :
979 : void
980 0 : SgBaseClassModifier::checkDataMemberPointersIfInMemoryPool()
981 : {
982 : // ------------ checking pointers of SgBaseClassModifier -------------------
983 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
984 :
985 0 : if ( p_parent != NULL )
986 : {
987 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
988 : {
989 0 : if ( p_parent->isInMemoryPool() == false )
990 : {
991 0 : std::cout << "SgBaseClassModifier :: ";
992 0 : std::cout << " p_parent is not in memory pool of ";
993 0 : std::cout << p_parent->class_name() << std::endl;
994 : }
995 : }
996 : else
997 : {
998 0 : std::cout << "SgBaseClassModifier :: " << std::flush;
999 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
1000 0 : std::cout << " not valid " << std::endl;
1001 : }
1002 : }
1003 :
1004 :
1005 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1006 :
1007 0 : }
1008 :
1009 :
1010 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
1011 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
1012 : bool
1013 0 : SgBaseClassModifier::isInMemoryPool ()
1014 : {
1015 0 : typedef unsigned char* TestType;
1016 :
1017 0 : bool found = false;
1018 :
1019 0 : ROSE_ASSERT(this != NULL);
1020 :
1021 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
1022 :
1023 0 : TestType tested = (TestType) ( this ) ;
1024 :
1025 0 : std::vector < unsigned char* > :: const_iterator block = SgBaseClassModifier::pools.begin();
1026 :
1027 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
1028 : // while (found == false && block < Memory_Block_List.end())
1029 0 : while ( (found == false) && (block != SgBaseClassModifier::pools.end()) )
1030 : {
1031 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgBaseClassModifier::pool_size * sizeof(SgBaseClassModifier) ) ) ;
1032 0 : ++block;
1033 : }
1034 :
1035 : // Special handling for static data
1036 :
1037 :
1038 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
1039 0 : ROSE_ASSERT(found == true);
1040 :
1041 0 : return found;
1042 : }
1043 : /* #line 1044 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1044 :
1045 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
1046 :
1047 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1048 :
1049 : /* #line 1050 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1050 :
1051 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1052 :
1053 : void
1054 0 : SgStructureModifier::checkDataMemberPointersIfInMemoryPool()
1055 : {
1056 : // ------------ checking pointers of SgStructureModifier -------------------
1057 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
1058 :
1059 0 : if ( p_parent != NULL )
1060 : {
1061 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
1062 : {
1063 0 : if ( p_parent->isInMemoryPool() == false )
1064 : {
1065 0 : std::cout << "SgStructureModifier :: ";
1066 0 : std::cout << " p_parent is not in memory pool of ";
1067 0 : std::cout << p_parent->class_name() << std::endl;
1068 : }
1069 : }
1070 : else
1071 : {
1072 0 : std::cout << "SgStructureModifier :: " << std::flush;
1073 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
1074 0 : std::cout << " not valid " << std::endl;
1075 : }
1076 : }
1077 :
1078 :
1079 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1080 :
1081 0 : }
1082 :
1083 :
1084 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
1085 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
1086 : bool
1087 0 : SgStructureModifier::isInMemoryPool ()
1088 : {
1089 0 : typedef unsigned char* TestType;
1090 :
1091 0 : bool found = false;
1092 :
1093 0 : ROSE_ASSERT(this != NULL);
1094 :
1095 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
1096 :
1097 0 : TestType tested = (TestType) ( this ) ;
1098 :
1099 0 : std::vector < unsigned char* > :: const_iterator block = SgStructureModifier::pools.begin();
1100 :
1101 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
1102 : // while (found == false && block < Memory_Block_List.end())
1103 0 : while ( (found == false) && (block != SgStructureModifier::pools.end()) )
1104 : {
1105 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgStructureModifier::pool_size * sizeof(SgStructureModifier) ) ) ;
1106 0 : ++block;
1107 : }
1108 :
1109 : // Special handling for static data
1110 :
1111 :
1112 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
1113 0 : ROSE_ASSERT(found == true);
1114 :
1115 0 : return found;
1116 : }
1117 : /* #line 1118 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1118 :
1119 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
1120 :
1121 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1122 :
1123 : /* #line 1124 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1124 :
1125 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1126 :
1127 : void
1128 0 : SgTypeModifier::checkDataMemberPointersIfInMemoryPool()
1129 : {
1130 : // ------------ checking pointers of SgTypeModifier -------------------
1131 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
1132 :
1133 0 : if ( p_parent != NULL )
1134 : {
1135 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
1136 : {
1137 0 : if ( p_parent->isInMemoryPool() == false )
1138 : {
1139 0 : std::cout << "SgTypeModifier :: ";
1140 0 : std::cout << " p_parent is not in memory pool of ";
1141 0 : std::cout << p_parent->class_name() << std::endl;
1142 : }
1143 : }
1144 : else
1145 : {
1146 0 : std::cout << "SgTypeModifier :: " << std::flush;
1147 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
1148 0 : std::cout << " not valid " << std::endl;
1149 : }
1150 : }
1151 :
1152 :
1153 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1154 :
1155 0 : }
1156 :
1157 :
1158 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
1159 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
1160 : bool
1161 0 : SgTypeModifier::isInMemoryPool ()
1162 : {
1163 0 : typedef unsigned char* TestType;
1164 :
1165 0 : bool found = false;
1166 :
1167 0 : ROSE_ASSERT(this != NULL);
1168 :
1169 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
1170 :
1171 0 : TestType tested = (TestType) ( this ) ;
1172 :
1173 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeModifier::pools.begin();
1174 :
1175 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
1176 : // while (found == false && block < Memory_Block_List.end())
1177 0 : while ( (found == false) && (block != SgTypeModifier::pools.end()) )
1178 : {
1179 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeModifier::pool_size * sizeof(SgTypeModifier) ) ) ;
1180 0 : ++block;
1181 : }
1182 :
1183 : // Special handling for static data
1184 :
1185 :
1186 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
1187 0 : ROSE_ASSERT(found == true);
1188 :
1189 0 : return found;
1190 : }
1191 : /* #line 1192 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1192 :
1193 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
1194 :
1195 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1196 :
1197 : /* #line 1198 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1198 :
1199 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1200 :
1201 : void
1202 0 : SgDeclarationModifier::checkDataMemberPointersIfInMemoryPool()
1203 : {
1204 : // ------------ checking pointers of SgDeclarationModifier -------------------
1205 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
1206 :
1207 0 : if ( p_parent != NULL )
1208 : {
1209 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
1210 : {
1211 0 : if ( p_parent->isInMemoryPool() == false )
1212 : {
1213 0 : std::cout << "SgDeclarationModifier :: ";
1214 0 : std::cout << " p_parent is not in memory pool of ";
1215 0 : std::cout << p_parent->class_name() << std::endl;
1216 : }
1217 : }
1218 : else
1219 : {
1220 0 : std::cout << "SgDeclarationModifier :: " << std::flush;
1221 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
1222 0 : std::cout << " not valid " << std::endl;
1223 : }
1224 : }
1225 :
1226 :
1227 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1228 :
1229 0 : }
1230 :
1231 :
1232 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
1233 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
1234 : bool
1235 0 : SgDeclarationModifier::isInMemoryPool ()
1236 : {
1237 0 : typedef unsigned char* TestType;
1238 :
1239 0 : bool found = false;
1240 :
1241 0 : ROSE_ASSERT(this != NULL);
1242 :
1243 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
1244 :
1245 0 : TestType tested = (TestType) ( this ) ;
1246 :
1247 0 : std::vector < unsigned char* > :: const_iterator block = SgDeclarationModifier::pools.begin();
1248 :
1249 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
1250 : // while (found == false && block < Memory_Block_List.end())
1251 0 : while ( (found == false) && (block != SgDeclarationModifier::pools.end()) )
1252 : {
1253 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDeclarationModifier::pool_size * sizeof(SgDeclarationModifier) ) ) ;
1254 0 : ++block;
1255 : }
1256 :
1257 : // Special handling for static data
1258 :
1259 :
1260 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
1261 0 : ROSE_ASSERT(found == true);
1262 :
1263 0 : return found;
1264 : }
1265 : /* #line 1266 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1266 :
1267 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
1268 :
1269 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1270 :
1271 : /* #line 1272 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1272 :
1273 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1274 :
1275 : void
1276 0 : SgOpenclAccessModeModifier::checkDataMemberPointersIfInMemoryPool()
1277 : {
1278 : // ------------ checking pointers of SgOpenclAccessModeModifier -------------------
1279 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
1280 :
1281 0 : if ( p_parent != NULL )
1282 : {
1283 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
1284 : {
1285 0 : if ( p_parent->isInMemoryPool() == false )
1286 : {
1287 0 : std::cout << "SgOpenclAccessModeModifier :: ";
1288 0 : std::cout << " p_parent is not in memory pool of ";
1289 0 : std::cout << p_parent->class_name() << std::endl;
1290 : }
1291 : }
1292 : else
1293 : {
1294 0 : std::cout << "SgOpenclAccessModeModifier :: " << std::flush;
1295 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
1296 0 : std::cout << " not valid " << std::endl;
1297 : }
1298 : }
1299 :
1300 :
1301 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1302 :
1303 0 : }
1304 :
1305 :
1306 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
1307 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
1308 : bool
1309 0 : SgOpenclAccessModeModifier::isInMemoryPool ()
1310 : {
1311 0 : typedef unsigned char* TestType;
1312 :
1313 0 : bool found = false;
1314 :
1315 0 : ROSE_ASSERT(this != NULL);
1316 :
1317 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
1318 :
1319 0 : TestType tested = (TestType) ( this ) ;
1320 :
1321 0 : std::vector < unsigned char* > :: const_iterator block = SgOpenclAccessModeModifier::pools.begin();
1322 :
1323 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
1324 : // while (found == false && block < Memory_Block_List.end())
1325 0 : while ( (found == false) && (block != SgOpenclAccessModeModifier::pools.end()) )
1326 : {
1327 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOpenclAccessModeModifier::pool_size * sizeof(SgOpenclAccessModeModifier) ) ) ;
1328 0 : ++block;
1329 : }
1330 :
1331 : // Special handling for static data
1332 :
1333 :
1334 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
1335 0 : ROSE_ASSERT(found == true);
1336 :
1337 0 : return found;
1338 : }
1339 : /* #line 1340 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1340 :
1341 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
1342 :
1343 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1344 :
1345 : /* #line 1346 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1346 :
1347 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1348 :
1349 : void
1350 0 : SgName::checkDataMemberPointersIfInMemoryPool()
1351 : {
1352 : // ------------ checking pointers of SgName -------------------
1353 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
1354 :
1355 0 : if ( p_parent != NULL )
1356 : {
1357 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
1358 : {
1359 0 : if ( p_parent->isInMemoryPool() == false )
1360 : {
1361 0 : std::cout << "SgName :: ";
1362 0 : std::cout << " p_parent is not in memory pool of ";
1363 0 : std::cout << p_parent->class_name() << std::endl;
1364 : }
1365 : }
1366 : else
1367 : {
1368 0 : std::cout << "SgName :: " << std::flush;
1369 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
1370 0 : std::cout << " not valid " << std::endl;
1371 : }
1372 : }
1373 :
1374 :
1375 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1376 :
1377 0 : }
1378 :
1379 :
1380 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
1381 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
1382 : bool
1383 0 : SgName::isInMemoryPool ()
1384 : {
1385 0 : typedef unsigned char* TestType;
1386 :
1387 0 : bool found = false;
1388 :
1389 0 : ROSE_ASSERT(this != NULL);
1390 :
1391 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
1392 :
1393 0 : TestType tested = (TestType) ( this ) ;
1394 :
1395 0 : std::vector < unsigned char* > :: const_iterator block = SgName::pools.begin();
1396 :
1397 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
1398 : // while (found == false && block < Memory_Block_List.end())
1399 0 : while ( (found == false) && (block != SgName::pools.end()) )
1400 : {
1401 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgName::pool_size * sizeof(SgName) ) ) ;
1402 0 : ++block;
1403 : }
1404 :
1405 : // Special handling for static data
1406 :
1407 :
1408 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
1409 0 : ROSE_ASSERT(found == true);
1410 :
1411 0 : return found;
1412 : }
1413 : /* #line 1414 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1414 :
1415 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
1416 :
1417 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1418 :
1419 : /* #line 1420 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1420 :
1421 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1422 :
1423 : void
1424 0 : SgSymbolTable::checkDataMemberPointersIfInMemoryPool()
1425 : {
1426 : // ------------ checking pointers of SgSymbolTable -------------------
1427 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
1428 :
1429 0 : if ( p_table != NULL )
1430 : {
1431 0 : rose_hash_multimap::iterator it;
1432 0 : for (it = p_table->begin(); it != p_table->end(); ++it)
1433 : {
1434 0 : if ( it->second != NULL )
1435 : {
1436 0 : if ( it->second->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
1437 : {
1438 0 : if ( it->second->isInMemoryPool() == false )
1439 : {
1440 0 : std::cout << "SgSymbolTable :: ";
1441 0 : std::cout << " p_table ( rose_hash_multimap, second entries (SgSymbol) ), entry is not in memory pool of ";
1442 0 : std::cout << it->second->class_name() << std::endl;
1443 : }
1444 : }
1445 : else
1446 : {
1447 0 : std::cout << "SgSymbolTable :: " << std::flush;
1448 0 : std::cout << " rose_hash_multimap* p_table --> " << std::flush;
1449 0 : std::cout << " entry not valid " << std::endl;
1450 : }
1451 : }
1452 : else
1453 : {
1454 0 : std::cout << " rose_hash_multimap* p_table --> NULL " << std::endl;
1455 : }
1456 : }
1457 : }
1458 :
1459 0 : if ( p_parent != NULL )
1460 : {
1461 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
1462 : {
1463 0 : if ( p_parent->isInMemoryPool() == false )
1464 : {
1465 0 : std::cout << "SgSymbolTable :: ";
1466 0 : std::cout << " p_parent is not in memory pool of ";
1467 0 : std::cout << p_parent->class_name() << std::endl;
1468 : }
1469 : }
1470 : else
1471 : {
1472 0 : std::cout << "SgSymbolTable :: " << std::flush;
1473 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
1474 0 : std::cout << " not valid " << std::endl;
1475 : }
1476 : }
1477 :
1478 :
1479 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1480 :
1481 0 : }
1482 :
1483 :
1484 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
1485 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
1486 : bool
1487 0 : SgSymbolTable::isInMemoryPool ()
1488 : {
1489 0 : typedef unsigned char* TestType;
1490 :
1491 0 : bool found = false;
1492 :
1493 0 : ROSE_ASSERT(this != NULL);
1494 :
1495 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
1496 :
1497 0 : TestType tested = (TestType) ( this ) ;
1498 :
1499 0 : std::vector < unsigned char* > :: const_iterator block = SgSymbolTable::pools.begin();
1500 :
1501 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
1502 : // while (found == false && block < Memory_Block_List.end())
1503 0 : while ( (found == false) && (block != SgSymbolTable::pools.end()) )
1504 : {
1505 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSymbolTable::pool_size * sizeof(SgSymbolTable) ) ) ;
1506 0 : ++block;
1507 : }
1508 :
1509 : // Special handling for static data
1510 :
1511 :
1512 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
1513 0 : ROSE_ASSERT(found == true);
1514 :
1515 0 : return found;
1516 : }
1517 : /* #line 1518 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1518 :
1519 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
1520 :
1521 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1522 :
1523 : /* #line 1524 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1524 :
1525 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1526 :
1527 : void
1528 0 : SgAttribute::checkDataMemberPointersIfInMemoryPool()
1529 : {
1530 : // ------------ checking pointers of SgAttribute -------------------
1531 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
1532 :
1533 0 : if ( p_parent != NULL )
1534 : {
1535 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
1536 : {
1537 0 : if ( p_parent->isInMemoryPool() == false )
1538 : {
1539 0 : std::cout << "SgAttribute :: ";
1540 0 : std::cout << " p_parent is not in memory pool of ";
1541 0 : std::cout << p_parent->class_name() << std::endl;
1542 : }
1543 : }
1544 : else
1545 : {
1546 0 : std::cout << "SgAttribute :: " << std::flush;
1547 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
1548 0 : std::cout << " not valid " << std::endl;
1549 : }
1550 : }
1551 :
1552 :
1553 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1554 :
1555 0 : }
1556 :
1557 :
1558 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
1559 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
1560 : bool
1561 0 : SgAttribute::isInMemoryPool ()
1562 : {
1563 0 : typedef unsigned char* TestType;
1564 :
1565 0 : bool found = false;
1566 :
1567 0 : ROSE_ASSERT(this != NULL);
1568 :
1569 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
1570 :
1571 0 : TestType tested = (TestType) ( this ) ;
1572 :
1573 0 : std::vector < unsigned char* > :: const_iterator block = SgAttribute::pools.begin();
1574 :
1575 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
1576 : // while (found == false && block < Memory_Block_List.end())
1577 0 : while ( (found == false) && (block != SgAttribute::pools.end()) )
1578 : {
1579 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAttribute::pool_size * sizeof(SgAttribute) ) ) ;
1580 0 : ++block;
1581 : }
1582 :
1583 : // Special handling for static data
1584 :
1585 :
1586 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
1587 0 : ROSE_ASSERT(found == true);
1588 :
1589 0 : return found;
1590 : }
1591 : /* #line 1592 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1592 :
1593 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
1594 :
1595 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1596 :
1597 : /* #line 1598 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1598 :
1599 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1600 :
1601 : void
1602 0 : SgPragma::checkDataMemberPointersIfInMemoryPool()
1603 : {
1604 : // ------------ checking pointers of SgPragma -------------------
1605 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
1606 :
1607 0 : if ( p_startOfConstruct != NULL )
1608 : {
1609 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
1610 : {
1611 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
1612 : {
1613 0 : std::cout << "SgPragma :: ";
1614 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
1615 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
1616 : }
1617 : }
1618 : else
1619 : {
1620 0 : std::cout << "SgPragma :: " << std::flush;
1621 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
1622 0 : std::cout << " not valid " << std::endl;
1623 : }
1624 : }
1625 :
1626 0 : if ( p_endOfConstruct != NULL )
1627 : {
1628 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
1629 : {
1630 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
1631 : {
1632 0 : std::cout << "SgPragma :: ";
1633 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
1634 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
1635 : }
1636 : }
1637 : else
1638 : {
1639 0 : std::cout << "SgPragma :: " << std::flush;
1640 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
1641 0 : std::cout << " not valid " << std::endl;
1642 : }
1643 : }
1644 :
1645 0 : if ( p_args != NULL )
1646 : {
1647 0 : if ( p_args->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
1648 : {
1649 0 : if ( p_args->isInMemoryPool() == false )
1650 : {
1651 0 : std::cout << "SgPragma :: ";
1652 0 : std::cout << " p_args is not in memory pool of ";
1653 0 : std::cout << p_args->class_name() << std::endl;
1654 : }
1655 : }
1656 : else
1657 : {
1658 0 : std::cout << "SgPragma :: " << std::flush;
1659 0 : std::cout << "SgExprListExp* p_args = " << p_args << " --> " << std::flush;
1660 0 : std::cout << " not valid " << std::endl;
1661 : }
1662 : }
1663 :
1664 0 : if ( p_parent != NULL )
1665 : {
1666 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
1667 : {
1668 0 : if ( p_parent->isInMemoryPool() == false )
1669 : {
1670 0 : std::cout << "SgPragma :: ";
1671 0 : std::cout << " p_parent is not in memory pool of ";
1672 0 : std::cout << p_parent->class_name() << std::endl;
1673 : }
1674 : }
1675 : else
1676 : {
1677 0 : std::cout << "SgPragma :: " << std::flush;
1678 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
1679 0 : std::cout << " not valid " << std::endl;
1680 : }
1681 : }
1682 :
1683 :
1684 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1685 :
1686 0 : }
1687 :
1688 :
1689 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
1690 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
1691 : bool
1692 0 : SgPragma::isInMemoryPool ()
1693 : {
1694 0 : typedef unsigned char* TestType;
1695 :
1696 0 : bool found = false;
1697 :
1698 0 : ROSE_ASSERT(this != NULL);
1699 :
1700 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
1701 :
1702 0 : TestType tested = (TestType) ( this ) ;
1703 :
1704 0 : std::vector < unsigned char* > :: const_iterator block = SgPragma::pools.begin();
1705 :
1706 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
1707 : // while (found == false && block < Memory_Block_List.end())
1708 0 : while ( (found == false) && (block != SgPragma::pools.end()) )
1709 : {
1710 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgPragma::pool_size * sizeof(SgPragma) ) ) ;
1711 0 : ++block;
1712 : }
1713 :
1714 : // Special handling for static data
1715 :
1716 :
1717 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
1718 0 : ROSE_ASSERT(found == true);
1719 :
1720 0 : return found;
1721 : }
1722 : /* #line 1723 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1723 :
1724 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
1725 :
1726 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1727 :
1728 : /* #line 1729 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1729 :
1730 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1731 :
1732 : void
1733 0 : SgBitAttribute::checkDataMemberPointersIfInMemoryPool()
1734 : {
1735 : // ------------ checking pointers of SgBitAttribute -------------------
1736 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
1737 :
1738 0 : if ( p_parent != NULL )
1739 : {
1740 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
1741 : {
1742 0 : if ( p_parent->isInMemoryPool() == false )
1743 : {
1744 0 : std::cout << "SgBitAttribute :: ";
1745 0 : std::cout << " p_parent is not in memory pool of ";
1746 0 : std::cout << p_parent->class_name() << std::endl;
1747 : }
1748 : }
1749 : else
1750 : {
1751 0 : std::cout << "SgBitAttribute :: " << std::flush;
1752 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
1753 0 : std::cout << " not valid " << std::endl;
1754 : }
1755 : }
1756 :
1757 :
1758 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1759 :
1760 0 : }
1761 :
1762 :
1763 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
1764 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
1765 : bool
1766 0 : SgBitAttribute::isInMemoryPool ()
1767 : {
1768 0 : typedef unsigned char* TestType;
1769 :
1770 0 : bool found = false;
1771 :
1772 0 : ROSE_ASSERT(this != NULL);
1773 :
1774 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
1775 :
1776 0 : TestType tested = (TestType) ( this ) ;
1777 :
1778 0 : std::vector < unsigned char* > :: const_iterator block = SgBitAttribute::pools.begin();
1779 :
1780 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
1781 : // while (found == false && block < Memory_Block_List.end())
1782 0 : while ( (found == false) && (block != SgBitAttribute::pools.end()) )
1783 : {
1784 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgBitAttribute::pool_size * sizeof(SgBitAttribute) ) ) ;
1785 0 : ++block;
1786 : }
1787 :
1788 : // Special handling for static data
1789 :
1790 :
1791 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
1792 0 : ROSE_ASSERT(found == true);
1793 :
1794 0 : return found;
1795 : }
1796 : /* #line 1797 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1797 :
1798 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
1799 :
1800 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1801 :
1802 : /* #line 1803 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1803 :
1804 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1805 :
1806 : void
1807 0 : SgFuncDecl_attr::checkDataMemberPointersIfInMemoryPool()
1808 : {
1809 : // ------------ checking pointers of SgFuncDecl_attr -------------------
1810 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
1811 :
1812 0 : if ( p_parent != NULL )
1813 : {
1814 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
1815 : {
1816 0 : if ( p_parent->isInMemoryPool() == false )
1817 : {
1818 0 : std::cout << "SgFuncDecl_attr :: ";
1819 0 : std::cout << " p_parent is not in memory pool of ";
1820 0 : std::cout << p_parent->class_name() << std::endl;
1821 : }
1822 : }
1823 : else
1824 : {
1825 0 : std::cout << "SgFuncDecl_attr :: " << std::flush;
1826 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
1827 0 : std::cout << " not valid " << std::endl;
1828 : }
1829 : }
1830 :
1831 :
1832 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1833 :
1834 0 : }
1835 :
1836 :
1837 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
1838 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
1839 : bool
1840 0 : SgFuncDecl_attr::isInMemoryPool ()
1841 : {
1842 0 : typedef unsigned char* TestType;
1843 :
1844 0 : bool found = false;
1845 :
1846 0 : ROSE_ASSERT(this != NULL);
1847 :
1848 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
1849 :
1850 0 : TestType tested = (TestType) ( this ) ;
1851 :
1852 0 : std::vector < unsigned char* > :: const_iterator block = SgFuncDecl_attr::pools.begin();
1853 :
1854 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
1855 : // while (found == false && block < Memory_Block_List.end())
1856 0 : while ( (found == false) && (block != SgFuncDecl_attr::pools.end()) )
1857 : {
1858 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFuncDecl_attr::pool_size * sizeof(SgFuncDecl_attr) ) ) ;
1859 0 : ++block;
1860 : }
1861 :
1862 : // Special handling for static data
1863 :
1864 :
1865 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
1866 0 : ROSE_ASSERT(found == true);
1867 :
1868 0 : return found;
1869 : }
1870 : /* #line 1871 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1871 :
1872 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
1873 :
1874 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1875 :
1876 : /* #line 1877 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1877 :
1878 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1879 :
1880 : void
1881 0 : SgClassDecl_attr::checkDataMemberPointersIfInMemoryPool()
1882 : {
1883 : // ------------ checking pointers of SgClassDecl_attr -------------------
1884 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
1885 :
1886 0 : if ( p_parent != NULL )
1887 : {
1888 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
1889 : {
1890 0 : if ( p_parent->isInMemoryPool() == false )
1891 : {
1892 0 : std::cout << "SgClassDecl_attr :: ";
1893 0 : std::cout << " p_parent is not in memory pool of ";
1894 0 : std::cout << p_parent->class_name() << std::endl;
1895 : }
1896 : }
1897 : else
1898 : {
1899 0 : std::cout << "SgClassDecl_attr :: " << std::flush;
1900 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
1901 0 : std::cout << " not valid " << std::endl;
1902 : }
1903 : }
1904 :
1905 :
1906 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1907 :
1908 0 : }
1909 :
1910 :
1911 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
1912 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
1913 : bool
1914 0 : SgClassDecl_attr::isInMemoryPool ()
1915 : {
1916 0 : typedef unsigned char* TestType;
1917 :
1918 0 : bool found = false;
1919 :
1920 0 : ROSE_ASSERT(this != NULL);
1921 :
1922 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
1923 :
1924 0 : TestType tested = (TestType) ( this ) ;
1925 :
1926 0 : std::vector < unsigned char* > :: const_iterator block = SgClassDecl_attr::pools.begin();
1927 :
1928 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
1929 : // while (found == false && block < Memory_Block_List.end())
1930 0 : while ( (found == false) && (block != SgClassDecl_attr::pools.end()) )
1931 : {
1932 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgClassDecl_attr::pool_size * sizeof(SgClassDecl_attr) ) ) ;
1933 0 : ++block;
1934 : }
1935 :
1936 : // Special handling for static data
1937 :
1938 :
1939 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
1940 0 : ROSE_ASSERT(found == true);
1941 :
1942 0 : return found;
1943 : }
1944 : /* #line 1945 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1945 :
1946 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
1947 :
1948 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1949 :
1950 : /* #line 1951 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
1951 :
1952 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1953 :
1954 : void
1955 0 : Sg_File_Info::checkDataMemberPointersIfInMemoryPool()
1956 : {
1957 : // ------------ checking pointers of Sg_File_Info -------------------
1958 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
1959 :
1960 0 : if ( p_parent != NULL )
1961 : {
1962 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
1963 : {
1964 0 : if ( p_parent->isInMemoryPool() == false )
1965 : {
1966 0 : std::cout << "Sg_File_Info :: ";
1967 0 : std::cout << " p_parent is not in memory pool of ";
1968 0 : std::cout << p_parent->class_name() << std::endl;
1969 : }
1970 : }
1971 : else
1972 : {
1973 0 : std::cout << "Sg_File_Info :: " << std::flush;
1974 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
1975 0 : std::cout << " not valid " << std::endl;
1976 : }
1977 : }
1978 :
1979 :
1980 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
1981 :
1982 0 : }
1983 :
1984 :
1985 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
1986 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
1987 : bool
1988 0 : Sg_File_Info::isInMemoryPool ()
1989 : {
1990 0 : typedef unsigned char* TestType;
1991 :
1992 0 : bool found = false;
1993 :
1994 0 : ROSE_ASSERT(this != NULL);
1995 :
1996 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
1997 :
1998 0 : TestType tested = (TestType) ( this ) ;
1999 :
2000 0 : std::vector < unsigned char* > :: const_iterator block = Sg_File_Info::pools.begin();
2001 :
2002 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
2003 : // while (found == false && block < Memory_Block_List.end())
2004 0 : while ( (found == false) && (block != Sg_File_Info::pools.end()) )
2005 : {
2006 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + Sg_File_Info::pool_size * sizeof(Sg_File_Info) ) ) ;
2007 0 : ++block;
2008 : }
2009 :
2010 : // Special handling for static data
2011 :
2012 :
2013 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
2014 0 : ROSE_ASSERT(found == true);
2015 :
2016 0 : return found;
2017 : }
2018 : /* #line 2019 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
2019 :
2020 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
2021 :
2022 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2023 :
2024 : /* #line 2025 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
2025 :
2026 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2027 :
2028 : void
2029 0 : SgFile::checkDataMemberPointersIfInMemoryPool()
2030 : {
2031 : // ------------ checking pointers of SgFile -------------------
2032 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
2033 :
2034 0 : if ( p_startOfConstruct != NULL )
2035 : {
2036 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2037 : {
2038 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
2039 : {
2040 0 : std::cout << "SgFile :: ";
2041 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
2042 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
2043 : }
2044 : }
2045 : else
2046 : {
2047 0 : std::cout << "SgFile :: " << std::flush;
2048 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
2049 0 : std::cout << " not valid " << std::endl;
2050 : }
2051 : }
2052 :
2053 0 : if ( p_parent != NULL )
2054 : {
2055 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2056 : {
2057 0 : if ( p_parent->isInMemoryPool() == false )
2058 : {
2059 0 : std::cout << "SgFile :: ";
2060 0 : std::cout << " p_parent is not in memory pool of ";
2061 0 : std::cout << p_parent->class_name() << std::endl;
2062 : }
2063 : }
2064 : else
2065 : {
2066 0 : std::cout << "SgFile :: " << std::flush;
2067 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
2068 0 : std::cout << " not valid " << std::endl;
2069 : }
2070 : }
2071 :
2072 :
2073 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2074 :
2075 0 : }
2076 :
2077 :
2078 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
2079 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
2080 : bool
2081 0 : SgFile::isInMemoryPool ()
2082 : {
2083 0 : typedef unsigned char* TestType;
2084 :
2085 0 : bool found = false;
2086 :
2087 0 : ROSE_ASSERT(this != NULL);
2088 :
2089 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
2090 :
2091 0 : TestType tested = (TestType) ( this ) ;
2092 :
2093 0 : std::vector < unsigned char* > :: const_iterator block = SgFile::pools.begin();
2094 :
2095 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
2096 : // while (found == false && block < Memory_Block_List.end())
2097 0 : while ( (found == false) && (block != SgFile::pools.end()) )
2098 : {
2099 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFile::pool_size * sizeof(SgFile) ) ) ;
2100 0 : ++block;
2101 : }
2102 :
2103 : // Special handling for static data
2104 :
2105 :
2106 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
2107 0 : ROSE_ASSERT(found == true);
2108 :
2109 0 : return found;
2110 : }
2111 : /* #line 2112 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
2112 :
2113 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
2114 :
2115 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2116 :
2117 : /* #line 2118 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
2118 :
2119 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2120 :
2121 : void
2122 0 : SgSourceFile::checkDataMemberPointersIfInMemoryPool()
2123 : {
2124 : // ------------ checking pointers of SgSourceFile -------------------
2125 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
2126 :
2127 0 : if ( p_globalScope != NULL )
2128 : {
2129 0 : if ( p_globalScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2130 : {
2131 0 : if ( p_globalScope->isInMemoryPool() == false )
2132 : {
2133 0 : std::cout << "SgSourceFile :: ";
2134 0 : std::cout << " p_globalScope is not in memory pool of ";
2135 0 : std::cout << p_globalScope->class_name() << std::endl;
2136 : }
2137 : }
2138 : else
2139 : {
2140 0 : std::cout << "SgSourceFile :: " << std::flush;
2141 0 : std::cout << "SgGlobal* p_globalScope = " << p_globalScope << " --> " << std::flush;
2142 0 : std::cout << " not valid " << std::endl;
2143 : }
2144 : }
2145 :
2146 0 : SgModuleStatementPtrList::iterator i_module_list = p_module_list.begin() ;
2147 0 : for ( ; i_module_list != p_module_list.end(); ++i_module_list )
2148 : {
2149 0 : if ( (*i_module_list) != NULL )
2150 : {
2151 0 : if ( (*i_module_list)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2152 : {
2153 0 : if ( (*i_module_list)->isInMemoryPool() == false )
2154 : {
2155 0 : std::cout << "SgSourceFile :: ";
2156 0 : std::cout << " p_module_list ( list of poitners to IR nodes ), entry is not in memory pool of ";
2157 0 : std::cout << (*i_module_list)->class_name() << std::endl;
2158 : }
2159 : }
2160 : else
2161 : {
2162 0 : std::cout << "SgSourceFile :: " << std::flush;
2163 0 : std::cout << "SgModuleStatementPtrList p_module_list --> " << std::flush;
2164 0 : std::cout << " entry not valid " << std::endl;
2165 : }
2166 : }
2167 : else
2168 : {
2169 0 : std::cout << "SgModuleStatementPtrList p_module_list --> NULL " << std::endl;
2170 : }
2171 : }
2172 :
2173 0 : SgTokenPtrList::iterator i_token_list = p_token_list.begin() ;
2174 0 : for ( ; i_token_list != p_token_list.end(); ++i_token_list )
2175 : {
2176 0 : if ( (*i_token_list) != NULL )
2177 : {
2178 0 : if ( (*i_token_list)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2179 : {
2180 0 : if ( (*i_token_list)->isInMemoryPool() == false )
2181 : {
2182 0 : std::cout << "SgSourceFile :: ";
2183 0 : std::cout << " p_token_list ( list of poitners to IR nodes ), entry is not in memory pool of ";
2184 0 : std::cout << (*i_token_list)->class_name() << std::endl;
2185 : }
2186 : }
2187 : else
2188 : {
2189 0 : std::cout << "SgSourceFile :: " << std::flush;
2190 0 : std::cout << "SgTokenPtrList p_token_list --> " << std::flush;
2191 0 : std::cout << " entry not valid " << std::endl;
2192 : }
2193 : }
2194 : else
2195 : {
2196 0 : std::cout << "SgTokenPtrList p_token_list --> NULL " << std::endl;
2197 : }
2198 : }
2199 :
2200 0 : if ( p_temp_holding_scope != NULL )
2201 : {
2202 0 : if ( p_temp_holding_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2203 : {
2204 0 : if ( p_temp_holding_scope->isInMemoryPool() == false )
2205 : {
2206 0 : std::cout << "SgSourceFile :: ";
2207 0 : std::cout << " p_temp_holding_scope is not in memory pool of ";
2208 0 : std::cout << p_temp_holding_scope->class_name() << std::endl;
2209 : }
2210 : }
2211 : else
2212 : {
2213 0 : std::cout << "SgSourceFile :: " << std::flush;
2214 0 : std::cout << "SgGlobal* p_temp_holding_scope = " << p_temp_holding_scope << " --> " << std::flush;
2215 0 : std::cout << " not valid " << std::endl;
2216 : }
2217 : }
2218 :
2219 0 : if ( p_headerFileReport != NULL )
2220 : {
2221 0 : if ( p_headerFileReport->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2222 : {
2223 0 : if ( p_headerFileReport->isInMemoryPool() == false )
2224 : {
2225 0 : std::cout << "SgSourceFile :: ";
2226 0 : std::cout << " p_headerFileReport is not in memory pool of ";
2227 0 : std::cout << p_headerFileReport->class_name() << std::endl;
2228 : }
2229 : }
2230 : else
2231 : {
2232 0 : std::cout << "SgSourceFile :: " << std::flush;
2233 0 : std::cout << "SgHeaderFileReport* p_headerFileReport = " << p_headerFileReport << " --> " << std::flush;
2234 0 : std::cout << " not valid " << std::endl;
2235 : }
2236 : }
2237 :
2238 0 : if ( p_associated_include_file != NULL )
2239 : {
2240 0 : if ( p_associated_include_file->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2241 : {
2242 0 : if ( p_associated_include_file->isInMemoryPool() == false )
2243 : {
2244 0 : std::cout << "SgSourceFile :: ";
2245 0 : std::cout << " p_associated_include_file is not in memory pool of ";
2246 0 : std::cout << p_associated_include_file->class_name() << std::endl;
2247 : }
2248 : }
2249 : else
2250 : {
2251 0 : std::cout << "SgSourceFile :: " << std::flush;
2252 0 : std::cout << "SgIncludeFile* p_associated_include_file = " << p_associated_include_file << " --> " << std::flush;
2253 0 : std::cout << " not valid " << std::endl;
2254 : }
2255 : }
2256 :
2257 0 : SgNodePtrList::iterator i_extra_nodes_for_namequal_init = p_extra_nodes_for_namequal_init.begin() ;
2258 0 : for ( ; i_extra_nodes_for_namequal_init != p_extra_nodes_for_namequal_init.end(); ++i_extra_nodes_for_namequal_init )
2259 : {
2260 0 : if ( (*i_extra_nodes_for_namequal_init) != NULL )
2261 : {
2262 0 : if ( (*i_extra_nodes_for_namequal_init)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2263 : {
2264 0 : if ( (*i_extra_nodes_for_namequal_init)->isInMemoryPool() == false )
2265 : {
2266 0 : std::cout << "SgSourceFile :: ";
2267 0 : std::cout << " p_extra_nodes_for_namequal_init ( list of poitners to IR nodes ), entry is not in memory pool of ";
2268 0 : std::cout << (*i_extra_nodes_for_namequal_init)->class_name() << std::endl;
2269 : }
2270 : }
2271 : else
2272 : {
2273 0 : std::cout << "SgSourceFile :: " << std::flush;
2274 0 : std::cout << "SgNodePtrList p_extra_nodes_for_namequal_init --> " << std::flush;
2275 0 : std::cout << " entry not valid " << std::endl;
2276 : }
2277 : }
2278 : else
2279 : {
2280 0 : std::cout << "SgNodePtrList p_extra_nodes_for_namequal_init --> NULL " << std::endl;
2281 : }
2282 : }
2283 :
2284 0 : if ( p_startOfConstruct != NULL )
2285 : {
2286 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2287 : {
2288 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
2289 : {
2290 0 : std::cout << "SgSourceFile :: ";
2291 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
2292 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
2293 : }
2294 : }
2295 : else
2296 : {
2297 0 : std::cout << "SgSourceFile :: " << std::flush;
2298 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
2299 0 : std::cout << " not valid " << std::endl;
2300 : }
2301 : }
2302 :
2303 0 : if ( p_parent != NULL )
2304 : {
2305 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2306 : {
2307 0 : if ( p_parent->isInMemoryPool() == false )
2308 : {
2309 0 : std::cout << "SgSourceFile :: ";
2310 0 : std::cout << " p_parent is not in memory pool of ";
2311 0 : std::cout << p_parent->class_name() << std::endl;
2312 : }
2313 : }
2314 : else
2315 : {
2316 0 : std::cout << "SgSourceFile :: " << std::flush;
2317 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
2318 0 : std::cout << " not valid " << std::endl;
2319 : }
2320 : }
2321 :
2322 :
2323 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2324 :
2325 0 : }
2326 :
2327 :
2328 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
2329 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
2330 : bool
2331 0 : SgSourceFile::isInMemoryPool ()
2332 : {
2333 0 : typedef unsigned char* TestType;
2334 :
2335 0 : bool found = false;
2336 :
2337 0 : ROSE_ASSERT(this != NULL);
2338 :
2339 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
2340 :
2341 0 : TestType tested = (TestType) ( this ) ;
2342 :
2343 0 : std::vector < unsigned char* > :: const_iterator block = SgSourceFile::pools.begin();
2344 :
2345 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
2346 : // while (found == false && block < Memory_Block_List.end())
2347 0 : while ( (found == false) && (block != SgSourceFile::pools.end()) )
2348 : {
2349 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSourceFile::pool_size * sizeof(SgSourceFile) ) ) ;
2350 0 : ++block;
2351 : }
2352 :
2353 : // Special handling for static data
2354 :
2355 :
2356 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
2357 0 : ROSE_ASSERT(found == true);
2358 :
2359 0 : return found;
2360 : }
2361 : /* #line 2362 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
2362 :
2363 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
2364 :
2365 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2366 :
2367 : /* #line 2368 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
2368 :
2369 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2370 :
2371 : void
2372 0 : SgUnknownFile::checkDataMemberPointersIfInMemoryPool()
2373 : {
2374 : // ------------ checking pointers of SgUnknownFile -------------------
2375 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
2376 :
2377 0 : if ( p_globalScope != NULL )
2378 : {
2379 0 : if ( p_globalScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2380 : {
2381 0 : if ( p_globalScope->isInMemoryPool() == false )
2382 : {
2383 0 : std::cout << "SgUnknownFile :: ";
2384 0 : std::cout << " p_globalScope is not in memory pool of ";
2385 0 : std::cout << p_globalScope->class_name() << std::endl;
2386 : }
2387 : }
2388 : else
2389 : {
2390 0 : std::cout << "SgUnknownFile :: " << std::flush;
2391 0 : std::cout << "SgGlobal* p_globalScope = " << p_globalScope << " --> " << std::flush;
2392 0 : std::cout << " not valid " << std::endl;
2393 : }
2394 : }
2395 :
2396 0 : if ( p_startOfConstruct != NULL )
2397 : {
2398 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2399 : {
2400 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
2401 : {
2402 0 : std::cout << "SgUnknownFile :: ";
2403 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
2404 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
2405 : }
2406 : }
2407 : else
2408 : {
2409 0 : std::cout << "SgUnknownFile :: " << std::flush;
2410 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
2411 0 : std::cout << " not valid " << std::endl;
2412 : }
2413 : }
2414 :
2415 0 : if ( p_parent != NULL )
2416 : {
2417 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2418 : {
2419 0 : if ( p_parent->isInMemoryPool() == false )
2420 : {
2421 0 : std::cout << "SgUnknownFile :: ";
2422 0 : std::cout << " p_parent is not in memory pool of ";
2423 0 : std::cout << p_parent->class_name() << std::endl;
2424 : }
2425 : }
2426 : else
2427 : {
2428 0 : std::cout << "SgUnknownFile :: " << std::flush;
2429 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
2430 0 : std::cout << " not valid " << std::endl;
2431 : }
2432 : }
2433 :
2434 :
2435 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2436 :
2437 0 : }
2438 :
2439 :
2440 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
2441 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
2442 : bool
2443 0 : SgUnknownFile::isInMemoryPool ()
2444 : {
2445 0 : typedef unsigned char* TestType;
2446 :
2447 0 : bool found = false;
2448 :
2449 0 : ROSE_ASSERT(this != NULL);
2450 :
2451 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
2452 :
2453 0 : TestType tested = (TestType) ( this ) ;
2454 :
2455 0 : std::vector < unsigned char* > :: const_iterator block = SgUnknownFile::pools.begin();
2456 :
2457 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
2458 : // while (found == false && block < Memory_Block_List.end())
2459 0 : while ( (found == false) && (block != SgUnknownFile::pools.end()) )
2460 : {
2461 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUnknownFile::pool_size * sizeof(SgUnknownFile) ) ) ;
2462 0 : ++block;
2463 : }
2464 :
2465 : // Special handling for static data
2466 :
2467 :
2468 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
2469 0 : ROSE_ASSERT(found == true);
2470 :
2471 0 : return found;
2472 : }
2473 : /* #line 2474 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
2474 :
2475 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
2476 :
2477 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2478 :
2479 : /* #line 2480 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
2480 :
2481 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2482 :
2483 : void
2484 0 : SgProject::checkDataMemberPointersIfInMemoryPool()
2485 : {
2486 : // ------------ checking pointers of SgProject -------------------
2487 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
2488 :
2489 0 : if ( p_fileList_ptr != NULL )
2490 : {
2491 0 : if ( p_fileList_ptr->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2492 : {
2493 0 : if ( p_fileList_ptr->isInMemoryPool() == false )
2494 : {
2495 0 : std::cout << "SgProject :: ";
2496 0 : std::cout << " p_fileList_ptr is not in memory pool of ";
2497 0 : std::cout << p_fileList_ptr->class_name() << std::endl;
2498 : }
2499 : }
2500 : else
2501 : {
2502 0 : std::cout << "SgProject :: " << std::flush;
2503 0 : std::cout << "SgFileList* p_fileList_ptr = " << p_fileList_ptr << " --> " << std::flush;
2504 0 : std::cout << " not valid " << std::endl;
2505 : }
2506 : }
2507 :
2508 0 : if ( p_directoryList != NULL )
2509 : {
2510 0 : if ( p_directoryList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2511 : {
2512 0 : if ( p_directoryList->isInMemoryPool() == false )
2513 : {
2514 0 : std::cout << "SgProject :: ";
2515 0 : std::cout << " p_directoryList is not in memory pool of ";
2516 0 : std::cout << p_directoryList->class_name() << std::endl;
2517 : }
2518 : }
2519 : else
2520 : {
2521 0 : std::cout << "SgProject :: " << std::flush;
2522 0 : std::cout << "SgDirectoryList* p_directoryList = " << p_directoryList << " --> " << std::flush;
2523 0 : std::cout << " not valid " << std::endl;
2524 : }
2525 : }
2526 :
2527 0 : if ( p_globalScopeAcrossFiles != NULL )
2528 : {
2529 0 : if ( p_globalScopeAcrossFiles->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2530 : {
2531 0 : if ( p_globalScopeAcrossFiles->isInMemoryPool() == false )
2532 : {
2533 0 : std::cout << "SgProject :: ";
2534 0 : std::cout << " p_globalScopeAcrossFiles is not in memory pool of ";
2535 0 : std::cout << p_globalScopeAcrossFiles->class_name() << std::endl;
2536 : }
2537 : }
2538 : else
2539 : {
2540 0 : std::cout << "SgProject :: " << std::flush;
2541 0 : std::cout << "SgGlobal* p_globalScopeAcrossFiles = " << p_globalScopeAcrossFiles << " --> " << std::flush;
2542 0 : std::cout << " not valid " << std::endl;
2543 : }
2544 : }
2545 :
2546 0 : if ( p_parent != NULL )
2547 : {
2548 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2549 : {
2550 0 : if ( p_parent->isInMemoryPool() == false )
2551 : {
2552 0 : std::cout << "SgProject :: ";
2553 0 : std::cout << " p_parent is not in memory pool of ";
2554 0 : std::cout << p_parent->class_name() << std::endl;
2555 : }
2556 : }
2557 : else
2558 : {
2559 0 : std::cout << "SgProject :: " << std::flush;
2560 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
2561 0 : std::cout << " not valid " << std::endl;
2562 : }
2563 : }
2564 :
2565 :
2566 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2567 :
2568 0 : }
2569 :
2570 :
2571 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
2572 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
2573 : bool
2574 0 : SgProject::isInMemoryPool ()
2575 : {
2576 0 : typedef unsigned char* TestType;
2577 :
2578 0 : bool found = false;
2579 :
2580 0 : ROSE_ASSERT(this != NULL);
2581 :
2582 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
2583 :
2584 0 : TestType tested = (TestType) ( this ) ;
2585 :
2586 0 : std::vector < unsigned char* > :: const_iterator block = SgProject::pools.begin();
2587 :
2588 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
2589 : // while (found == false && block < Memory_Block_List.end())
2590 0 : while ( (found == false) && (block != SgProject::pools.end()) )
2591 : {
2592 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgProject::pool_size * sizeof(SgProject) ) ) ;
2593 0 : ++block;
2594 : }
2595 :
2596 : // Special handling for static data
2597 :
2598 :
2599 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
2600 0 : ROSE_ASSERT(found == true);
2601 :
2602 0 : return found;
2603 : }
2604 : /* #line 2605 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
2605 :
2606 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
2607 :
2608 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2609 :
2610 : /* #line 2611 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
2611 :
2612 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2613 :
2614 : void
2615 0 : SgOptions::checkDataMemberPointersIfInMemoryPool()
2616 : {
2617 : // ------------ checking pointers of SgOptions -------------------
2618 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
2619 :
2620 0 : if ( p_parent != NULL )
2621 : {
2622 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2623 : {
2624 0 : if ( p_parent->isInMemoryPool() == false )
2625 : {
2626 0 : std::cout << "SgOptions :: ";
2627 0 : std::cout << " p_parent is not in memory pool of ";
2628 0 : std::cout << p_parent->class_name() << std::endl;
2629 : }
2630 : }
2631 : else
2632 : {
2633 0 : std::cout << "SgOptions :: " << std::flush;
2634 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
2635 0 : std::cout << " not valid " << std::endl;
2636 : }
2637 : }
2638 :
2639 :
2640 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2641 :
2642 0 : }
2643 :
2644 :
2645 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
2646 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
2647 : bool
2648 0 : SgOptions::isInMemoryPool ()
2649 : {
2650 0 : typedef unsigned char* TestType;
2651 :
2652 0 : bool found = false;
2653 :
2654 0 : ROSE_ASSERT(this != NULL);
2655 :
2656 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
2657 :
2658 0 : TestType tested = (TestType) ( this ) ;
2659 :
2660 0 : std::vector < unsigned char* > :: const_iterator block = SgOptions::pools.begin();
2661 :
2662 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
2663 : // while (found == false && block < Memory_Block_List.end())
2664 0 : while ( (found == false) && (block != SgOptions::pools.end()) )
2665 : {
2666 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOptions::pool_size * sizeof(SgOptions) ) ) ;
2667 0 : ++block;
2668 : }
2669 :
2670 : // Special handling for static data
2671 :
2672 :
2673 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
2674 0 : ROSE_ASSERT(found == true);
2675 :
2676 0 : return found;
2677 : }
2678 : /* #line 2679 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
2679 :
2680 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
2681 :
2682 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2683 :
2684 : /* #line 2685 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
2685 :
2686 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2687 :
2688 : void
2689 0 : SgUnparse_Info::checkDataMemberPointersIfInMemoryPool()
2690 : {
2691 : // ------------ checking pointers of SgUnparse_Info -------------------
2692 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
2693 :
2694 0 : if ( p_declstatement_ptr != NULL )
2695 : {
2696 0 : if ( p_declstatement_ptr->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2697 : {
2698 0 : if ( p_declstatement_ptr->isInMemoryPool() == false )
2699 : {
2700 0 : std::cout << "SgUnparse_Info :: ";
2701 0 : std::cout << " p_declstatement_ptr is not in memory pool of ";
2702 0 : std::cout << p_declstatement_ptr->class_name() << std::endl;
2703 : }
2704 : }
2705 : else
2706 : {
2707 0 : std::cout << "SgUnparse_Info :: " << std::flush;
2708 0 : std::cout << "SgDeclarationStatement* p_declstatement_ptr = " << p_declstatement_ptr << " --> " << std::flush;
2709 0 : std::cout << " not valid " << std::endl;
2710 : }
2711 : }
2712 :
2713 0 : if ( p_declaration_of_context != NULL )
2714 : {
2715 0 : if ( p_declaration_of_context->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2716 : {
2717 0 : if ( p_declaration_of_context->isInMemoryPool() == false )
2718 : {
2719 0 : std::cout << "SgUnparse_Info :: ";
2720 0 : std::cout << " p_declaration_of_context is not in memory pool of ";
2721 0 : std::cout << p_declaration_of_context->class_name() << std::endl;
2722 : }
2723 : }
2724 : else
2725 : {
2726 0 : std::cout << "SgUnparse_Info :: " << std::flush;
2727 0 : std::cout << "SgDeclarationStatement* p_declaration_of_context = " << p_declaration_of_context << " --> " << std::flush;
2728 0 : std::cout << " not valid " << std::endl;
2729 : }
2730 : }
2731 :
2732 0 : if ( p_current_context != NULL )
2733 : {
2734 0 : if ( p_current_context->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2735 : {
2736 0 : if ( p_current_context->isInMemoryPool() == false )
2737 : {
2738 0 : std::cout << "SgUnparse_Info :: ";
2739 0 : std::cout << " p_current_context is not in memory pool of ";
2740 0 : std::cout << p_current_context->class_name() << std::endl;
2741 : }
2742 : }
2743 : else
2744 : {
2745 0 : std::cout << "SgUnparse_Info :: " << std::flush;
2746 0 : std::cout << "SgNamedType* p_current_context = " << p_current_context << " --> " << std::flush;
2747 0 : std::cout << " not valid " << std::endl;
2748 : }
2749 : }
2750 :
2751 0 : static SgTypePtrList::iterator i_structureTagProcessingList = p_structureTagProcessingList.begin() ;
2752 0 : for ( ; i_structureTagProcessingList != p_structureTagProcessingList.end(); ++i_structureTagProcessingList )
2753 : {
2754 0 : if ( (*i_structureTagProcessingList) != NULL )
2755 : {
2756 0 : if ( (*i_structureTagProcessingList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2757 : {
2758 0 : if ( (*i_structureTagProcessingList)->isInMemoryPool() == false )
2759 : {
2760 0 : std::cout << "SgUnparse_Info :: ";
2761 0 : std::cout << " p_structureTagProcessingList ( list of poitners to IR nodes ), entry is not in memory pool of ";
2762 0 : std::cout << (*i_structureTagProcessingList)->class_name() << std::endl;
2763 : }
2764 : }
2765 : else
2766 : {
2767 0 : std::cout << "SgUnparse_Info :: " << std::flush;
2768 0 : std::cout << "static SgTypePtrList p_structureTagProcessingList --> " << std::flush;
2769 0 : std::cout << " entry not valid " << std::endl;
2770 : }
2771 : }
2772 : else
2773 : {
2774 0 : std::cout << "static SgTypePtrList p_structureTagProcessingList --> NULL " << std::endl;
2775 : }
2776 : }
2777 :
2778 0 : if ( p_current_namespace != NULL )
2779 : {
2780 0 : if ( p_current_namespace->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2781 : {
2782 0 : if ( p_current_namespace->isInMemoryPool() == false )
2783 : {
2784 0 : std::cout << "SgUnparse_Info :: ";
2785 0 : std::cout << " p_current_namespace is not in memory pool of ";
2786 0 : std::cout << p_current_namespace->class_name() << std::endl;
2787 : }
2788 : }
2789 : else
2790 : {
2791 0 : std::cout << "SgUnparse_Info :: " << std::flush;
2792 0 : std::cout << "SgNamespaceDeclarationStatement* p_current_namespace = " << p_current_namespace << " --> " << std::flush;
2793 0 : std::cout << " not valid " << std::endl;
2794 : }
2795 : }
2796 :
2797 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
2798 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
2799 : {
2800 0 : if ( (*i_qualifiedNameList) != NULL )
2801 : {
2802 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2803 : {
2804 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
2805 : {
2806 0 : std::cout << "SgUnparse_Info :: ";
2807 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
2808 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
2809 : }
2810 : }
2811 : else
2812 : {
2813 0 : std::cout << "SgUnparse_Info :: " << std::flush;
2814 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
2815 0 : std::cout << " entry not valid " << std::endl;
2816 : }
2817 : }
2818 : else
2819 : {
2820 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
2821 : }
2822 : }
2823 :
2824 0 : if ( p_current_function_call != NULL )
2825 : {
2826 0 : if ( p_current_function_call->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2827 : {
2828 0 : if ( p_current_function_call->isInMemoryPool() == false )
2829 : {
2830 0 : std::cout << "SgUnparse_Info :: ";
2831 0 : std::cout << " p_current_function_call is not in memory pool of ";
2832 0 : std::cout << p_current_function_call->class_name() << std::endl;
2833 : }
2834 : }
2835 : else
2836 : {
2837 0 : std::cout << "SgUnparse_Info :: " << std::flush;
2838 0 : std::cout << "SgFunctionCallExp* p_current_function_call = " << p_current_function_call << " --> " << std::flush;
2839 0 : std::cout << " not valid " << std::endl;
2840 : }
2841 : }
2842 :
2843 0 : if ( p_current_scope != NULL )
2844 : {
2845 0 : if ( p_current_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2846 : {
2847 0 : if ( p_current_scope->isInMemoryPool() == false )
2848 : {
2849 0 : std::cout << "SgUnparse_Info :: ";
2850 0 : std::cout << " p_current_scope is not in memory pool of ";
2851 0 : std::cout << p_current_scope->class_name() << std::endl;
2852 : }
2853 : }
2854 : else
2855 : {
2856 0 : std::cout << "SgUnparse_Info :: " << std::flush;
2857 0 : std::cout << "SgScopeStatement* p_current_scope = " << p_current_scope << " --> " << std::flush;
2858 0 : std::cout << " not valid " << std::endl;
2859 : }
2860 : }
2861 :
2862 0 : if ( p_reference_node_for_qualification != NULL )
2863 : {
2864 0 : if ( p_reference_node_for_qualification->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2865 : {
2866 0 : if ( p_reference_node_for_qualification->isInMemoryPool() == false )
2867 : {
2868 0 : std::cout << "SgUnparse_Info :: ";
2869 0 : std::cout << " p_reference_node_for_qualification is not in memory pool of ";
2870 0 : std::cout << p_reference_node_for_qualification->class_name() << std::endl;
2871 : }
2872 : }
2873 : else
2874 : {
2875 0 : std::cout << "SgUnparse_Info :: " << std::flush;
2876 0 : std::cout << "SgNode* p_reference_node_for_qualification = " << p_reference_node_for_qualification << " --> " << std::flush;
2877 0 : std::cout << " not valid " << std::endl;
2878 : }
2879 : }
2880 :
2881 0 : if ( p_current_source_file != NULL )
2882 : {
2883 0 : if ( p_current_source_file->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2884 : {
2885 0 : if ( p_current_source_file->isInMemoryPool() == false )
2886 : {
2887 0 : std::cout << "SgUnparse_Info :: ";
2888 0 : std::cout << " p_current_source_file is not in memory pool of ";
2889 0 : std::cout << p_current_source_file->class_name() << std::endl;
2890 : }
2891 : }
2892 : else
2893 : {
2894 0 : std::cout << "SgUnparse_Info :: " << std::flush;
2895 0 : std::cout << "SgSourceFile* p_current_source_file = " << p_current_source_file << " --> " << std::flush;
2896 0 : std::cout << " not valid " << std::endl;
2897 : }
2898 : }
2899 :
2900 0 : if ( p_declstatement_associated_with_type != NULL )
2901 : {
2902 0 : if ( p_declstatement_associated_with_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2903 : {
2904 0 : if ( p_declstatement_associated_with_type->isInMemoryPool() == false )
2905 : {
2906 0 : std::cout << "SgUnparse_Info :: ";
2907 0 : std::cout << " p_declstatement_associated_with_type is not in memory pool of ";
2908 0 : std::cout << p_declstatement_associated_with_type->class_name() << std::endl;
2909 : }
2910 : }
2911 : else
2912 : {
2913 0 : std::cout << "SgUnparse_Info :: " << std::flush;
2914 0 : std::cout << "SgDeclarationStatement* p_declstatement_associated_with_type = " << p_declstatement_associated_with_type << " --> " << std::flush;
2915 0 : std::cout << " not valid " << std::endl;
2916 : }
2917 : }
2918 :
2919 0 : if ( p_parent != NULL )
2920 : {
2921 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2922 : {
2923 0 : if ( p_parent->isInMemoryPool() == false )
2924 : {
2925 0 : std::cout << "SgUnparse_Info :: ";
2926 0 : std::cout << " p_parent is not in memory pool of ";
2927 0 : std::cout << p_parent->class_name() << std::endl;
2928 : }
2929 : }
2930 : else
2931 : {
2932 0 : std::cout << "SgUnparse_Info :: " << std::flush;
2933 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
2934 0 : std::cout << " not valid " << std::endl;
2935 : }
2936 : }
2937 :
2938 :
2939 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2940 :
2941 0 : }
2942 :
2943 :
2944 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
2945 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
2946 : bool
2947 0 : SgUnparse_Info::isInMemoryPool ()
2948 : {
2949 0 : typedef unsigned char* TestType;
2950 :
2951 0 : bool found = false;
2952 :
2953 0 : ROSE_ASSERT(this != NULL);
2954 :
2955 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
2956 :
2957 0 : TestType tested = (TestType) ( this ) ;
2958 :
2959 0 : std::vector < unsigned char* > :: const_iterator block = SgUnparse_Info::pools.begin();
2960 :
2961 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
2962 : // while (found == false && block < Memory_Block_List.end())
2963 0 : while ( (found == false) && (block != SgUnparse_Info::pools.end()) )
2964 : {
2965 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUnparse_Info::pool_size * sizeof(SgUnparse_Info) ) ) ;
2966 0 : ++block;
2967 : }
2968 :
2969 : // Special handling for static data
2970 :
2971 :
2972 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
2973 0 : ROSE_ASSERT(found == true);
2974 :
2975 0 : return found;
2976 : }
2977 : /* #line 2978 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
2978 :
2979 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
2980 :
2981 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2982 :
2983 : /* #line 2984 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
2984 :
2985 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
2986 :
2987 : void
2988 0 : SgBaseClass::checkDataMemberPointersIfInMemoryPool()
2989 : {
2990 : // ------------ checking pointers of SgBaseClass -------------------
2991 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
2992 :
2993 0 : if ( p_base_class != NULL )
2994 : {
2995 0 : if ( p_base_class->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
2996 : {
2997 0 : if ( p_base_class->isInMemoryPool() == false )
2998 : {
2999 0 : std::cout << "SgBaseClass :: ";
3000 0 : std::cout << " p_base_class is not in memory pool of ";
3001 0 : std::cout << p_base_class->class_name() << std::endl;
3002 : }
3003 : }
3004 : else
3005 : {
3006 0 : std::cout << "SgBaseClass :: " << std::flush;
3007 0 : std::cout << "SgClassDeclaration* p_base_class = " << p_base_class << " --> " << std::flush;
3008 0 : std::cout << " not valid " << std::endl;
3009 : }
3010 : }
3011 :
3012 0 : if ( p_baseClassModifier != NULL )
3013 : {
3014 0 : if ( p_baseClassModifier->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3015 : {
3016 0 : if ( p_baseClassModifier->isInMemoryPool() == false )
3017 : {
3018 0 : std::cout << "SgBaseClass :: ";
3019 0 : std::cout << " p_baseClassModifier is not in memory pool of ";
3020 0 : std::cout << p_baseClassModifier->class_name() << std::endl;
3021 : }
3022 : }
3023 : else
3024 : {
3025 0 : std::cout << "SgBaseClass :: " << std::flush;
3026 0 : std::cout << "SgBaseClassModifier* p_baseClassModifier = " << p_baseClassModifier << " --> " << std::flush;
3027 0 : std::cout << " not valid " << std::endl;
3028 : }
3029 : }
3030 :
3031 0 : if ( p_parent != NULL )
3032 : {
3033 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3034 : {
3035 0 : if ( p_parent->isInMemoryPool() == false )
3036 : {
3037 0 : std::cout << "SgBaseClass :: ";
3038 0 : std::cout << " p_parent is not in memory pool of ";
3039 0 : std::cout << p_parent->class_name() << std::endl;
3040 : }
3041 : }
3042 : else
3043 : {
3044 0 : std::cout << "SgBaseClass :: " << std::flush;
3045 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
3046 0 : std::cout << " not valid " << std::endl;
3047 : }
3048 : }
3049 :
3050 :
3051 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3052 :
3053 0 : }
3054 :
3055 :
3056 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
3057 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
3058 : bool
3059 0 : SgBaseClass::isInMemoryPool ()
3060 : {
3061 0 : typedef unsigned char* TestType;
3062 :
3063 0 : bool found = false;
3064 :
3065 0 : ROSE_ASSERT(this != NULL);
3066 :
3067 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
3068 :
3069 0 : TestType tested = (TestType) ( this ) ;
3070 :
3071 0 : std::vector < unsigned char* > :: const_iterator block = SgBaseClass::pools.begin();
3072 :
3073 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
3074 : // while (found == false && block < Memory_Block_List.end())
3075 0 : while ( (found == false) && (block != SgBaseClass::pools.end()) )
3076 : {
3077 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgBaseClass::pool_size * sizeof(SgBaseClass) ) ) ;
3078 0 : ++block;
3079 : }
3080 :
3081 : // Special handling for static data
3082 :
3083 :
3084 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
3085 0 : ROSE_ASSERT(found == true);
3086 :
3087 0 : return found;
3088 : }
3089 : /* #line 3090 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
3090 :
3091 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
3092 :
3093 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3094 :
3095 : /* #line 3096 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
3096 :
3097 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3098 :
3099 : void
3100 0 : SgExpBaseClass::checkDataMemberPointersIfInMemoryPool()
3101 : {
3102 : // ------------ checking pointers of SgExpBaseClass -------------------
3103 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
3104 :
3105 0 : if ( p_base_class_exp != NULL )
3106 : {
3107 0 : if ( p_base_class_exp->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3108 : {
3109 0 : if ( p_base_class_exp->isInMemoryPool() == false )
3110 : {
3111 0 : std::cout << "SgExpBaseClass :: ";
3112 0 : std::cout << " p_base_class_exp is not in memory pool of ";
3113 0 : std::cout << p_base_class_exp->class_name() << std::endl;
3114 : }
3115 : }
3116 : else
3117 : {
3118 0 : std::cout << "SgExpBaseClass :: " << std::flush;
3119 0 : std::cout << "SgExpression* p_base_class_exp = " << p_base_class_exp << " --> " << std::flush;
3120 0 : std::cout << " not valid " << std::endl;
3121 : }
3122 : }
3123 :
3124 0 : if ( p_base_class != NULL )
3125 : {
3126 0 : if ( p_base_class->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3127 : {
3128 0 : if ( p_base_class->isInMemoryPool() == false )
3129 : {
3130 0 : std::cout << "SgExpBaseClass :: ";
3131 0 : std::cout << " p_base_class is not in memory pool of ";
3132 0 : std::cout << p_base_class->class_name() << std::endl;
3133 : }
3134 : }
3135 : else
3136 : {
3137 0 : std::cout << "SgExpBaseClass :: " << std::flush;
3138 0 : std::cout << "SgClassDeclaration* p_base_class = " << p_base_class << " --> " << std::flush;
3139 0 : std::cout << " not valid " << std::endl;
3140 : }
3141 : }
3142 :
3143 0 : if ( p_baseClassModifier != NULL )
3144 : {
3145 0 : if ( p_baseClassModifier->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3146 : {
3147 0 : if ( p_baseClassModifier->isInMemoryPool() == false )
3148 : {
3149 0 : std::cout << "SgExpBaseClass :: ";
3150 0 : std::cout << " p_baseClassModifier is not in memory pool of ";
3151 0 : std::cout << p_baseClassModifier->class_name() << std::endl;
3152 : }
3153 : }
3154 : else
3155 : {
3156 0 : std::cout << "SgExpBaseClass :: " << std::flush;
3157 0 : std::cout << "SgBaseClassModifier* p_baseClassModifier = " << p_baseClassModifier << " --> " << std::flush;
3158 0 : std::cout << " not valid " << std::endl;
3159 : }
3160 : }
3161 :
3162 0 : if ( p_parent != NULL )
3163 : {
3164 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3165 : {
3166 0 : if ( p_parent->isInMemoryPool() == false )
3167 : {
3168 0 : std::cout << "SgExpBaseClass :: ";
3169 0 : std::cout << " p_parent is not in memory pool of ";
3170 0 : std::cout << p_parent->class_name() << std::endl;
3171 : }
3172 : }
3173 : else
3174 : {
3175 0 : std::cout << "SgExpBaseClass :: " << std::flush;
3176 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
3177 0 : std::cout << " not valid " << std::endl;
3178 : }
3179 : }
3180 :
3181 :
3182 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3183 :
3184 0 : }
3185 :
3186 :
3187 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
3188 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
3189 : bool
3190 0 : SgExpBaseClass::isInMemoryPool ()
3191 : {
3192 0 : typedef unsigned char* TestType;
3193 :
3194 0 : bool found = false;
3195 :
3196 0 : ROSE_ASSERT(this != NULL);
3197 :
3198 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
3199 :
3200 0 : TestType tested = (TestType) ( this ) ;
3201 :
3202 0 : std::vector < unsigned char* > :: const_iterator block = SgExpBaseClass::pools.begin();
3203 :
3204 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
3205 : // while (found == false && block < Memory_Block_List.end())
3206 0 : while ( (found == false) && (block != SgExpBaseClass::pools.end()) )
3207 : {
3208 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgExpBaseClass::pool_size * sizeof(SgExpBaseClass) ) ) ;
3209 0 : ++block;
3210 : }
3211 :
3212 : // Special handling for static data
3213 :
3214 :
3215 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
3216 0 : ROSE_ASSERT(found == true);
3217 :
3218 0 : return found;
3219 : }
3220 : /* #line 3221 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
3221 :
3222 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
3223 :
3224 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3225 :
3226 : /* #line 3227 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
3227 :
3228 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3229 :
3230 : void
3231 0 : SgNonrealBaseClass::checkDataMemberPointersIfInMemoryPool()
3232 : {
3233 : // ------------ checking pointers of SgNonrealBaseClass -------------------
3234 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
3235 :
3236 0 : if ( p_base_class_nonreal != NULL )
3237 : {
3238 0 : if ( p_base_class_nonreal->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3239 : {
3240 0 : if ( p_base_class_nonreal->isInMemoryPool() == false )
3241 : {
3242 0 : std::cout << "SgNonrealBaseClass :: ";
3243 0 : std::cout << " p_base_class_nonreal is not in memory pool of ";
3244 0 : std::cout << p_base_class_nonreal->class_name() << std::endl;
3245 : }
3246 : }
3247 : else
3248 : {
3249 0 : std::cout << "SgNonrealBaseClass :: " << std::flush;
3250 0 : std::cout << "SgNonrealDecl* p_base_class_nonreal = " << p_base_class_nonreal << " --> " << std::flush;
3251 0 : std::cout << " not valid " << std::endl;
3252 : }
3253 : }
3254 :
3255 0 : if ( p_base_class != NULL )
3256 : {
3257 0 : if ( p_base_class->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3258 : {
3259 0 : if ( p_base_class->isInMemoryPool() == false )
3260 : {
3261 0 : std::cout << "SgNonrealBaseClass :: ";
3262 0 : std::cout << " p_base_class is not in memory pool of ";
3263 0 : std::cout << p_base_class->class_name() << std::endl;
3264 : }
3265 : }
3266 : else
3267 : {
3268 0 : std::cout << "SgNonrealBaseClass :: " << std::flush;
3269 0 : std::cout << "SgClassDeclaration* p_base_class = " << p_base_class << " --> " << std::flush;
3270 0 : std::cout << " not valid " << std::endl;
3271 : }
3272 : }
3273 :
3274 0 : if ( p_baseClassModifier != NULL )
3275 : {
3276 0 : if ( p_baseClassModifier->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3277 : {
3278 0 : if ( p_baseClassModifier->isInMemoryPool() == false )
3279 : {
3280 0 : std::cout << "SgNonrealBaseClass :: ";
3281 0 : std::cout << " p_baseClassModifier is not in memory pool of ";
3282 0 : std::cout << p_baseClassModifier->class_name() << std::endl;
3283 : }
3284 : }
3285 : else
3286 : {
3287 0 : std::cout << "SgNonrealBaseClass :: " << std::flush;
3288 0 : std::cout << "SgBaseClassModifier* p_baseClassModifier = " << p_baseClassModifier << " --> " << std::flush;
3289 0 : std::cout << " not valid " << std::endl;
3290 : }
3291 : }
3292 :
3293 0 : if ( p_parent != NULL )
3294 : {
3295 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3296 : {
3297 0 : if ( p_parent->isInMemoryPool() == false )
3298 : {
3299 0 : std::cout << "SgNonrealBaseClass :: ";
3300 0 : std::cout << " p_parent is not in memory pool of ";
3301 0 : std::cout << p_parent->class_name() << std::endl;
3302 : }
3303 : }
3304 : else
3305 : {
3306 0 : std::cout << "SgNonrealBaseClass :: " << std::flush;
3307 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
3308 0 : std::cout << " not valid " << std::endl;
3309 : }
3310 : }
3311 :
3312 :
3313 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3314 :
3315 0 : }
3316 :
3317 :
3318 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
3319 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
3320 : bool
3321 0 : SgNonrealBaseClass::isInMemoryPool ()
3322 : {
3323 0 : typedef unsigned char* TestType;
3324 :
3325 0 : bool found = false;
3326 :
3327 0 : ROSE_ASSERT(this != NULL);
3328 :
3329 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
3330 :
3331 0 : TestType tested = (TestType) ( this ) ;
3332 :
3333 0 : std::vector < unsigned char* > :: const_iterator block = SgNonrealBaseClass::pools.begin();
3334 :
3335 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
3336 : // while (found == false && block < Memory_Block_List.end())
3337 0 : while ( (found == false) && (block != SgNonrealBaseClass::pools.end()) )
3338 : {
3339 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNonrealBaseClass::pool_size * sizeof(SgNonrealBaseClass) ) ) ;
3340 0 : ++block;
3341 : }
3342 :
3343 : // Special handling for static data
3344 :
3345 :
3346 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
3347 0 : ROSE_ASSERT(found == true);
3348 :
3349 0 : return found;
3350 : }
3351 : /* #line 3352 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
3352 :
3353 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
3354 :
3355 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3356 :
3357 : /* #line 3358 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
3358 :
3359 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3360 :
3361 : void
3362 0 : SgTypedefSeq::checkDataMemberPointersIfInMemoryPool()
3363 : {
3364 : // ------------ checking pointers of SgTypedefSeq -------------------
3365 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
3366 :
3367 0 : SgTypePtrList::iterator i_typedefs = p_typedefs.begin() ;
3368 0 : for ( ; i_typedefs != p_typedefs.end(); ++i_typedefs )
3369 : {
3370 0 : if ( (*i_typedefs) != NULL )
3371 : {
3372 0 : if ( (*i_typedefs)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3373 : {
3374 0 : if ( (*i_typedefs)->isInMemoryPool() == false )
3375 : {
3376 0 : std::cout << "SgTypedefSeq :: ";
3377 0 : std::cout << " p_typedefs ( list of poitners to IR nodes ), entry is not in memory pool of ";
3378 0 : std::cout << (*i_typedefs)->class_name() << std::endl;
3379 : }
3380 : }
3381 : else
3382 : {
3383 0 : std::cout << "SgTypedefSeq :: " << std::flush;
3384 0 : std::cout << "SgTypePtrList p_typedefs --> " << std::flush;
3385 0 : std::cout << " entry not valid " << std::endl;
3386 : }
3387 : }
3388 : else
3389 : {
3390 0 : std::cout << "SgTypePtrList p_typedefs --> NULL " << std::endl;
3391 : }
3392 : }
3393 :
3394 0 : if ( p_parent != NULL )
3395 : {
3396 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3397 : {
3398 0 : if ( p_parent->isInMemoryPool() == false )
3399 : {
3400 0 : std::cout << "SgTypedefSeq :: ";
3401 0 : std::cout << " p_parent is not in memory pool of ";
3402 0 : std::cout << p_parent->class_name() << std::endl;
3403 : }
3404 : }
3405 : else
3406 : {
3407 0 : std::cout << "SgTypedefSeq :: " << std::flush;
3408 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
3409 0 : std::cout << " not valid " << std::endl;
3410 : }
3411 : }
3412 :
3413 :
3414 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3415 :
3416 0 : }
3417 :
3418 :
3419 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
3420 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
3421 : bool
3422 0 : SgTypedefSeq::isInMemoryPool ()
3423 : {
3424 0 : typedef unsigned char* TestType;
3425 :
3426 0 : bool found = false;
3427 :
3428 0 : ROSE_ASSERT(this != NULL);
3429 :
3430 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
3431 :
3432 0 : TestType tested = (TestType) ( this ) ;
3433 :
3434 0 : std::vector < unsigned char* > :: const_iterator block = SgTypedefSeq::pools.begin();
3435 :
3436 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
3437 : // while (found == false && block < Memory_Block_List.end())
3438 0 : while ( (found == false) && (block != SgTypedefSeq::pools.end()) )
3439 : {
3440 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypedefSeq::pool_size * sizeof(SgTypedefSeq) ) ) ;
3441 0 : ++block;
3442 : }
3443 :
3444 : // Special handling for static data
3445 :
3446 :
3447 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
3448 0 : ROSE_ASSERT(found == true);
3449 :
3450 0 : return found;
3451 : }
3452 : /* #line 3453 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
3453 :
3454 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
3455 :
3456 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3457 :
3458 : /* #line 3459 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
3459 :
3460 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3461 :
3462 : void
3463 0 : SgTemplateParameter::checkDataMemberPointersIfInMemoryPool()
3464 : {
3465 : // ------------ checking pointers of SgTemplateParameter -------------------
3466 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
3467 :
3468 0 : if ( p_type != NULL )
3469 : {
3470 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3471 : {
3472 0 : if ( p_type->isInMemoryPool() == false )
3473 : {
3474 0 : std::cout << "SgTemplateParameter :: ";
3475 0 : std::cout << " p_type is not in memory pool of ";
3476 0 : std::cout << p_type->class_name() << std::endl;
3477 : }
3478 : }
3479 : else
3480 : {
3481 0 : std::cout << "SgTemplateParameter :: " << std::flush;
3482 0 : std::cout << "SgType* p_type = " << p_type << " --> " << std::flush;
3483 0 : std::cout << " not valid " << std::endl;
3484 : }
3485 : }
3486 :
3487 0 : if ( p_defaultTypeParameter != NULL )
3488 : {
3489 0 : if ( p_defaultTypeParameter->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3490 : {
3491 0 : if ( p_defaultTypeParameter->isInMemoryPool() == false )
3492 : {
3493 0 : std::cout << "SgTemplateParameter :: ";
3494 0 : std::cout << " p_defaultTypeParameter is not in memory pool of ";
3495 0 : std::cout << p_defaultTypeParameter->class_name() << std::endl;
3496 : }
3497 : }
3498 : else
3499 : {
3500 0 : std::cout << "SgTemplateParameter :: " << std::flush;
3501 0 : std::cout << "SgType* p_defaultTypeParameter = " << p_defaultTypeParameter << " --> " << std::flush;
3502 0 : std::cout << " not valid " << std::endl;
3503 : }
3504 : }
3505 :
3506 0 : if ( p_expression != NULL )
3507 : {
3508 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3509 : {
3510 0 : if ( p_expression->isInMemoryPool() == false )
3511 : {
3512 0 : std::cout << "SgTemplateParameter :: ";
3513 0 : std::cout << " p_expression is not in memory pool of ";
3514 0 : std::cout << p_expression->class_name() << std::endl;
3515 : }
3516 : }
3517 : else
3518 : {
3519 0 : std::cout << "SgTemplateParameter :: " << std::flush;
3520 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
3521 0 : std::cout << " not valid " << std::endl;
3522 : }
3523 : }
3524 :
3525 0 : if ( p_defaultExpressionParameter != NULL )
3526 : {
3527 0 : if ( p_defaultExpressionParameter->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3528 : {
3529 0 : if ( p_defaultExpressionParameter->isInMemoryPool() == false )
3530 : {
3531 0 : std::cout << "SgTemplateParameter :: ";
3532 0 : std::cout << " p_defaultExpressionParameter is not in memory pool of ";
3533 0 : std::cout << p_defaultExpressionParameter->class_name() << std::endl;
3534 : }
3535 : }
3536 : else
3537 : {
3538 0 : std::cout << "SgTemplateParameter :: " << std::flush;
3539 0 : std::cout << "SgExpression* p_defaultExpressionParameter = " << p_defaultExpressionParameter << " --> " << std::flush;
3540 0 : std::cout << " not valid " << std::endl;
3541 : }
3542 : }
3543 :
3544 0 : if ( p_templateDeclaration != NULL )
3545 : {
3546 0 : if ( p_templateDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3547 : {
3548 0 : if ( p_templateDeclaration->isInMemoryPool() == false )
3549 : {
3550 0 : std::cout << "SgTemplateParameter :: ";
3551 0 : std::cout << " p_templateDeclaration is not in memory pool of ";
3552 0 : std::cout << p_templateDeclaration->class_name() << std::endl;
3553 : }
3554 : }
3555 : else
3556 : {
3557 0 : std::cout << "SgTemplateParameter :: " << std::flush;
3558 0 : std::cout << "SgDeclarationStatement* p_templateDeclaration = " << p_templateDeclaration << " --> " << std::flush;
3559 0 : std::cout << " not valid " << std::endl;
3560 : }
3561 : }
3562 :
3563 0 : if ( p_defaultTemplateDeclarationParameter != NULL )
3564 : {
3565 0 : if ( p_defaultTemplateDeclarationParameter->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3566 : {
3567 0 : if ( p_defaultTemplateDeclarationParameter->isInMemoryPool() == false )
3568 : {
3569 0 : std::cout << "SgTemplateParameter :: ";
3570 0 : std::cout << " p_defaultTemplateDeclarationParameter is not in memory pool of ";
3571 0 : std::cout << p_defaultTemplateDeclarationParameter->class_name() << std::endl;
3572 : }
3573 : }
3574 : else
3575 : {
3576 0 : std::cout << "SgTemplateParameter :: " << std::flush;
3577 0 : std::cout << "SgDeclarationStatement* p_defaultTemplateDeclarationParameter = " << p_defaultTemplateDeclarationParameter << " --> " << std::flush;
3578 0 : std::cout << " not valid " << std::endl;
3579 : }
3580 : }
3581 :
3582 0 : if ( p_initializedName != NULL )
3583 : {
3584 0 : if ( p_initializedName->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3585 : {
3586 0 : if ( p_initializedName->isInMemoryPool() == false )
3587 : {
3588 0 : std::cout << "SgTemplateParameter :: ";
3589 0 : std::cout << " p_initializedName is not in memory pool of ";
3590 0 : std::cout << p_initializedName->class_name() << std::endl;
3591 : }
3592 : }
3593 : else
3594 : {
3595 0 : std::cout << "SgTemplateParameter :: " << std::flush;
3596 0 : std::cout << "SgInitializedName* p_initializedName = " << p_initializedName << " --> " << std::flush;
3597 0 : std::cout << " not valid " << std::endl;
3598 : }
3599 : }
3600 :
3601 0 : if ( p_parent != NULL )
3602 : {
3603 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3604 : {
3605 0 : if ( p_parent->isInMemoryPool() == false )
3606 : {
3607 0 : std::cout << "SgTemplateParameter :: ";
3608 0 : std::cout << " p_parent is not in memory pool of ";
3609 0 : std::cout << p_parent->class_name() << std::endl;
3610 : }
3611 : }
3612 : else
3613 : {
3614 0 : std::cout << "SgTemplateParameter :: " << std::flush;
3615 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
3616 0 : std::cout << " not valid " << std::endl;
3617 : }
3618 : }
3619 :
3620 :
3621 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3622 :
3623 0 : }
3624 :
3625 :
3626 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
3627 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
3628 : bool
3629 0 : SgTemplateParameter::isInMemoryPool ()
3630 : {
3631 0 : typedef unsigned char* TestType;
3632 :
3633 0 : bool found = false;
3634 :
3635 0 : ROSE_ASSERT(this != NULL);
3636 :
3637 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
3638 :
3639 0 : TestType tested = (TestType) ( this ) ;
3640 :
3641 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateParameter::pools.begin();
3642 :
3643 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
3644 : // while (found == false && block < Memory_Block_List.end())
3645 0 : while ( (found == false) && (block != SgTemplateParameter::pools.end()) )
3646 : {
3647 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateParameter::pool_size * sizeof(SgTemplateParameter) ) ) ;
3648 0 : ++block;
3649 : }
3650 :
3651 : // Special handling for static data
3652 :
3653 :
3654 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
3655 0 : ROSE_ASSERT(found == true);
3656 :
3657 0 : return found;
3658 : }
3659 : /* #line 3660 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
3660 :
3661 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
3662 :
3663 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3664 :
3665 : /* #line 3666 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
3666 :
3667 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3668 :
3669 : void
3670 0 : SgTemplateArgument::checkDataMemberPointersIfInMemoryPool()
3671 : {
3672 : // ------------ checking pointers of SgTemplateArgument -------------------
3673 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
3674 :
3675 0 : if ( p_type != NULL )
3676 : {
3677 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3678 : {
3679 0 : if ( p_type->isInMemoryPool() == false )
3680 : {
3681 0 : std::cout << "SgTemplateArgument :: ";
3682 0 : std::cout << " p_type is not in memory pool of ";
3683 0 : std::cout << p_type->class_name() << std::endl;
3684 : }
3685 : }
3686 : else
3687 : {
3688 0 : std::cout << "SgTemplateArgument :: " << std::flush;
3689 0 : std::cout << "SgType* p_type = " << p_type << " --> " << std::flush;
3690 0 : std::cout << " not valid " << std::endl;
3691 : }
3692 : }
3693 :
3694 0 : if ( p_unparsable_type_alias != NULL )
3695 : {
3696 0 : if ( p_unparsable_type_alias->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3697 : {
3698 0 : if ( p_unparsable_type_alias->isInMemoryPool() == false )
3699 : {
3700 0 : std::cout << "SgTemplateArgument :: ";
3701 0 : std::cout << " p_unparsable_type_alias is not in memory pool of ";
3702 0 : std::cout << p_unparsable_type_alias->class_name() << std::endl;
3703 : }
3704 : }
3705 : else
3706 : {
3707 0 : std::cout << "SgTemplateArgument :: " << std::flush;
3708 0 : std::cout << "SgType* p_unparsable_type_alias = " << p_unparsable_type_alias << " --> " << std::flush;
3709 0 : std::cout << " not valid " << std::endl;
3710 : }
3711 : }
3712 :
3713 0 : if ( p_expression != NULL )
3714 : {
3715 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3716 : {
3717 0 : if ( p_expression->isInMemoryPool() == false )
3718 : {
3719 0 : std::cout << "SgTemplateArgument :: ";
3720 0 : std::cout << " p_expression is not in memory pool of ";
3721 0 : std::cout << p_expression->class_name() << std::endl;
3722 : }
3723 : }
3724 : else
3725 : {
3726 0 : std::cout << "SgTemplateArgument :: " << std::flush;
3727 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
3728 0 : std::cout << " not valid " << std::endl;
3729 : }
3730 : }
3731 :
3732 0 : if ( p_templateDeclaration != NULL )
3733 : {
3734 0 : if ( p_templateDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3735 : {
3736 0 : if ( p_templateDeclaration->isInMemoryPool() == false )
3737 : {
3738 0 : std::cout << "SgTemplateArgument :: ";
3739 0 : std::cout << " p_templateDeclaration is not in memory pool of ";
3740 0 : std::cout << p_templateDeclaration->class_name() << std::endl;
3741 : }
3742 : }
3743 : else
3744 : {
3745 0 : std::cout << "SgTemplateArgument :: " << std::flush;
3746 0 : std::cout << "SgDeclarationStatement* p_templateDeclaration = " << p_templateDeclaration << " --> " << std::flush;
3747 0 : std::cout << " not valid " << std::endl;
3748 : }
3749 : }
3750 :
3751 0 : if ( p_initializedName != NULL )
3752 : {
3753 0 : if ( p_initializedName->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3754 : {
3755 0 : if ( p_initializedName->isInMemoryPool() == false )
3756 : {
3757 0 : std::cout << "SgTemplateArgument :: ";
3758 0 : std::cout << " p_initializedName is not in memory pool of ";
3759 0 : std::cout << p_initializedName->class_name() << std::endl;
3760 : }
3761 : }
3762 : else
3763 : {
3764 0 : std::cout << "SgTemplateArgument :: " << std::flush;
3765 0 : std::cout << "SgInitializedName* p_initializedName = " << p_initializedName << " --> " << std::flush;
3766 0 : std::cout << " not valid " << std::endl;
3767 : }
3768 : }
3769 :
3770 0 : if ( p_previous_instance != NULL )
3771 : {
3772 0 : if ( p_previous_instance->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3773 : {
3774 0 : if ( p_previous_instance->isInMemoryPool() == false )
3775 : {
3776 0 : std::cout << "SgTemplateArgument :: ";
3777 0 : std::cout << " p_previous_instance is not in memory pool of ";
3778 0 : std::cout << p_previous_instance->class_name() << std::endl;
3779 : }
3780 : }
3781 : else
3782 : {
3783 0 : std::cout << "SgTemplateArgument :: " << std::flush;
3784 0 : std::cout << "SgTemplateArgument* p_previous_instance = " << p_previous_instance << " --> " << std::flush;
3785 0 : std::cout << " not valid " << std::endl;
3786 : }
3787 : }
3788 :
3789 0 : if ( p_next_instance != NULL )
3790 : {
3791 0 : if ( p_next_instance->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3792 : {
3793 0 : if ( p_next_instance->isInMemoryPool() == false )
3794 : {
3795 0 : std::cout << "SgTemplateArgument :: ";
3796 0 : std::cout << " p_next_instance is not in memory pool of ";
3797 0 : std::cout << p_next_instance->class_name() << std::endl;
3798 : }
3799 : }
3800 : else
3801 : {
3802 0 : std::cout << "SgTemplateArgument :: " << std::flush;
3803 0 : std::cout << "SgTemplateArgument* p_next_instance = " << p_next_instance << " --> " << std::flush;
3804 0 : std::cout << " not valid " << std::endl;
3805 : }
3806 : }
3807 :
3808 0 : if ( p_parent != NULL )
3809 : {
3810 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3811 : {
3812 0 : if ( p_parent->isInMemoryPool() == false )
3813 : {
3814 0 : std::cout << "SgTemplateArgument :: ";
3815 0 : std::cout << " p_parent is not in memory pool of ";
3816 0 : std::cout << p_parent->class_name() << std::endl;
3817 : }
3818 : }
3819 : else
3820 : {
3821 0 : std::cout << "SgTemplateArgument :: " << std::flush;
3822 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
3823 0 : std::cout << " not valid " << std::endl;
3824 : }
3825 : }
3826 :
3827 :
3828 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3829 :
3830 0 : }
3831 :
3832 :
3833 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
3834 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
3835 : bool
3836 0 : SgTemplateArgument::isInMemoryPool ()
3837 : {
3838 0 : typedef unsigned char* TestType;
3839 :
3840 0 : bool found = false;
3841 :
3842 0 : ROSE_ASSERT(this != NULL);
3843 :
3844 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
3845 :
3846 0 : TestType tested = (TestType) ( this ) ;
3847 :
3848 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateArgument::pools.begin();
3849 :
3850 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
3851 : // while (found == false && block < Memory_Block_List.end())
3852 0 : while ( (found == false) && (block != SgTemplateArgument::pools.end()) )
3853 : {
3854 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateArgument::pool_size * sizeof(SgTemplateArgument) ) ) ;
3855 0 : ++block;
3856 : }
3857 :
3858 : // Special handling for static data
3859 :
3860 :
3861 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
3862 0 : ROSE_ASSERT(found == true);
3863 :
3864 0 : return found;
3865 : }
3866 : /* #line 3867 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
3867 :
3868 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
3869 :
3870 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3871 :
3872 : /* #line 3873 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
3873 :
3874 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3875 :
3876 : void
3877 0 : SgDirectory::checkDataMemberPointersIfInMemoryPool()
3878 : {
3879 : // ------------ checking pointers of SgDirectory -------------------
3880 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
3881 :
3882 0 : if ( p_fileList != NULL )
3883 : {
3884 0 : if ( p_fileList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3885 : {
3886 0 : if ( p_fileList->isInMemoryPool() == false )
3887 : {
3888 0 : std::cout << "SgDirectory :: ";
3889 0 : std::cout << " p_fileList is not in memory pool of ";
3890 0 : std::cout << p_fileList->class_name() << std::endl;
3891 : }
3892 : }
3893 : else
3894 : {
3895 0 : std::cout << "SgDirectory :: " << std::flush;
3896 0 : std::cout << "SgFileList* p_fileList = " << p_fileList << " --> " << std::flush;
3897 0 : std::cout << " not valid " << std::endl;
3898 : }
3899 : }
3900 :
3901 0 : if ( p_directoryList != NULL )
3902 : {
3903 0 : if ( p_directoryList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3904 : {
3905 0 : if ( p_directoryList->isInMemoryPool() == false )
3906 : {
3907 0 : std::cout << "SgDirectory :: ";
3908 0 : std::cout << " p_directoryList is not in memory pool of ";
3909 0 : std::cout << p_directoryList->class_name() << std::endl;
3910 : }
3911 : }
3912 : else
3913 : {
3914 0 : std::cout << "SgDirectory :: " << std::flush;
3915 0 : std::cout << "SgDirectoryList* p_directoryList = " << p_directoryList << " --> " << std::flush;
3916 0 : std::cout << " not valid " << std::endl;
3917 : }
3918 : }
3919 :
3920 0 : if ( p_parent != NULL )
3921 : {
3922 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
3923 : {
3924 0 : if ( p_parent->isInMemoryPool() == false )
3925 : {
3926 0 : std::cout << "SgDirectory :: ";
3927 0 : std::cout << " p_parent is not in memory pool of ";
3928 0 : std::cout << p_parent->class_name() << std::endl;
3929 : }
3930 : }
3931 : else
3932 : {
3933 0 : std::cout << "SgDirectory :: " << std::flush;
3934 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
3935 0 : std::cout << " not valid " << std::endl;
3936 : }
3937 : }
3938 :
3939 :
3940 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3941 :
3942 0 : }
3943 :
3944 :
3945 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
3946 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
3947 : bool
3948 0 : SgDirectory::isInMemoryPool ()
3949 : {
3950 0 : typedef unsigned char* TestType;
3951 :
3952 0 : bool found = false;
3953 :
3954 0 : ROSE_ASSERT(this != NULL);
3955 :
3956 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
3957 :
3958 0 : TestType tested = (TestType) ( this ) ;
3959 :
3960 0 : std::vector < unsigned char* > :: const_iterator block = SgDirectory::pools.begin();
3961 :
3962 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
3963 : // while (found == false && block < Memory_Block_List.end())
3964 0 : while ( (found == false) && (block != SgDirectory::pools.end()) )
3965 : {
3966 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDirectory::pool_size * sizeof(SgDirectory) ) ) ;
3967 0 : ++block;
3968 : }
3969 :
3970 : // Special handling for static data
3971 :
3972 :
3973 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
3974 0 : ROSE_ASSERT(found == true);
3975 :
3976 0 : return found;
3977 : }
3978 : /* #line 3979 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
3979 :
3980 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
3981 :
3982 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3983 :
3984 : /* #line 3985 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
3985 :
3986 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
3987 :
3988 : void
3989 0 : SgFileList::checkDataMemberPointersIfInMemoryPool()
3990 : {
3991 : // ------------ checking pointers of SgFileList -------------------
3992 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
3993 :
3994 0 : SgFilePtrList::iterator i_listOfFiles = p_listOfFiles.begin() ;
3995 0 : for ( ; i_listOfFiles != p_listOfFiles.end(); ++i_listOfFiles )
3996 : {
3997 0 : if ( (*i_listOfFiles) != NULL )
3998 : {
3999 0 : if ( (*i_listOfFiles)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4000 : {
4001 0 : if ( (*i_listOfFiles)->isInMemoryPool() == false )
4002 : {
4003 0 : std::cout << "SgFileList :: ";
4004 0 : std::cout << " p_listOfFiles ( list of poitners to IR nodes ), entry is not in memory pool of ";
4005 0 : std::cout << (*i_listOfFiles)->class_name() << std::endl;
4006 : }
4007 : }
4008 : else
4009 : {
4010 0 : std::cout << "SgFileList :: " << std::flush;
4011 0 : std::cout << "SgFilePtrList p_listOfFiles --> " << std::flush;
4012 0 : std::cout << " entry not valid " << std::endl;
4013 : }
4014 : }
4015 : else
4016 : {
4017 0 : std::cout << "SgFilePtrList p_listOfFiles --> NULL " << std::endl;
4018 : }
4019 : }
4020 :
4021 0 : if ( p_parent != NULL )
4022 : {
4023 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4024 : {
4025 0 : if ( p_parent->isInMemoryPool() == false )
4026 : {
4027 0 : std::cout << "SgFileList :: ";
4028 0 : std::cout << " p_parent is not in memory pool of ";
4029 0 : std::cout << p_parent->class_name() << std::endl;
4030 : }
4031 : }
4032 : else
4033 : {
4034 0 : std::cout << "SgFileList :: " << std::flush;
4035 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
4036 0 : std::cout << " not valid " << std::endl;
4037 : }
4038 : }
4039 :
4040 :
4041 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4042 :
4043 0 : }
4044 :
4045 :
4046 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
4047 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
4048 : bool
4049 0 : SgFileList::isInMemoryPool ()
4050 : {
4051 0 : typedef unsigned char* TestType;
4052 :
4053 0 : bool found = false;
4054 :
4055 0 : ROSE_ASSERT(this != NULL);
4056 :
4057 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
4058 :
4059 0 : TestType tested = (TestType) ( this ) ;
4060 :
4061 0 : std::vector < unsigned char* > :: const_iterator block = SgFileList::pools.begin();
4062 :
4063 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
4064 : // while (found == false && block < Memory_Block_List.end())
4065 0 : while ( (found == false) && (block != SgFileList::pools.end()) )
4066 : {
4067 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFileList::pool_size * sizeof(SgFileList) ) ) ;
4068 0 : ++block;
4069 : }
4070 :
4071 : // Special handling for static data
4072 :
4073 :
4074 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
4075 0 : ROSE_ASSERT(found == true);
4076 :
4077 0 : return found;
4078 : }
4079 : /* #line 4080 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4080 :
4081 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
4082 :
4083 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4084 :
4085 : /* #line 4086 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4086 :
4087 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4088 :
4089 : void
4090 0 : SgDirectoryList::checkDataMemberPointersIfInMemoryPool()
4091 : {
4092 : // ------------ checking pointers of SgDirectoryList -------------------
4093 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
4094 :
4095 0 : SgDirectoryPtrList::iterator i_listOfDirectories = p_listOfDirectories.begin() ;
4096 0 : for ( ; i_listOfDirectories != p_listOfDirectories.end(); ++i_listOfDirectories )
4097 : {
4098 0 : if ( (*i_listOfDirectories) != NULL )
4099 : {
4100 0 : if ( (*i_listOfDirectories)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4101 : {
4102 0 : if ( (*i_listOfDirectories)->isInMemoryPool() == false )
4103 : {
4104 0 : std::cout << "SgDirectoryList :: ";
4105 0 : std::cout << " p_listOfDirectories ( list of poitners to IR nodes ), entry is not in memory pool of ";
4106 0 : std::cout << (*i_listOfDirectories)->class_name() << std::endl;
4107 : }
4108 : }
4109 : else
4110 : {
4111 0 : std::cout << "SgDirectoryList :: " << std::flush;
4112 0 : std::cout << "SgDirectoryPtrList p_listOfDirectories --> " << std::flush;
4113 0 : std::cout << " entry not valid " << std::endl;
4114 : }
4115 : }
4116 : else
4117 : {
4118 0 : std::cout << "SgDirectoryPtrList p_listOfDirectories --> NULL " << std::endl;
4119 : }
4120 : }
4121 :
4122 0 : if ( p_parent != NULL )
4123 : {
4124 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4125 : {
4126 0 : if ( p_parent->isInMemoryPool() == false )
4127 : {
4128 0 : std::cout << "SgDirectoryList :: ";
4129 0 : std::cout << " p_parent is not in memory pool of ";
4130 0 : std::cout << p_parent->class_name() << std::endl;
4131 : }
4132 : }
4133 : else
4134 : {
4135 0 : std::cout << "SgDirectoryList :: " << std::flush;
4136 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
4137 0 : std::cout << " not valid " << std::endl;
4138 : }
4139 : }
4140 :
4141 :
4142 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4143 :
4144 0 : }
4145 :
4146 :
4147 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
4148 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
4149 : bool
4150 0 : SgDirectoryList::isInMemoryPool ()
4151 : {
4152 0 : typedef unsigned char* TestType;
4153 :
4154 0 : bool found = false;
4155 :
4156 0 : ROSE_ASSERT(this != NULL);
4157 :
4158 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
4159 :
4160 0 : TestType tested = (TestType) ( this ) ;
4161 :
4162 0 : std::vector < unsigned char* > :: const_iterator block = SgDirectoryList::pools.begin();
4163 :
4164 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
4165 : // while (found == false && block < Memory_Block_List.end())
4166 0 : while ( (found == false) && (block != SgDirectoryList::pools.end()) )
4167 : {
4168 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDirectoryList::pool_size * sizeof(SgDirectoryList) ) ) ;
4169 0 : ++block;
4170 : }
4171 :
4172 : // Special handling for static data
4173 :
4174 :
4175 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
4176 0 : ROSE_ASSERT(found == true);
4177 :
4178 0 : return found;
4179 : }
4180 : /* #line 4181 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4181 :
4182 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
4183 :
4184 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4185 :
4186 : /* #line 4187 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4187 :
4188 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4189 :
4190 : void
4191 0 : SgFunctionParameterTypeList::checkDataMemberPointersIfInMemoryPool()
4192 : {
4193 : // ------------ checking pointers of SgFunctionParameterTypeList -------------------
4194 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
4195 :
4196 0 : SgTypePtrList::iterator i_arguments = p_arguments.begin() ;
4197 0 : for ( ; i_arguments != p_arguments.end(); ++i_arguments )
4198 : {
4199 0 : if ( (*i_arguments) != NULL )
4200 : {
4201 0 : if ( (*i_arguments)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4202 : {
4203 0 : if ( (*i_arguments)->isInMemoryPool() == false )
4204 : {
4205 0 : std::cout << "SgFunctionParameterTypeList :: ";
4206 0 : std::cout << " p_arguments ( list of poitners to IR nodes ), entry is not in memory pool of ";
4207 0 : std::cout << (*i_arguments)->class_name() << std::endl;
4208 : }
4209 : }
4210 : else
4211 : {
4212 0 : std::cout << "SgFunctionParameterTypeList :: " << std::flush;
4213 0 : std::cout << "SgTypePtrList p_arguments --> " << std::flush;
4214 0 : std::cout << " entry not valid " << std::endl;
4215 : }
4216 : }
4217 : else
4218 : {
4219 0 : std::cout << "SgTypePtrList p_arguments --> NULL " << std::endl;
4220 : }
4221 : }
4222 :
4223 0 : if ( p_parent != NULL )
4224 : {
4225 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4226 : {
4227 0 : if ( p_parent->isInMemoryPool() == false )
4228 : {
4229 0 : std::cout << "SgFunctionParameterTypeList :: ";
4230 0 : std::cout << " p_parent is not in memory pool of ";
4231 0 : std::cout << p_parent->class_name() << std::endl;
4232 : }
4233 : }
4234 : else
4235 : {
4236 0 : std::cout << "SgFunctionParameterTypeList :: " << std::flush;
4237 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
4238 0 : std::cout << " not valid " << std::endl;
4239 : }
4240 : }
4241 :
4242 :
4243 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4244 :
4245 0 : }
4246 :
4247 :
4248 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
4249 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
4250 : bool
4251 0 : SgFunctionParameterTypeList::isInMemoryPool ()
4252 : {
4253 0 : typedef unsigned char* TestType;
4254 :
4255 0 : bool found = false;
4256 :
4257 0 : ROSE_ASSERT(this != NULL);
4258 :
4259 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
4260 :
4261 0 : TestType tested = (TestType) ( this ) ;
4262 :
4263 0 : std::vector < unsigned char* > :: const_iterator block = SgFunctionParameterTypeList::pools.begin();
4264 :
4265 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
4266 : // while (found == false && block < Memory_Block_List.end())
4267 0 : while ( (found == false) && (block != SgFunctionParameterTypeList::pools.end()) )
4268 : {
4269 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFunctionParameterTypeList::pool_size * sizeof(SgFunctionParameterTypeList) ) ) ;
4270 0 : ++block;
4271 : }
4272 :
4273 : // Special handling for static data
4274 :
4275 :
4276 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
4277 0 : ROSE_ASSERT(found == true);
4278 :
4279 0 : return found;
4280 : }
4281 : /* #line 4282 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4282 :
4283 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
4284 :
4285 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4286 :
4287 : /* #line 4288 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4288 :
4289 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4290 :
4291 : void
4292 0 : SgQualifiedName::checkDataMemberPointersIfInMemoryPool()
4293 : {
4294 : // ------------ checking pointers of SgQualifiedName -------------------
4295 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
4296 :
4297 0 : if ( p_scope != NULL )
4298 : {
4299 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4300 : {
4301 0 : if ( p_scope->isInMemoryPool() == false )
4302 : {
4303 0 : std::cout << "SgQualifiedName :: ";
4304 0 : std::cout << " p_scope is not in memory pool of ";
4305 0 : std::cout << p_scope->class_name() << std::endl;
4306 : }
4307 : }
4308 : else
4309 : {
4310 0 : std::cout << "SgQualifiedName :: " << std::flush;
4311 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
4312 0 : std::cout << " not valid " << std::endl;
4313 : }
4314 : }
4315 :
4316 0 : if ( p_parent != NULL )
4317 : {
4318 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4319 : {
4320 0 : if ( p_parent->isInMemoryPool() == false )
4321 : {
4322 0 : std::cout << "SgQualifiedName :: ";
4323 0 : std::cout << " p_parent is not in memory pool of ";
4324 0 : std::cout << p_parent->class_name() << std::endl;
4325 : }
4326 : }
4327 : else
4328 : {
4329 0 : std::cout << "SgQualifiedName :: " << std::flush;
4330 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
4331 0 : std::cout << " not valid " << std::endl;
4332 : }
4333 : }
4334 :
4335 :
4336 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4337 :
4338 0 : }
4339 :
4340 :
4341 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
4342 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
4343 : bool
4344 0 : SgQualifiedName::isInMemoryPool ()
4345 : {
4346 0 : typedef unsigned char* TestType;
4347 :
4348 0 : bool found = false;
4349 :
4350 0 : ROSE_ASSERT(this != NULL);
4351 :
4352 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
4353 :
4354 0 : TestType tested = (TestType) ( this ) ;
4355 :
4356 0 : std::vector < unsigned char* > :: const_iterator block = SgQualifiedName::pools.begin();
4357 :
4358 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
4359 : // while (found == false && block < Memory_Block_List.end())
4360 0 : while ( (found == false) && (block != SgQualifiedName::pools.end()) )
4361 : {
4362 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgQualifiedName::pool_size * sizeof(SgQualifiedName) ) ) ;
4363 0 : ++block;
4364 : }
4365 :
4366 : // Special handling for static data
4367 :
4368 :
4369 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
4370 0 : ROSE_ASSERT(found == true);
4371 :
4372 0 : return found;
4373 : }
4374 : /* #line 4375 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4375 :
4376 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
4377 :
4378 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4379 :
4380 : /* #line 4381 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4381 :
4382 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4383 :
4384 : void
4385 0 : SgTemplateArgumentList::checkDataMemberPointersIfInMemoryPool()
4386 : {
4387 : // ------------ checking pointers of SgTemplateArgumentList -------------------
4388 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
4389 :
4390 0 : SgTemplateArgumentPtrList::iterator i_args = p_args.begin() ;
4391 0 : for ( ; i_args != p_args.end(); ++i_args )
4392 : {
4393 0 : if ( (*i_args) != NULL )
4394 : {
4395 0 : if ( (*i_args)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4396 : {
4397 0 : if ( (*i_args)->isInMemoryPool() == false )
4398 : {
4399 0 : std::cout << "SgTemplateArgumentList :: ";
4400 0 : std::cout << " p_args ( list of poitners to IR nodes ), entry is not in memory pool of ";
4401 0 : std::cout << (*i_args)->class_name() << std::endl;
4402 : }
4403 : }
4404 : else
4405 : {
4406 0 : std::cout << "SgTemplateArgumentList :: " << std::flush;
4407 0 : std::cout << "SgTemplateArgumentPtrList p_args --> " << std::flush;
4408 0 : std::cout << " entry not valid " << std::endl;
4409 : }
4410 : }
4411 : else
4412 : {
4413 0 : std::cout << "SgTemplateArgumentPtrList p_args --> NULL " << std::endl;
4414 : }
4415 : }
4416 :
4417 0 : if ( p_parent != NULL )
4418 : {
4419 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4420 : {
4421 0 : if ( p_parent->isInMemoryPool() == false )
4422 : {
4423 0 : std::cout << "SgTemplateArgumentList :: ";
4424 0 : std::cout << " p_parent is not in memory pool of ";
4425 0 : std::cout << p_parent->class_name() << std::endl;
4426 : }
4427 : }
4428 : else
4429 : {
4430 0 : std::cout << "SgTemplateArgumentList :: " << std::flush;
4431 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
4432 0 : std::cout << " not valid " << std::endl;
4433 : }
4434 : }
4435 :
4436 :
4437 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4438 :
4439 0 : }
4440 :
4441 :
4442 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
4443 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
4444 : bool
4445 0 : SgTemplateArgumentList::isInMemoryPool ()
4446 : {
4447 0 : typedef unsigned char* TestType;
4448 :
4449 0 : bool found = false;
4450 :
4451 0 : ROSE_ASSERT(this != NULL);
4452 :
4453 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
4454 :
4455 0 : TestType tested = (TestType) ( this ) ;
4456 :
4457 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateArgumentList::pools.begin();
4458 :
4459 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
4460 : // while (found == false && block < Memory_Block_List.end())
4461 0 : while ( (found == false) && (block != SgTemplateArgumentList::pools.end()) )
4462 : {
4463 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateArgumentList::pool_size * sizeof(SgTemplateArgumentList) ) ) ;
4464 0 : ++block;
4465 : }
4466 :
4467 : // Special handling for static data
4468 :
4469 :
4470 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
4471 0 : ROSE_ASSERT(found == true);
4472 :
4473 0 : return found;
4474 : }
4475 : /* #line 4476 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4476 :
4477 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
4478 :
4479 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4480 :
4481 : /* #line 4482 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4482 :
4483 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4484 :
4485 : void
4486 0 : SgTemplateParameterList::checkDataMemberPointersIfInMemoryPool()
4487 : {
4488 : // ------------ checking pointers of SgTemplateParameterList -------------------
4489 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
4490 :
4491 0 : SgTemplateParameterPtrList::iterator i_args = p_args.begin() ;
4492 0 : for ( ; i_args != p_args.end(); ++i_args )
4493 : {
4494 0 : if ( (*i_args) != NULL )
4495 : {
4496 0 : if ( (*i_args)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4497 : {
4498 0 : if ( (*i_args)->isInMemoryPool() == false )
4499 : {
4500 0 : std::cout << "SgTemplateParameterList :: ";
4501 0 : std::cout << " p_args ( list of poitners to IR nodes ), entry is not in memory pool of ";
4502 0 : std::cout << (*i_args)->class_name() << std::endl;
4503 : }
4504 : }
4505 : else
4506 : {
4507 0 : std::cout << "SgTemplateParameterList :: " << std::flush;
4508 0 : std::cout << "SgTemplateParameterPtrList p_args --> " << std::flush;
4509 0 : std::cout << " entry not valid " << std::endl;
4510 : }
4511 : }
4512 : else
4513 : {
4514 0 : std::cout << "SgTemplateParameterPtrList p_args --> NULL " << std::endl;
4515 : }
4516 : }
4517 :
4518 0 : if ( p_parent != NULL )
4519 : {
4520 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4521 : {
4522 0 : if ( p_parent->isInMemoryPool() == false )
4523 : {
4524 0 : std::cout << "SgTemplateParameterList :: ";
4525 0 : std::cout << " p_parent is not in memory pool of ";
4526 0 : std::cout << p_parent->class_name() << std::endl;
4527 : }
4528 : }
4529 : else
4530 : {
4531 0 : std::cout << "SgTemplateParameterList :: " << std::flush;
4532 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
4533 0 : std::cout << " not valid " << std::endl;
4534 : }
4535 : }
4536 :
4537 :
4538 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4539 :
4540 0 : }
4541 :
4542 :
4543 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
4544 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
4545 : bool
4546 0 : SgTemplateParameterList::isInMemoryPool ()
4547 : {
4548 0 : typedef unsigned char* TestType;
4549 :
4550 0 : bool found = false;
4551 :
4552 0 : ROSE_ASSERT(this != NULL);
4553 :
4554 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
4555 :
4556 0 : TestType tested = (TestType) ( this ) ;
4557 :
4558 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateParameterList::pools.begin();
4559 :
4560 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
4561 : // while (found == false && block < Memory_Block_List.end())
4562 0 : while ( (found == false) && (block != SgTemplateParameterList::pools.end()) )
4563 : {
4564 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateParameterList::pool_size * sizeof(SgTemplateParameterList) ) ) ;
4565 0 : ++block;
4566 : }
4567 :
4568 : // Special handling for static data
4569 :
4570 :
4571 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
4572 0 : ROSE_ASSERT(found == true);
4573 :
4574 0 : return found;
4575 : }
4576 : /* #line 4577 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4577 :
4578 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
4579 :
4580 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4581 :
4582 : /* #line 4583 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4583 :
4584 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4585 :
4586 : void
4587 0 : SgGraph::checkDataMemberPointersIfInMemoryPool()
4588 : {
4589 : // ------------ checking pointers of SgGraph -------------------
4590 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
4591 :
4592 0 : if ( p_parent != NULL )
4593 : {
4594 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4595 : {
4596 0 : if ( p_parent->isInMemoryPool() == false )
4597 : {
4598 0 : std::cout << "SgGraph :: ";
4599 0 : std::cout << " p_parent is not in memory pool of ";
4600 0 : std::cout << p_parent->class_name() << std::endl;
4601 : }
4602 : }
4603 : else
4604 : {
4605 0 : std::cout << "SgGraph :: " << std::flush;
4606 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
4607 0 : std::cout << " not valid " << std::endl;
4608 : }
4609 : }
4610 :
4611 :
4612 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4613 :
4614 0 : }
4615 :
4616 :
4617 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
4618 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
4619 : bool
4620 0 : SgGraph::isInMemoryPool ()
4621 : {
4622 0 : typedef unsigned char* TestType;
4623 :
4624 0 : bool found = false;
4625 :
4626 0 : ROSE_ASSERT(this != NULL);
4627 :
4628 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
4629 :
4630 0 : TestType tested = (TestType) ( this ) ;
4631 :
4632 0 : std::vector < unsigned char* > :: const_iterator block = SgGraph::pools.begin();
4633 :
4634 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
4635 : // while (found == false && block < Memory_Block_List.end())
4636 0 : while ( (found == false) && (block != SgGraph::pools.end()) )
4637 : {
4638 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgGraph::pool_size * sizeof(SgGraph) ) ) ;
4639 0 : ++block;
4640 : }
4641 :
4642 : // Special handling for static data
4643 :
4644 :
4645 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
4646 0 : ROSE_ASSERT(found == true);
4647 :
4648 0 : return found;
4649 : }
4650 : /* #line 4651 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4651 :
4652 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
4653 :
4654 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4655 :
4656 : /* #line 4657 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4657 :
4658 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4659 :
4660 : void
4661 0 : SgIncidenceDirectedGraph::checkDataMemberPointersIfInMemoryPool()
4662 : {
4663 : // ------------ checking pointers of SgIncidenceDirectedGraph -------------------
4664 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
4665 :
4666 0 : if ( p_parent != NULL )
4667 : {
4668 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4669 : {
4670 0 : if ( p_parent->isInMemoryPool() == false )
4671 : {
4672 0 : std::cout << "SgIncidenceDirectedGraph :: ";
4673 0 : std::cout << " p_parent is not in memory pool of ";
4674 0 : std::cout << p_parent->class_name() << std::endl;
4675 : }
4676 : }
4677 : else
4678 : {
4679 0 : std::cout << "SgIncidenceDirectedGraph :: " << std::flush;
4680 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
4681 0 : std::cout << " not valid " << std::endl;
4682 : }
4683 : }
4684 :
4685 :
4686 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4687 :
4688 0 : }
4689 :
4690 :
4691 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
4692 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
4693 : bool
4694 0 : SgIncidenceDirectedGraph::isInMemoryPool ()
4695 : {
4696 0 : typedef unsigned char* TestType;
4697 :
4698 0 : bool found = false;
4699 :
4700 0 : ROSE_ASSERT(this != NULL);
4701 :
4702 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
4703 :
4704 0 : TestType tested = (TestType) ( this ) ;
4705 :
4706 0 : std::vector < unsigned char* > :: const_iterator block = SgIncidenceDirectedGraph::pools.begin();
4707 :
4708 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
4709 : // while (found == false && block < Memory_Block_List.end())
4710 0 : while ( (found == false) && (block != SgIncidenceDirectedGraph::pools.end()) )
4711 : {
4712 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIncidenceDirectedGraph::pool_size * sizeof(SgIncidenceDirectedGraph) ) ) ;
4713 0 : ++block;
4714 : }
4715 :
4716 : // Special handling for static data
4717 :
4718 :
4719 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
4720 0 : ROSE_ASSERT(found == true);
4721 :
4722 0 : return found;
4723 : }
4724 : /* #line 4725 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4725 :
4726 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
4727 :
4728 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4729 :
4730 : /* #line 4731 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4731 :
4732 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4733 :
4734 : void
4735 0 : SgBidirectionalGraph::checkDataMemberPointersIfInMemoryPool()
4736 : {
4737 : // ------------ checking pointers of SgBidirectionalGraph -------------------
4738 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
4739 :
4740 0 : if ( p_parent != NULL )
4741 : {
4742 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4743 : {
4744 0 : if ( p_parent->isInMemoryPool() == false )
4745 : {
4746 0 : std::cout << "SgBidirectionalGraph :: ";
4747 0 : std::cout << " p_parent is not in memory pool of ";
4748 0 : std::cout << p_parent->class_name() << std::endl;
4749 : }
4750 : }
4751 : else
4752 : {
4753 0 : std::cout << "SgBidirectionalGraph :: " << std::flush;
4754 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
4755 0 : std::cout << " not valid " << std::endl;
4756 : }
4757 : }
4758 :
4759 :
4760 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4761 :
4762 0 : }
4763 :
4764 :
4765 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
4766 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
4767 : bool
4768 0 : SgBidirectionalGraph::isInMemoryPool ()
4769 : {
4770 0 : typedef unsigned char* TestType;
4771 :
4772 0 : bool found = false;
4773 :
4774 0 : ROSE_ASSERT(this != NULL);
4775 :
4776 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
4777 :
4778 0 : TestType tested = (TestType) ( this ) ;
4779 :
4780 0 : std::vector < unsigned char* > :: const_iterator block = SgBidirectionalGraph::pools.begin();
4781 :
4782 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
4783 : // while (found == false && block < Memory_Block_List.end())
4784 0 : while ( (found == false) && (block != SgBidirectionalGraph::pools.end()) )
4785 : {
4786 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgBidirectionalGraph::pool_size * sizeof(SgBidirectionalGraph) ) ) ;
4787 0 : ++block;
4788 : }
4789 :
4790 : // Special handling for static data
4791 :
4792 :
4793 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
4794 0 : ROSE_ASSERT(found == true);
4795 :
4796 0 : return found;
4797 : }
4798 : /* #line 4799 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4799 :
4800 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
4801 :
4802 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4803 :
4804 : /* #line 4805 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4805 :
4806 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4807 :
4808 : void
4809 0 : SgStringKeyedBidirectionalGraph::checkDataMemberPointersIfInMemoryPool()
4810 : {
4811 : // ------------ checking pointers of SgStringKeyedBidirectionalGraph -------------------
4812 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
4813 :
4814 0 : if ( p_parent != NULL )
4815 : {
4816 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4817 : {
4818 0 : if ( p_parent->isInMemoryPool() == false )
4819 : {
4820 0 : std::cout << "SgStringKeyedBidirectionalGraph :: ";
4821 0 : std::cout << " p_parent is not in memory pool of ";
4822 0 : std::cout << p_parent->class_name() << std::endl;
4823 : }
4824 : }
4825 : else
4826 : {
4827 0 : std::cout << "SgStringKeyedBidirectionalGraph :: " << std::flush;
4828 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
4829 0 : std::cout << " not valid " << std::endl;
4830 : }
4831 : }
4832 :
4833 :
4834 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4835 :
4836 0 : }
4837 :
4838 :
4839 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
4840 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
4841 : bool
4842 0 : SgStringKeyedBidirectionalGraph::isInMemoryPool ()
4843 : {
4844 0 : typedef unsigned char* TestType;
4845 :
4846 0 : bool found = false;
4847 :
4848 0 : ROSE_ASSERT(this != NULL);
4849 :
4850 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
4851 :
4852 0 : TestType tested = (TestType) ( this ) ;
4853 :
4854 0 : std::vector < unsigned char* > :: const_iterator block = SgStringKeyedBidirectionalGraph::pools.begin();
4855 :
4856 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
4857 : // while (found == false && block < Memory_Block_List.end())
4858 0 : while ( (found == false) && (block != SgStringKeyedBidirectionalGraph::pools.end()) )
4859 : {
4860 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgStringKeyedBidirectionalGraph::pool_size * sizeof(SgStringKeyedBidirectionalGraph) ) ) ;
4861 0 : ++block;
4862 : }
4863 :
4864 : // Special handling for static data
4865 :
4866 :
4867 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
4868 0 : ROSE_ASSERT(found == true);
4869 :
4870 0 : return found;
4871 : }
4872 : /* #line 4873 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4873 :
4874 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
4875 :
4876 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4877 :
4878 : /* #line 4879 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4879 :
4880 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4881 :
4882 : void
4883 0 : SgIntKeyedBidirectionalGraph::checkDataMemberPointersIfInMemoryPool()
4884 : {
4885 : // ------------ checking pointers of SgIntKeyedBidirectionalGraph -------------------
4886 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
4887 :
4888 0 : if ( p_parent != NULL )
4889 : {
4890 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4891 : {
4892 0 : if ( p_parent->isInMemoryPool() == false )
4893 : {
4894 0 : std::cout << "SgIntKeyedBidirectionalGraph :: ";
4895 0 : std::cout << " p_parent is not in memory pool of ";
4896 0 : std::cout << p_parent->class_name() << std::endl;
4897 : }
4898 : }
4899 : else
4900 : {
4901 0 : std::cout << "SgIntKeyedBidirectionalGraph :: " << std::flush;
4902 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
4903 0 : std::cout << " not valid " << std::endl;
4904 : }
4905 : }
4906 :
4907 :
4908 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4909 :
4910 0 : }
4911 :
4912 :
4913 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
4914 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
4915 : bool
4916 0 : SgIntKeyedBidirectionalGraph::isInMemoryPool ()
4917 : {
4918 0 : typedef unsigned char* TestType;
4919 :
4920 0 : bool found = false;
4921 :
4922 0 : ROSE_ASSERT(this != NULL);
4923 :
4924 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
4925 :
4926 0 : TestType tested = (TestType) ( this ) ;
4927 :
4928 0 : std::vector < unsigned char* > :: const_iterator block = SgIntKeyedBidirectionalGraph::pools.begin();
4929 :
4930 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
4931 : // while (found == false && block < Memory_Block_List.end())
4932 0 : while ( (found == false) && (block != SgIntKeyedBidirectionalGraph::pools.end()) )
4933 : {
4934 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIntKeyedBidirectionalGraph::pool_size * sizeof(SgIntKeyedBidirectionalGraph) ) ) ;
4935 0 : ++block;
4936 : }
4937 :
4938 : // Special handling for static data
4939 :
4940 :
4941 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
4942 0 : ROSE_ASSERT(found == true);
4943 :
4944 0 : return found;
4945 : }
4946 : /* #line 4947 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4947 :
4948 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
4949 :
4950 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4951 :
4952 : /* #line 4953 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
4953 :
4954 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4955 :
4956 : void
4957 0 : SgIncidenceUndirectedGraph::checkDataMemberPointersIfInMemoryPool()
4958 : {
4959 : // ------------ checking pointers of SgIncidenceUndirectedGraph -------------------
4960 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
4961 :
4962 0 : if ( p_parent != NULL )
4963 : {
4964 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
4965 : {
4966 0 : if ( p_parent->isInMemoryPool() == false )
4967 : {
4968 0 : std::cout << "SgIncidenceUndirectedGraph :: ";
4969 0 : std::cout << " p_parent is not in memory pool of ";
4970 0 : std::cout << p_parent->class_name() << std::endl;
4971 : }
4972 : }
4973 : else
4974 : {
4975 0 : std::cout << "SgIncidenceUndirectedGraph :: " << std::flush;
4976 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
4977 0 : std::cout << " not valid " << std::endl;
4978 : }
4979 : }
4980 :
4981 :
4982 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
4983 :
4984 0 : }
4985 :
4986 :
4987 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
4988 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
4989 : bool
4990 0 : SgIncidenceUndirectedGraph::isInMemoryPool ()
4991 : {
4992 0 : typedef unsigned char* TestType;
4993 :
4994 0 : bool found = false;
4995 :
4996 0 : ROSE_ASSERT(this != NULL);
4997 :
4998 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
4999 :
5000 0 : TestType tested = (TestType) ( this ) ;
5001 :
5002 0 : std::vector < unsigned char* > :: const_iterator block = SgIncidenceUndirectedGraph::pools.begin();
5003 :
5004 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
5005 : // while (found == false && block < Memory_Block_List.end())
5006 0 : while ( (found == false) && (block != SgIncidenceUndirectedGraph::pools.end()) )
5007 : {
5008 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIncidenceUndirectedGraph::pool_size * sizeof(SgIncidenceUndirectedGraph) ) ) ;
5009 0 : ++block;
5010 : }
5011 :
5012 : // Special handling for static data
5013 :
5014 :
5015 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
5016 0 : ROSE_ASSERT(found == true);
5017 :
5018 0 : return found;
5019 : }
5020 : /* #line 5021 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5021 :
5022 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
5023 :
5024 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5025 :
5026 : /* #line 5027 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5027 :
5028 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5029 :
5030 : void
5031 0 : SgGraphNode::checkDataMemberPointersIfInMemoryPool()
5032 : {
5033 : // ------------ checking pointers of SgGraphNode -------------------
5034 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
5035 :
5036 0 : if ( p_SgNode != NULL )
5037 : {
5038 0 : if ( p_SgNode->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5039 : {
5040 0 : if ( p_SgNode->isInMemoryPool() == false )
5041 : {
5042 0 : std::cout << "SgGraphNode :: ";
5043 0 : std::cout << " p_SgNode is not in memory pool of ";
5044 0 : std::cout << p_SgNode->class_name() << std::endl;
5045 : }
5046 : }
5047 : else
5048 : {
5049 0 : std::cout << "SgGraphNode :: " << std::flush;
5050 0 : std::cout << "SgNode* p_SgNode = " << p_SgNode << " --> " << std::flush;
5051 0 : std::cout << " not valid " << std::endl;
5052 : }
5053 : }
5054 :
5055 0 : if ( p_parent != NULL )
5056 : {
5057 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5058 : {
5059 0 : if ( p_parent->isInMemoryPool() == false )
5060 : {
5061 0 : std::cout << "SgGraphNode :: ";
5062 0 : std::cout << " p_parent is not in memory pool of ";
5063 0 : std::cout << p_parent->class_name() << std::endl;
5064 : }
5065 : }
5066 : else
5067 : {
5068 0 : std::cout << "SgGraphNode :: " << std::flush;
5069 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
5070 0 : std::cout << " not valid " << std::endl;
5071 : }
5072 : }
5073 :
5074 :
5075 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5076 :
5077 0 : }
5078 :
5079 :
5080 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
5081 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
5082 : bool
5083 0 : SgGraphNode::isInMemoryPool ()
5084 : {
5085 0 : typedef unsigned char* TestType;
5086 :
5087 0 : bool found = false;
5088 :
5089 0 : ROSE_ASSERT(this != NULL);
5090 :
5091 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
5092 :
5093 0 : TestType tested = (TestType) ( this ) ;
5094 :
5095 0 : std::vector < unsigned char* > :: const_iterator block = SgGraphNode::pools.begin();
5096 :
5097 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
5098 : // while (found == false && block < Memory_Block_List.end())
5099 0 : while ( (found == false) && (block != SgGraphNode::pools.end()) )
5100 : {
5101 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgGraphNode::pool_size * sizeof(SgGraphNode) ) ) ;
5102 0 : ++block;
5103 : }
5104 :
5105 : // Special handling for static data
5106 :
5107 :
5108 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
5109 0 : ROSE_ASSERT(found == true);
5110 :
5111 0 : return found;
5112 : }
5113 : /* #line 5114 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5114 :
5115 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
5116 :
5117 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5118 :
5119 : /* #line 5120 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5120 :
5121 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5122 :
5123 : void
5124 0 : SgGraphEdge::checkDataMemberPointersIfInMemoryPool()
5125 : {
5126 : // ------------ checking pointers of SgGraphEdge -------------------
5127 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
5128 :
5129 0 : if ( p_node_A != NULL )
5130 : {
5131 0 : if ( p_node_A->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5132 : {
5133 0 : if ( p_node_A->isInMemoryPool() == false )
5134 : {
5135 0 : std::cout << "SgGraphEdge :: ";
5136 0 : std::cout << " p_node_A is not in memory pool of ";
5137 0 : std::cout << p_node_A->class_name() << std::endl;
5138 : }
5139 : }
5140 : else
5141 : {
5142 0 : std::cout << "SgGraphEdge :: " << std::flush;
5143 0 : std::cout << "SgGraphNode* p_node_A = " << p_node_A << " --> " << std::flush;
5144 0 : std::cout << " not valid " << std::endl;
5145 : }
5146 : }
5147 :
5148 0 : if ( p_node_B != NULL )
5149 : {
5150 0 : if ( p_node_B->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5151 : {
5152 0 : if ( p_node_B->isInMemoryPool() == false )
5153 : {
5154 0 : std::cout << "SgGraphEdge :: ";
5155 0 : std::cout << " p_node_B is not in memory pool of ";
5156 0 : std::cout << p_node_B->class_name() << std::endl;
5157 : }
5158 : }
5159 : else
5160 : {
5161 0 : std::cout << "SgGraphEdge :: " << std::flush;
5162 0 : std::cout << "SgGraphNode* p_node_B = " << p_node_B << " --> " << std::flush;
5163 0 : std::cout << " not valid " << std::endl;
5164 : }
5165 : }
5166 :
5167 0 : if ( p_parent != NULL )
5168 : {
5169 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5170 : {
5171 0 : if ( p_parent->isInMemoryPool() == false )
5172 : {
5173 0 : std::cout << "SgGraphEdge :: ";
5174 0 : std::cout << " p_parent is not in memory pool of ";
5175 0 : std::cout << p_parent->class_name() << std::endl;
5176 : }
5177 : }
5178 : else
5179 : {
5180 0 : std::cout << "SgGraphEdge :: " << std::flush;
5181 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
5182 0 : std::cout << " not valid " << std::endl;
5183 : }
5184 : }
5185 :
5186 :
5187 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5188 :
5189 0 : }
5190 :
5191 :
5192 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
5193 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
5194 : bool
5195 0 : SgGraphEdge::isInMemoryPool ()
5196 : {
5197 0 : typedef unsigned char* TestType;
5198 :
5199 0 : bool found = false;
5200 :
5201 0 : ROSE_ASSERT(this != NULL);
5202 :
5203 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
5204 :
5205 0 : TestType tested = (TestType) ( this ) ;
5206 :
5207 0 : std::vector < unsigned char* > :: const_iterator block = SgGraphEdge::pools.begin();
5208 :
5209 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
5210 : // while (found == false && block < Memory_Block_List.end())
5211 0 : while ( (found == false) && (block != SgGraphEdge::pools.end()) )
5212 : {
5213 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgGraphEdge::pool_size * sizeof(SgGraphEdge) ) ) ;
5214 0 : ++block;
5215 : }
5216 :
5217 : // Special handling for static data
5218 :
5219 :
5220 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
5221 0 : ROSE_ASSERT(found == true);
5222 :
5223 0 : return found;
5224 : }
5225 : /* #line 5226 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5226 :
5227 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
5228 :
5229 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5230 :
5231 : /* #line 5232 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5232 :
5233 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5234 :
5235 : void
5236 0 : SgDirectedGraphEdge::checkDataMemberPointersIfInMemoryPool()
5237 : {
5238 : // ------------ checking pointers of SgDirectedGraphEdge -------------------
5239 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
5240 :
5241 0 : if ( p_node_A != NULL )
5242 : {
5243 0 : if ( p_node_A->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5244 : {
5245 0 : if ( p_node_A->isInMemoryPool() == false )
5246 : {
5247 0 : std::cout << "SgDirectedGraphEdge :: ";
5248 0 : std::cout << " p_node_A is not in memory pool of ";
5249 0 : std::cout << p_node_A->class_name() << std::endl;
5250 : }
5251 : }
5252 : else
5253 : {
5254 0 : std::cout << "SgDirectedGraphEdge :: " << std::flush;
5255 0 : std::cout << "SgGraphNode* p_node_A = " << p_node_A << " --> " << std::flush;
5256 0 : std::cout << " not valid " << std::endl;
5257 : }
5258 : }
5259 :
5260 0 : if ( p_node_B != NULL )
5261 : {
5262 0 : if ( p_node_B->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5263 : {
5264 0 : if ( p_node_B->isInMemoryPool() == false )
5265 : {
5266 0 : std::cout << "SgDirectedGraphEdge :: ";
5267 0 : std::cout << " p_node_B is not in memory pool of ";
5268 0 : std::cout << p_node_B->class_name() << std::endl;
5269 : }
5270 : }
5271 : else
5272 : {
5273 0 : std::cout << "SgDirectedGraphEdge :: " << std::flush;
5274 0 : std::cout << "SgGraphNode* p_node_B = " << p_node_B << " --> " << std::flush;
5275 0 : std::cout << " not valid " << std::endl;
5276 : }
5277 : }
5278 :
5279 0 : if ( p_parent != NULL )
5280 : {
5281 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5282 : {
5283 0 : if ( p_parent->isInMemoryPool() == false )
5284 : {
5285 0 : std::cout << "SgDirectedGraphEdge :: ";
5286 0 : std::cout << " p_parent is not in memory pool of ";
5287 0 : std::cout << p_parent->class_name() << std::endl;
5288 : }
5289 : }
5290 : else
5291 : {
5292 0 : std::cout << "SgDirectedGraphEdge :: " << std::flush;
5293 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
5294 0 : std::cout << " not valid " << std::endl;
5295 : }
5296 : }
5297 :
5298 :
5299 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5300 :
5301 0 : }
5302 :
5303 :
5304 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
5305 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
5306 : bool
5307 0 : SgDirectedGraphEdge::isInMemoryPool ()
5308 : {
5309 0 : typedef unsigned char* TestType;
5310 :
5311 0 : bool found = false;
5312 :
5313 0 : ROSE_ASSERT(this != NULL);
5314 :
5315 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
5316 :
5317 0 : TestType tested = (TestType) ( this ) ;
5318 :
5319 0 : std::vector < unsigned char* > :: const_iterator block = SgDirectedGraphEdge::pools.begin();
5320 :
5321 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
5322 : // while (found == false && block < Memory_Block_List.end())
5323 0 : while ( (found == false) && (block != SgDirectedGraphEdge::pools.end()) )
5324 : {
5325 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDirectedGraphEdge::pool_size * sizeof(SgDirectedGraphEdge) ) ) ;
5326 0 : ++block;
5327 : }
5328 :
5329 : // Special handling for static data
5330 :
5331 :
5332 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
5333 0 : ROSE_ASSERT(found == true);
5334 :
5335 0 : return found;
5336 : }
5337 : /* #line 5338 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5338 :
5339 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
5340 :
5341 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5342 :
5343 : /* #line 5344 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5344 :
5345 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5346 :
5347 : void
5348 0 : SgUndirectedGraphEdge::checkDataMemberPointersIfInMemoryPool()
5349 : {
5350 : // ------------ checking pointers of SgUndirectedGraphEdge -------------------
5351 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
5352 :
5353 0 : if ( p_node_A != NULL )
5354 : {
5355 0 : if ( p_node_A->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5356 : {
5357 0 : if ( p_node_A->isInMemoryPool() == false )
5358 : {
5359 0 : std::cout << "SgUndirectedGraphEdge :: ";
5360 0 : std::cout << " p_node_A is not in memory pool of ";
5361 0 : std::cout << p_node_A->class_name() << std::endl;
5362 : }
5363 : }
5364 : else
5365 : {
5366 0 : std::cout << "SgUndirectedGraphEdge :: " << std::flush;
5367 0 : std::cout << "SgGraphNode* p_node_A = " << p_node_A << " --> " << std::flush;
5368 0 : std::cout << " not valid " << std::endl;
5369 : }
5370 : }
5371 :
5372 0 : if ( p_node_B != NULL )
5373 : {
5374 0 : if ( p_node_B->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5375 : {
5376 0 : if ( p_node_B->isInMemoryPool() == false )
5377 : {
5378 0 : std::cout << "SgUndirectedGraphEdge :: ";
5379 0 : std::cout << " p_node_B is not in memory pool of ";
5380 0 : std::cout << p_node_B->class_name() << std::endl;
5381 : }
5382 : }
5383 : else
5384 : {
5385 0 : std::cout << "SgUndirectedGraphEdge :: " << std::flush;
5386 0 : std::cout << "SgGraphNode* p_node_B = " << p_node_B << " --> " << std::flush;
5387 0 : std::cout << " not valid " << std::endl;
5388 : }
5389 : }
5390 :
5391 0 : if ( p_parent != NULL )
5392 : {
5393 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5394 : {
5395 0 : if ( p_parent->isInMemoryPool() == false )
5396 : {
5397 0 : std::cout << "SgUndirectedGraphEdge :: ";
5398 0 : std::cout << " p_parent is not in memory pool of ";
5399 0 : std::cout << p_parent->class_name() << std::endl;
5400 : }
5401 : }
5402 : else
5403 : {
5404 0 : std::cout << "SgUndirectedGraphEdge :: " << std::flush;
5405 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
5406 0 : std::cout << " not valid " << std::endl;
5407 : }
5408 : }
5409 :
5410 :
5411 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5412 :
5413 0 : }
5414 :
5415 :
5416 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
5417 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
5418 : bool
5419 0 : SgUndirectedGraphEdge::isInMemoryPool ()
5420 : {
5421 0 : typedef unsigned char* TestType;
5422 :
5423 0 : bool found = false;
5424 :
5425 0 : ROSE_ASSERT(this != NULL);
5426 :
5427 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
5428 :
5429 0 : TestType tested = (TestType) ( this ) ;
5430 :
5431 0 : std::vector < unsigned char* > :: const_iterator block = SgUndirectedGraphEdge::pools.begin();
5432 :
5433 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
5434 : // while (found == false && block < Memory_Block_List.end())
5435 0 : while ( (found == false) && (block != SgUndirectedGraphEdge::pools.end()) )
5436 : {
5437 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUndirectedGraphEdge::pool_size * sizeof(SgUndirectedGraphEdge) ) ) ;
5438 0 : ++block;
5439 : }
5440 :
5441 : // Special handling for static data
5442 :
5443 :
5444 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
5445 0 : ROSE_ASSERT(found == true);
5446 :
5447 0 : return found;
5448 : }
5449 : /* #line 5450 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5450 :
5451 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
5452 :
5453 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5454 :
5455 : /* #line 5456 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5456 :
5457 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5458 :
5459 : void
5460 0 : SgGraphNodeList::checkDataMemberPointersIfInMemoryPool()
5461 : {
5462 : // ------------ checking pointers of SgGraphNodeList -------------------
5463 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
5464 :
5465 0 : if ( p_parent != NULL )
5466 : {
5467 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5468 : {
5469 0 : if ( p_parent->isInMemoryPool() == false )
5470 : {
5471 0 : std::cout << "SgGraphNodeList :: ";
5472 0 : std::cout << " p_parent is not in memory pool of ";
5473 0 : std::cout << p_parent->class_name() << std::endl;
5474 : }
5475 : }
5476 : else
5477 : {
5478 0 : std::cout << "SgGraphNodeList :: " << std::flush;
5479 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
5480 0 : std::cout << " not valid " << std::endl;
5481 : }
5482 : }
5483 :
5484 :
5485 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5486 :
5487 0 : }
5488 :
5489 :
5490 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
5491 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
5492 : bool
5493 0 : SgGraphNodeList::isInMemoryPool ()
5494 : {
5495 0 : typedef unsigned char* TestType;
5496 :
5497 0 : bool found = false;
5498 :
5499 0 : ROSE_ASSERT(this != NULL);
5500 :
5501 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
5502 :
5503 0 : TestType tested = (TestType) ( this ) ;
5504 :
5505 0 : std::vector < unsigned char* > :: const_iterator block = SgGraphNodeList::pools.begin();
5506 :
5507 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
5508 : // while (found == false && block < Memory_Block_List.end())
5509 0 : while ( (found == false) && (block != SgGraphNodeList::pools.end()) )
5510 : {
5511 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgGraphNodeList::pool_size * sizeof(SgGraphNodeList) ) ) ;
5512 0 : ++block;
5513 : }
5514 :
5515 : // Special handling for static data
5516 :
5517 :
5518 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
5519 0 : ROSE_ASSERT(found == true);
5520 :
5521 0 : return found;
5522 : }
5523 : /* #line 5524 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5524 :
5525 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
5526 :
5527 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5528 :
5529 : /* #line 5530 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5530 :
5531 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5532 :
5533 : void
5534 0 : SgGraphEdgeList::checkDataMemberPointersIfInMemoryPool()
5535 : {
5536 : // ------------ checking pointers of SgGraphEdgeList -------------------
5537 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
5538 :
5539 0 : if ( p_parent != NULL )
5540 : {
5541 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5542 : {
5543 0 : if ( p_parent->isInMemoryPool() == false )
5544 : {
5545 0 : std::cout << "SgGraphEdgeList :: ";
5546 0 : std::cout << " p_parent is not in memory pool of ";
5547 0 : std::cout << p_parent->class_name() << std::endl;
5548 : }
5549 : }
5550 : else
5551 : {
5552 0 : std::cout << "SgGraphEdgeList :: " << std::flush;
5553 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
5554 0 : std::cout << " not valid " << std::endl;
5555 : }
5556 : }
5557 :
5558 :
5559 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5560 :
5561 0 : }
5562 :
5563 :
5564 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
5565 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
5566 : bool
5567 0 : SgGraphEdgeList::isInMemoryPool ()
5568 : {
5569 0 : typedef unsigned char* TestType;
5570 :
5571 0 : bool found = false;
5572 :
5573 0 : ROSE_ASSERT(this != NULL);
5574 :
5575 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
5576 :
5577 0 : TestType tested = (TestType) ( this ) ;
5578 :
5579 0 : std::vector < unsigned char* > :: const_iterator block = SgGraphEdgeList::pools.begin();
5580 :
5581 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
5582 : // while (found == false && block < Memory_Block_List.end())
5583 0 : while ( (found == false) && (block != SgGraphEdgeList::pools.end()) )
5584 : {
5585 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgGraphEdgeList::pool_size * sizeof(SgGraphEdgeList) ) ) ;
5586 0 : ++block;
5587 : }
5588 :
5589 : // Special handling for static data
5590 :
5591 :
5592 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
5593 0 : ROSE_ASSERT(found == true);
5594 :
5595 0 : return found;
5596 : }
5597 : /* #line 5598 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5598 :
5599 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
5600 :
5601 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5602 :
5603 : /* #line 5604 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5604 :
5605 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5606 :
5607 : void
5608 0 : SgTypeTable::checkDataMemberPointersIfInMemoryPool()
5609 : {
5610 : // ------------ checking pointers of SgTypeTable -------------------
5611 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
5612 :
5613 0 : if ( p_type_table != NULL )
5614 : {
5615 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5616 : {
5617 0 : if ( p_type_table->isInMemoryPool() == false )
5618 : {
5619 0 : std::cout << "SgTypeTable :: ";
5620 0 : std::cout << " p_type_table is not in memory pool of ";
5621 0 : std::cout << p_type_table->class_name() << std::endl;
5622 : }
5623 : }
5624 : else
5625 : {
5626 0 : std::cout << "SgTypeTable :: " << std::flush;
5627 0 : std::cout << "SgSymbolTable* p_type_table = " << p_type_table << " --> " << std::flush;
5628 0 : std::cout << " not valid " << std::endl;
5629 : }
5630 : }
5631 :
5632 0 : if ( p_parent != NULL )
5633 : {
5634 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5635 : {
5636 0 : if ( p_parent->isInMemoryPool() == false )
5637 : {
5638 0 : std::cout << "SgTypeTable :: ";
5639 0 : std::cout << " p_parent is not in memory pool of ";
5640 0 : std::cout << p_parent->class_name() << std::endl;
5641 : }
5642 : }
5643 : else
5644 : {
5645 0 : std::cout << "SgTypeTable :: " << std::flush;
5646 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
5647 0 : std::cout << " not valid " << std::endl;
5648 : }
5649 : }
5650 :
5651 :
5652 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5653 :
5654 0 : }
5655 :
5656 :
5657 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
5658 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
5659 : bool
5660 0 : SgTypeTable::isInMemoryPool ()
5661 : {
5662 0 : typedef unsigned char* TestType;
5663 :
5664 0 : bool found = false;
5665 :
5666 0 : ROSE_ASSERT(this != NULL);
5667 :
5668 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
5669 :
5670 0 : TestType tested = (TestType) ( this ) ;
5671 :
5672 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeTable::pools.begin();
5673 :
5674 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
5675 : // while (found == false && block < Memory_Block_List.end())
5676 0 : while ( (found == false) && (block != SgTypeTable::pools.end()) )
5677 : {
5678 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeTable::pool_size * sizeof(SgTypeTable) ) ) ;
5679 0 : ++block;
5680 : }
5681 :
5682 : // Special handling for static data
5683 :
5684 :
5685 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
5686 0 : ROSE_ASSERT(found == true);
5687 :
5688 0 : return found;
5689 : }
5690 : /* #line 5691 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5691 :
5692 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
5693 :
5694 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5695 :
5696 : /* #line 5697 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5697 :
5698 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5699 :
5700 : void
5701 0 : SgNameGroup::checkDataMemberPointersIfInMemoryPool()
5702 : {
5703 : // ------------ checking pointers of SgNameGroup -------------------
5704 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
5705 :
5706 0 : if ( p_parent != NULL )
5707 : {
5708 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5709 : {
5710 0 : if ( p_parent->isInMemoryPool() == false )
5711 : {
5712 0 : std::cout << "SgNameGroup :: ";
5713 0 : std::cout << " p_parent is not in memory pool of ";
5714 0 : std::cout << p_parent->class_name() << std::endl;
5715 : }
5716 : }
5717 : else
5718 : {
5719 0 : std::cout << "SgNameGroup :: " << std::flush;
5720 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
5721 0 : std::cout << " not valid " << std::endl;
5722 : }
5723 : }
5724 :
5725 :
5726 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5727 :
5728 0 : }
5729 :
5730 :
5731 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
5732 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
5733 : bool
5734 0 : SgNameGroup::isInMemoryPool ()
5735 : {
5736 0 : typedef unsigned char* TestType;
5737 :
5738 0 : bool found = false;
5739 :
5740 0 : ROSE_ASSERT(this != NULL);
5741 :
5742 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
5743 :
5744 0 : TestType tested = (TestType) ( this ) ;
5745 :
5746 0 : std::vector < unsigned char* > :: const_iterator block = SgNameGroup::pools.begin();
5747 :
5748 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
5749 : // while (found == false && block < Memory_Block_List.end())
5750 0 : while ( (found == false) && (block != SgNameGroup::pools.end()) )
5751 : {
5752 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNameGroup::pool_size * sizeof(SgNameGroup) ) ) ;
5753 0 : ++block;
5754 : }
5755 :
5756 : // Special handling for static data
5757 :
5758 :
5759 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
5760 0 : ROSE_ASSERT(found == true);
5761 :
5762 0 : return found;
5763 : }
5764 : /* #line 5765 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5765 :
5766 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
5767 :
5768 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5769 :
5770 : /* #line 5771 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5771 :
5772 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5773 :
5774 : void
5775 0 : SgDimensionObject::checkDataMemberPointersIfInMemoryPool()
5776 : {
5777 : // ------------ checking pointers of SgDimensionObject -------------------
5778 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
5779 :
5780 0 : if ( p_array != NULL )
5781 : {
5782 0 : if ( p_array->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5783 : {
5784 0 : if ( p_array->isInMemoryPool() == false )
5785 : {
5786 0 : std::cout << "SgDimensionObject :: ";
5787 0 : std::cout << " p_array is not in memory pool of ";
5788 0 : std::cout << p_array->class_name() << std::endl;
5789 : }
5790 : }
5791 : else
5792 : {
5793 0 : std::cout << "SgDimensionObject :: " << std::flush;
5794 0 : std::cout << "SgInitializedName* p_array = " << p_array << " --> " << std::flush;
5795 0 : std::cout << " not valid " << std::endl;
5796 : }
5797 : }
5798 :
5799 0 : if ( p_shape != NULL )
5800 : {
5801 0 : if ( p_shape->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5802 : {
5803 0 : if ( p_shape->isInMemoryPool() == false )
5804 : {
5805 0 : std::cout << "SgDimensionObject :: ";
5806 0 : std::cout << " p_shape is not in memory pool of ";
5807 0 : std::cout << p_shape->class_name() << std::endl;
5808 : }
5809 : }
5810 : else
5811 : {
5812 0 : std::cout << "SgDimensionObject :: " << std::flush;
5813 0 : std::cout << "SgExprListExp* p_shape = " << p_shape << " --> " << std::flush;
5814 0 : std::cout << " not valid " << std::endl;
5815 : }
5816 : }
5817 :
5818 0 : if ( p_parent != NULL )
5819 : {
5820 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5821 : {
5822 0 : if ( p_parent->isInMemoryPool() == false )
5823 : {
5824 0 : std::cout << "SgDimensionObject :: ";
5825 0 : std::cout << " p_parent is not in memory pool of ";
5826 0 : std::cout << p_parent->class_name() << std::endl;
5827 : }
5828 : }
5829 : else
5830 : {
5831 0 : std::cout << "SgDimensionObject :: " << std::flush;
5832 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
5833 0 : std::cout << " not valid " << std::endl;
5834 : }
5835 : }
5836 :
5837 :
5838 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5839 :
5840 0 : }
5841 :
5842 :
5843 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
5844 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
5845 : bool
5846 0 : SgDimensionObject::isInMemoryPool ()
5847 : {
5848 0 : typedef unsigned char* TestType;
5849 :
5850 0 : bool found = false;
5851 :
5852 0 : ROSE_ASSERT(this != NULL);
5853 :
5854 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
5855 :
5856 0 : TestType tested = (TestType) ( this ) ;
5857 :
5858 0 : std::vector < unsigned char* > :: const_iterator block = SgDimensionObject::pools.begin();
5859 :
5860 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
5861 : // while (found == false && block < Memory_Block_List.end())
5862 0 : while ( (found == false) && (block != SgDimensionObject::pools.end()) )
5863 : {
5864 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDimensionObject::pool_size * sizeof(SgDimensionObject) ) ) ;
5865 0 : ++block;
5866 : }
5867 :
5868 : // Special handling for static data
5869 :
5870 :
5871 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
5872 0 : ROSE_ASSERT(found == true);
5873 :
5874 0 : return found;
5875 : }
5876 : /* #line 5877 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5877 :
5878 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
5879 :
5880 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5881 :
5882 : /* #line 5883 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5883 :
5884 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5885 :
5886 : void
5887 0 : SgFormatItem::checkDataMemberPointersIfInMemoryPool()
5888 : {
5889 : // ------------ checking pointers of SgFormatItem -------------------
5890 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
5891 :
5892 0 : if ( p_data != NULL )
5893 : {
5894 0 : if ( p_data->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5895 : {
5896 0 : if ( p_data->isInMemoryPool() == false )
5897 : {
5898 0 : std::cout << "SgFormatItem :: ";
5899 0 : std::cout << " p_data is not in memory pool of ";
5900 0 : std::cout << p_data->class_name() << std::endl;
5901 : }
5902 : }
5903 : else
5904 : {
5905 0 : std::cout << "SgFormatItem :: " << std::flush;
5906 0 : std::cout << "SgExpression* p_data = " << p_data << " --> " << std::flush;
5907 0 : std::cout << " not valid " << std::endl;
5908 : }
5909 : }
5910 :
5911 0 : if ( p_format_item_list != NULL )
5912 : {
5913 0 : if ( p_format_item_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5914 : {
5915 0 : if ( p_format_item_list->isInMemoryPool() == false )
5916 : {
5917 0 : std::cout << "SgFormatItem :: ";
5918 0 : std::cout << " p_format_item_list is not in memory pool of ";
5919 0 : std::cout << p_format_item_list->class_name() << std::endl;
5920 : }
5921 : }
5922 : else
5923 : {
5924 0 : std::cout << "SgFormatItem :: " << std::flush;
5925 0 : std::cout << "SgFormatItemList* p_format_item_list = " << p_format_item_list << " --> " << std::flush;
5926 0 : std::cout << " not valid " << std::endl;
5927 : }
5928 : }
5929 :
5930 0 : if ( p_parent != NULL )
5931 : {
5932 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
5933 : {
5934 0 : if ( p_parent->isInMemoryPool() == false )
5935 : {
5936 0 : std::cout << "SgFormatItem :: ";
5937 0 : std::cout << " p_parent is not in memory pool of ";
5938 0 : std::cout << p_parent->class_name() << std::endl;
5939 : }
5940 : }
5941 : else
5942 : {
5943 0 : std::cout << "SgFormatItem :: " << std::flush;
5944 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
5945 0 : std::cout << " not valid " << std::endl;
5946 : }
5947 : }
5948 :
5949 :
5950 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5951 :
5952 0 : }
5953 :
5954 :
5955 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
5956 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
5957 : bool
5958 0 : SgFormatItem::isInMemoryPool ()
5959 : {
5960 0 : typedef unsigned char* TestType;
5961 :
5962 0 : bool found = false;
5963 :
5964 0 : ROSE_ASSERT(this != NULL);
5965 :
5966 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
5967 :
5968 0 : TestType tested = (TestType) ( this ) ;
5969 :
5970 0 : std::vector < unsigned char* > :: const_iterator block = SgFormatItem::pools.begin();
5971 :
5972 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
5973 : // while (found == false && block < Memory_Block_List.end())
5974 0 : while ( (found == false) && (block != SgFormatItem::pools.end()) )
5975 : {
5976 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFormatItem::pool_size * sizeof(SgFormatItem) ) ) ;
5977 0 : ++block;
5978 : }
5979 :
5980 : // Special handling for static data
5981 :
5982 :
5983 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
5984 0 : ROSE_ASSERT(found == true);
5985 :
5986 0 : return found;
5987 : }
5988 : /* #line 5989 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5989 :
5990 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
5991 :
5992 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5993 :
5994 : /* #line 5995 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
5995 :
5996 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
5997 :
5998 : void
5999 0 : SgFormatItemList::checkDataMemberPointersIfInMemoryPool()
6000 : {
6001 : // ------------ checking pointers of SgFormatItemList -------------------
6002 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
6003 :
6004 0 : SgFormatItemPtrList::iterator i_format_item_list = p_format_item_list.begin() ;
6005 0 : for ( ; i_format_item_list != p_format_item_list.end(); ++i_format_item_list )
6006 : {
6007 0 : if ( (*i_format_item_list) != NULL )
6008 : {
6009 0 : if ( (*i_format_item_list)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6010 : {
6011 0 : if ( (*i_format_item_list)->isInMemoryPool() == false )
6012 : {
6013 0 : std::cout << "SgFormatItemList :: ";
6014 0 : std::cout << " p_format_item_list ( list of poitners to IR nodes ), entry is not in memory pool of ";
6015 0 : std::cout << (*i_format_item_list)->class_name() << std::endl;
6016 : }
6017 : }
6018 : else
6019 : {
6020 0 : std::cout << "SgFormatItemList :: " << std::flush;
6021 0 : std::cout << "SgFormatItemPtrList p_format_item_list --> " << std::flush;
6022 0 : std::cout << " entry not valid " << std::endl;
6023 : }
6024 : }
6025 : else
6026 : {
6027 0 : std::cout << "SgFormatItemPtrList p_format_item_list --> NULL " << std::endl;
6028 : }
6029 : }
6030 :
6031 0 : if ( p_parent != NULL )
6032 : {
6033 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6034 : {
6035 0 : if ( p_parent->isInMemoryPool() == false )
6036 : {
6037 0 : std::cout << "SgFormatItemList :: ";
6038 0 : std::cout << " p_parent is not in memory pool of ";
6039 0 : std::cout << p_parent->class_name() << std::endl;
6040 : }
6041 : }
6042 : else
6043 : {
6044 0 : std::cout << "SgFormatItemList :: " << std::flush;
6045 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
6046 0 : std::cout << " not valid " << std::endl;
6047 : }
6048 : }
6049 :
6050 :
6051 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6052 :
6053 0 : }
6054 :
6055 :
6056 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
6057 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
6058 : bool
6059 0 : SgFormatItemList::isInMemoryPool ()
6060 : {
6061 0 : typedef unsigned char* TestType;
6062 :
6063 0 : bool found = false;
6064 :
6065 0 : ROSE_ASSERT(this != NULL);
6066 :
6067 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
6068 :
6069 0 : TestType tested = (TestType) ( this ) ;
6070 :
6071 0 : std::vector < unsigned char* > :: const_iterator block = SgFormatItemList::pools.begin();
6072 :
6073 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
6074 : // while (found == false && block < Memory_Block_List.end())
6075 0 : while ( (found == false) && (block != SgFormatItemList::pools.end()) )
6076 : {
6077 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFormatItemList::pool_size * sizeof(SgFormatItemList) ) ) ;
6078 0 : ++block;
6079 : }
6080 :
6081 : // Special handling for static data
6082 :
6083 :
6084 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
6085 0 : ROSE_ASSERT(found == true);
6086 :
6087 0 : return found;
6088 : }
6089 : /* #line 6090 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
6090 :
6091 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
6092 :
6093 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6094 :
6095 : /* #line 6096 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
6096 :
6097 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6098 :
6099 : void
6100 0 : SgDataStatementGroup::checkDataMemberPointersIfInMemoryPool()
6101 : {
6102 : // ------------ checking pointers of SgDataStatementGroup -------------------
6103 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
6104 :
6105 0 : SgDataStatementObjectPtrList::iterator i_object_list = p_object_list.begin() ;
6106 0 : for ( ; i_object_list != p_object_list.end(); ++i_object_list )
6107 : {
6108 0 : if ( (*i_object_list) != NULL )
6109 : {
6110 0 : if ( (*i_object_list)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6111 : {
6112 0 : if ( (*i_object_list)->isInMemoryPool() == false )
6113 : {
6114 0 : std::cout << "SgDataStatementGroup :: ";
6115 0 : std::cout << " p_object_list ( list of poitners to IR nodes ), entry is not in memory pool of ";
6116 0 : std::cout << (*i_object_list)->class_name() << std::endl;
6117 : }
6118 : }
6119 : else
6120 : {
6121 0 : std::cout << "SgDataStatementGroup :: " << std::flush;
6122 0 : std::cout << "SgDataStatementObjectPtrList p_object_list --> " << std::flush;
6123 0 : std::cout << " entry not valid " << std::endl;
6124 : }
6125 : }
6126 : else
6127 : {
6128 0 : std::cout << "SgDataStatementObjectPtrList p_object_list --> NULL " << std::endl;
6129 : }
6130 : }
6131 :
6132 0 : SgDataStatementValuePtrList::iterator i_value_list = p_value_list.begin() ;
6133 0 : for ( ; i_value_list != p_value_list.end(); ++i_value_list )
6134 : {
6135 0 : if ( (*i_value_list) != NULL )
6136 : {
6137 0 : if ( (*i_value_list)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6138 : {
6139 0 : if ( (*i_value_list)->isInMemoryPool() == false )
6140 : {
6141 0 : std::cout << "SgDataStatementGroup :: ";
6142 0 : std::cout << " p_value_list ( list of poitners to IR nodes ), entry is not in memory pool of ";
6143 0 : std::cout << (*i_value_list)->class_name() << std::endl;
6144 : }
6145 : }
6146 : else
6147 : {
6148 0 : std::cout << "SgDataStatementGroup :: " << std::flush;
6149 0 : std::cout << "SgDataStatementValuePtrList p_value_list --> " << std::flush;
6150 0 : std::cout << " entry not valid " << std::endl;
6151 : }
6152 : }
6153 : else
6154 : {
6155 0 : std::cout << "SgDataStatementValuePtrList p_value_list --> NULL " << std::endl;
6156 : }
6157 : }
6158 :
6159 0 : if ( p_parent != NULL )
6160 : {
6161 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6162 : {
6163 0 : if ( p_parent->isInMemoryPool() == false )
6164 : {
6165 0 : std::cout << "SgDataStatementGroup :: ";
6166 0 : std::cout << " p_parent is not in memory pool of ";
6167 0 : std::cout << p_parent->class_name() << std::endl;
6168 : }
6169 : }
6170 : else
6171 : {
6172 0 : std::cout << "SgDataStatementGroup :: " << std::flush;
6173 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
6174 0 : std::cout << " not valid " << std::endl;
6175 : }
6176 : }
6177 :
6178 :
6179 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6180 :
6181 0 : }
6182 :
6183 :
6184 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
6185 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
6186 : bool
6187 0 : SgDataStatementGroup::isInMemoryPool ()
6188 : {
6189 0 : typedef unsigned char* TestType;
6190 :
6191 0 : bool found = false;
6192 :
6193 0 : ROSE_ASSERT(this != NULL);
6194 :
6195 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
6196 :
6197 0 : TestType tested = (TestType) ( this ) ;
6198 :
6199 0 : std::vector < unsigned char* > :: const_iterator block = SgDataStatementGroup::pools.begin();
6200 :
6201 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
6202 : // while (found == false && block < Memory_Block_List.end())
6203 0 : while ( (found == false) && (block != SgDataStatementGroup::pools.end()) )
6204 : {
6205 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDataStatementGroup::pool_size * sizeof(SgDataStatementGroup) ) ) ;
6206 0 : ++block;
6207 : }
6208 :
6209 : // Special handling for static data
6210 :
6211 :
6212 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
6213 0 : ROSE_ASSERT(found == true);
6214 :
6215 0 : return found;
6216 : }
6217 : /* #line 6218 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
6218 :
6219 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
6220 :
6221 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6222 :
6223 : /* #line 6224 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
6224 :
6225 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6226 :
6227 : void
6228 0 : SgDataStatementObject::checkDataMemberPointersIfInMemoryPool()
6229 : {
6230 : // ------------ checking pointers of SgDataStatementObject -------------------
6231 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
6232 :
6233 0 : if ( p_variableReference_list != NULL )
6234 : {
6235 0 : if ( p_variableReference_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6236 : {
6237 0 : if ( p_variableReference_list->isInMemoryPool() == false )
6238 : {
6239 0 : std::cout << "SgDataStatementObject :: ";
6240 0 : std::cout << " p_variableReference_list is not in memory pool of ";
6241 0 : std::cout << p_variableReference_list->class_name() << std::endl;
6242 : }
6243 : }
6244 : else
6245 : {
6246 0 : std::cout << "SgDataStatementObject :: " << std::flush;
6247 0 : std::cout << "SgExprListExp* p_variableReference_list = " << p_variableReference_list << " --> " << std::flush;
6248 0 : std::cout << " not valid " << std::endl;
6249 : }
6250 : }
6251 :
6252 0 : if ( p_parent != NULL )
6253 : {
6254 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6255 : {
6256 0 : if ( p_parent->isInMemoryPool() == false )
6257 : {
6258 0 : std::cout << "SgDataStatementObject :: ";
6259 0 : std::cout << " p_parent is not in memory pool of ";
6260 0 : std::cout << p_parent->class_name() << std::endl;
6261 : }
6262 : }
6263 : else
6264 : {
6265 0 : std::cout << "SgDataStatementObject :: " << std::flush;
6266 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
6267 0 : std::cout << " not valid " << std::endl;
6268 : }
6269 : }
6270 :
6271 :
6272 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6273 :
6274 0 : }
6275 :
6276 :
6277 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
6278 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
6279 : bool
6280 0 : SgDataStatementObject::isInMemoryPool ()
6281 : {
6282 0 : typedef unsigned char* TestType;
6283 :
6284 0 : bool found = false;
6285 :
6286 0 : ROSE_ASSERT(this != NULL);
6287 :
6288 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
6289 :
6290 0 : TestType tested = (TestType) ( this ) ;
6291 :
6292 0 : std::vector < unsigned char* > :: const_iterator block = SgDataStatementObject::pools.begin();
6293 :
6294 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
6295 : // while (found == false && block < Memory_Block_List.end())
6296 0 : while ( (found == false) && (block != SgDataStatementObject::pools.end()) )
6297 : {
6298 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDataStatementObject::pool_size * sizeof(SgDataStatementObject) ) ) ;
6299 0 : ++block;
6300 : }
6301 :
6302 : // Special handling for static data
6303 :
6304 :
6305 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
6306 0 : ROSE_ASSERT(found == true);
6307 :
6308 0 : return found;
6309 : }
6310 : /* #line 6311 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
6311 :
6312 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
6313 :
6314 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6315 :
6316 : /* #line 6317 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
6317 :
6318 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6319 :
6320 : void
6321 0 : SgIncludeFile::checkDataMemberPointersIfInMemoryPool()
6322 : {
6323 : // ------------ checking pointers of SgIncludeFile -------------------
6324 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
6325 :
6326 0 : if ( p_source_file != NULL )
6327 : {
6328 0 : if ( p_source_file->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6329 : {
6330 0 : if ( p_source_file->isInMemoryPool() == false )
6331 : {
6332 0 : std::cout << "SgIncludeFile :: ";
6333 0 : std::cout << " p_source_file is not in memory pool of ";
6334 0 : std::cout << p_source_file->class_name() << std::endl;
6335 : }
6336 : }
6337 : else
6338 : {
6339 0 : std::cout << "SgIncludeFile :: " << std::flush;
6340 0 : std::cout << "SgSourceFile* p_source_file = " << p_source_file << " --> " << std::flush;
6341 0 : std::cout << " not valid " << std::endl;
6342 : }
6343 : }
6344 :
6345 0 : SgIncludeFilePtrList::iterator i_include_file_list = p_include_file_list.begin() ;
6346 0 : for ( ; i_include_file_list != p_include_file_list.end(); ++i_include_file_list )
6347 : {
6348 0 : if ( (*i_include_file_list) != NULL )
6349 : {
6350 0 : if ( (*i_include_file_list)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6351 : {
6352 0 : if ( (*i_include_file_list)->isInMemoryPool() == false )
6353 : {
6354 0 : std::cout << "SgIncludeFile :: ";
6355 0 : std::cout << " p_include_file_list ( list of poitners to IR nodes ), entry is not in memory pool of ";
6356 0 : std::cout << (*i_include_file_list)->class_name() << std::endl;
6357 : }
6358 : }
6359 : else
6360 : {
6361 0 : std::cout << "SgIncludeFile :: " << std::flush;
6362 0 : std::cout << "SgIncludeFilePtrList p_include_file_list --> " << std::flush;
6363 0 : std::cout << " entry not valid " << std::endl;
6364 : }
6365 : }
6366 : else
6367 : {
6368 0 : std::cout << "SgIncludeFilePtrList p_include_file_list --> NULL " << std::endl;
6369 : }
6370 : }
6371 :
6372 0 : if ( p_source_file_of_translation_unit != NULL )
6373 : {
6374 0 : if ( p_source_file_of_translation_unit->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6375 : {
6376 0 : if ( p_source_file_of_translation_unit->isInMemoryPool() == false )
6377 : {
6378 0 : std::cout << "SgIncludeFile :: ";
6379 0 : std::cout << " p_source_file_of_translation_unit is not in memory pool of ";
6380 0 : std::cout << p_source_file_of_translation_unit->class_name() << std::endl;
6381 : }
6382 : }
6383 : else
6384 : {
6385 0 : std::cout << "SgIncludeFile :: " << std::flush;
6386 0 : std::cout << "SgSourceFile* p_source_file_of_translation_unit = " << p_source_file_of_translation_unit << " --> " << std::flush;
6387 0 : std::cout << " not valid " << std::endl;
6388 : }
6389 : }
6390 :
6391 0 : if ( p_including_source_file != NULL )
6392 : {
6393 0 : if ( p_including_source_file->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6394 : {
6395 0 : if ( p_including_source_file->isInMemoryPool() == false )
6396 : {
6397 0 : std::cout << "SgIncludeFile :: ";
6398 0 : std::cout << " p_including_source_file is not in memory pool of ";
6399 0 : std::cout << p_including_source_file->class_name() << std::endl;
6400 : }
6401 : }
6402 : else
6403 : {
6404 0 : std::cout << "SgIncludeFile :: " << std::flush;
6405 0 : std::cout << "SgSourceFile* p_including_source_file = " << p_including_source_file << " --> " << std::flush;
6406 0 : std::cout << " not valid " << std::endl;
6407 : }
6408 : }
6409 :
6410 0 : if ( p_parent_include_file != NULL )
6411 : {
6412 0 : if ( p_parent_include_file->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6413 : {
6414 0 : if ( p_parent_include_file->isInMemoryPool() == false )
6415 : {
6416 0 : std::cout << "SgIncludeFile :: ";
6417 0 : std::cout << " p_parent_include_file is not in memory pool of ";
6418 0 : std::cout << p_parent_include_file->class_name() << std::endl;
6419 : }
6420 : }
6421 : else
6422 : {
6423 0 : std::cout << "SgIncludeFile :: " << std::flush;
6424 0 : std::cout << "SgIncludeFile* p_parent_include_file = " << p_parent_include_file << " --> " << std::flush;
6425 0 : std::cout << " not valid " << std::endl;
6426 : }
6427 : }
6428 :
6429 0 : if ( p_firstStatement != NULL )
6430 : {
6431 0 : if ( p_firstStatement->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6432 : {
6433 0 : if ( p_firstStatement->isInMemoryPool() == false )
6434 : {
6435 0 : std::cout << "SgIncludeFile :: ";
6436 0 : std::cout << " p_firstStatement is not in memory pool of ";
6437 0 : std::cout << p_firstStatement->class_name() << std::endl;
6438 : }
6439 : }
6440 : else
6441 : {
6442 0 : std::cout << "SgIncludeFile :: " << std::flush;
6443 0 : std::cout << "SgStatement* p_firstStatement = " << p_firstStatement << " --> " << std::flush;
6444 0 : std::cout << " not valid " << std::endl;
6445 : }
6446 : }
6447 :
6448 0 : if ( p_lastStatement != NULL )
6449 : {
6450 0 : if ( p_lastStatement->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6451 : {
6452 0 : if ( p_lastStatement->isInMemoryPool() == false )
6453 : {
6454 0 : std::cout << "SgIncludeFile :: ";
6455 0 : std::cout << " p_lastStatement is not in memory pool of ";
6456 0 : std::cout << p_lastStatement->class_name() << std::endl;
6457 : }
6458 : }
6459 : else
6460 : {
6461 0 : std::cout << "SgIncludeFile :: " << std::flush;
6462 0 : std::cout << "SgStatement* p_lastStatement = " << p_lastStatement << " --> " << std::flush;
6463 0 : std::cout << " not valid " << std::endl;
6464 : }
6465 : }
6466 :
6467 0 : if ( p_parent != NULL )
6468 : {
6469 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6470 : {
6471 0 : if ( p_parent->isInMemoryPool() == false )
6472 : {
6473 0 : std::cout << "SgIncludeFile :: ";
6474 0 : std::cout << " p_parent is not in memory pool of ";
6475 0 : std::cout << p_parent->class_name() << std::endl;
6476 : }
6477 : }
6478 : else
6479 : {
6480 0 : std::cout << "SgIncludeFile :: " << std::flush;
6481 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
6482 0 : std::cout << " not valid " << std::endl;
6483 : }
6484 : }
6485 :
6486 :
6487 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6488 :
6489 0 : }
6490 :
6491 :
6492 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
6493 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
6494 : bool
6495 0 : SgIncludeFile::isInMemoryPool ()
6496 : {
6497 0 : typedef unsigned char* TestType;
6498 :
6499 0 : bool found = false;
6500 :
6501 0 : ROSE_ASSERT(this != NULL);
6502 :
6503 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
6504 :
6505 0 : TestType tested = (TestType) ( this ) ;
6506 :
6507 0 : std::vector < unsigned char* > :: const_iterator block = SgIncludeFile::pools.begin();
6508 :
6509 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
6510 : // while (found == false && block < Memory_Block_List.end())
6511 0 : while ( (found == false) && (block != SgIncludeFile::pools.end()) )
6512 : {
6513 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIncludeFile::pool_size * sizeof(SgIncludeFile) ) ) ;
6514 0 : ++block;
6515 : }
6516 :
6517 : // Special handling for static data
6518 :
6519 :
6520 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
6521 0 : ROSE_ASSERT(found == true);
6522 :
6523 0 : return found;
6524 : }
6525 : /* #line 6526 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
6526 :
6527 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
6528 :
6529 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6530 :
6531 : /* #line 6532 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
6532 :
6533 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6534 :
6535 : void
6536 0 : SgDataStatementValue::checkDataMemberPointersIfInMemoryPool()
6537 : {
6538 : // ------------ checking pointers of SgDataStatementValue -------------------
6539 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
6540 :
6541 0 : if ( p_initializer_list != NULL )
6542 : {
6543 0 : if ( p_initializer_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6544 : {
6545 0 : if ( p_initializer_list->isInMemoryPool() == false )
6546 : {
6547 0 : std::cout << "SgDataStatementValue :: ";
6548 0 : std::cout << " p_initializer_list is not in memory pool of ";
6549 0 : std::cout << p_initializer_list->class_name() << std::endl;
6550 : }
6551 : }
6552 : else
6553 : {
6554 0 : std::cout << "SgDataStatementValue :: " << std::flush;
6555 0 : std::cout << "SgExprListExp* p_initializer_list = " << p_initializer_list << " --> " << std::flush;
6556 0 : std::cout << " not valid " << std::endl;
6557 : }
6558 : }
6559 :
6560 0 : if ( p_repeat_expression != NULL )
6561 : {
6562 0 : if ( p_repeat_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6563 : {
6564 0 : if ( p_repeat_expression->isInMemoryPool() == false )
6565 : {
6566 0 : std::cout << "SgDataStatementValue :: ";
6567 0 : std::cout << " p_repeat_expression is not in memory pool of ";
6568 0 : std::cout << p_repeat_expression->class_name() << std::endl;
6569 : }
6570 : }
6571 : else
6572 : {
6573 0 : std::cout << "SgDataStatementValue :: " << std::flush;
6574 0 : std::cout << "SgExpression* p_repeat_expression = " << p_repeat_expression << " --> " << std::flush;
6575 0 : std::cout << " not valid " << std::endl;
6576 : }
6577 : }
6578 :
6579 0 : if ( p_constant_expression != NULL )
6580 : {
6581 0 : if ( p_constant_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6582 : {
6583 0 : if ( p_constant_expression->isInMemoryPool() == false )
6584 : {
6585 0 : std::cout << "SgDataStatementValue :: ";
6586 0 : std::cout << " p_constant_expression is not in memory pool of ";
6587 0 : std::cout << p_constant_expression->class_name() << std::endl;
6588 : }
6589 : }
6590 : else
6591 : {
6592 0 : std::cout << "SgDataStatementValue :: " << std::flush;
6593 0 : std::cout << "SgExpression* p_constant_expression = " << p_constant_expression << " --> " << std::flush;
6594 0 : std::cout << " not valid " << std::endl;
6595 : }
6596 : }
6597 :
6598 0 : if ( p_parent != NULL )
6599 : {
6600 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6601 : {
6602 0 : if ( p_parent->isInMemoryPool() == false )
6603 : {
6604 0 : std::cout << "SgDataStatementValue :: ";
6605 0 : std::cout << " p_parent is not in memory pool of ";
6606 0 : std::cout << p_parent->class_name() << std::endl;
6607 : }
6608 : }
6609 : else
6610 : {
6611 0 : std::cout << "SgDataStatementValue :: " << std::flush;
6612 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
6613 0 : std::cout << " not valid " << std::endl;
6614 : }
6615 : }
6616 :
6617 :
6618 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6619 :
6620 0 : }
6621 :
6622 :
6623 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
6624 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
6625 : bool
6626 0 : SgDataStatementValue::isInMemoryPool ()
6627 : {
6628 0 : typedef unsigned char* TestType;
6629 :
6630 0 : bool found = false;
6631 :
6632 0 : ROSE_ASSERT(this != NULL);
6633 :
6634 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
6635 :
6636 0 : TestType tested = (TestType) ( this ) ;
6637 :
6638 0 : std::vector < unsigned char* > :: const_iterator block = SgDataStatementValue::pools.begin();
6639 :
6640 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
6641 : // while (found == false && block < Memory_Block_List.end())
6642 0 : while ( (found == false) && (block != SgDataStatementValue::pools.end()) )
6643 : {
6644 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDataStatementValue::pool_size * sizeof(SgDataStatementValue) ) ) ;
6645 0 : ++block;
6646 : }
6647 :
6648 : // Special handling for static data
6649 :
6650 :
6651 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
6652 0 : ROSE_ASSERT(found == true);
6653 :
6654 0 : return found;
6655 : }
6656 : /* #line 6657 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
6657 :
6658 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
6659 :
6660 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6661 :
6662 : /* #line 6663 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
6663 :
6664 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6665 :
6666 : void
6667 0 : SgHeaderFileReport::checkDataMemberPointersIfInMemoryPool()
6668 : {
6669 : // ------------ checking pointers of SgHeaderFileReport -------------------
6670 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
6671 :
6672 0 : if ( p_source_file != NULL )
6673 : {
6674 0 : if ( p_source_file->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6675 : {
6676 0 : if ( p_source_file->isInMemoryPool() == false )
6677 : {
6678 0 : std::cout << "SgHeaderFileReport :: ";
6679 0 : std::cout << " p_source_file is not in memory pool of ";
6680 0 : std::cout << p_source_file->class_name() << std::endl;
6681 : }
6682 : }
6683 : else
6684 : {
6685 0 : std::cout << "SgHeaderFileReport :: " << std::flush;
6686 0 : std::cout << "SgSourceFile* p_source_file = " << p_source_file << " --> " << std::flush;
6687 0 : std::cout << " not valid " << std::endl;
6688 : }
6689 : }
6690 :
6691 0 : SgSourceFilePtrList::iterator i_include_file_list = p_include_file_list.begin() ;
6692 0 : for ( ; i_include_file_list != p_include_file_list.end(); ++i_include_file_list )
6693 : {
6694 0 : if ( (*i_include_file_list) != NULL )
6695 : {
6696 0 : if ( (*i_include_file_list)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6697 : {
6698 0 : if ( (*i_include_file_list)->isInMemoryPool() == false )
6699 : {
6700 0 : std::cout << "SgHeaderFileReport :: ";
6701 0 : std::cout << " p_include_file_list ( list of poitners to IR nodes ), entry is not in memory pool of ";
6702 0 : std::cout << (*i_include_file_list)->class_name() << std::endl;
6703 : }
6704 : }
6705 : else
6706 : {
6707 0 : std::cout << "SgHeaderFileReport :: " << std::flush;
6708 0 : std::cout << "SgSourceFilePtrList p_include_file_list --> " << std::flush;
6709 0 : std::cout << " entry not valid " << std::endl;
6710 : }
6711 : }
6712 : else
6713 : {
6714 0 : std::cout << "SgSourceFilePtrList p_include_file_list --> NULL " << std::endl;
6715 : }
6716 : }
6717 :
6718 0 : if ( p_parent != NULL )
6719 : {
6720 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6721 : {
6722 0 : if ( p_parent->isInMemoryPool() == false )
6723 : {
6724 0 : std::cout << "SgHeaderFileReport :: ";
6725 0 : std::cout << " p_parent is not in memory pool of ";
6726 0 : std::cout << p_parent->class_name() << std::endl;
6727 : }
6728 : }
6729 : else
6730 : {
6731 0 : std::cout << "SgHeaderFileReport :: " << std::flush;
6732 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
6733 0 : std::cout << " not valid " << std::endl;
6734 : }
6735 : }
6736 :
6737 :
6738 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6739 :
6740 0 : }
6741 :
6742 :
6743 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
6744 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
6745 : bool
6746 0 : SgHeaderFileReport::isInMemoryPool ()
6747 : {
6748 0 : typedef unsigned char* TestType;
6749 :
6750 0 : bool found = false;
6751 :
6752 0 : ROSE_ASSERT(this != NULL);
6753 :
6754 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
6755 :
6756 0 : TestType tested = (TestType) ( this ) ;
6757 :
6758 0 : std::vector < unsigned char* > :: const_iterator block = SgHeaderFileReport::pools.begin();
6759 :
6760 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
6761 : // while (found == false && block < Memory_Block_List.end())
6762 0 : while ( (found == false) && (block != SgHeaderFileReport::pools.end()) )
6763 : {
6764 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgHeaderFileReport::pool_size * sizeof(SgHeaderFileReport) ) ) ;
6765 0 : ++block;
6766 : }
6767 :
6768 : // Special handling for static data
6769 :
6770 :
6771 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
6772 0 : ROSE_ASSERT(found == true);
6773 :
6774 0 : return found;
6775 : }
6776 : /* #line 6777 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
6777 :
6778 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
6779 :
6780 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6781 :
6782 : /* #line 6783 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
6783 :
6784 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6785 :
6786 : void
6787 0 : SgType::checkDataMemberPointersIfInMemoryPool()
6788 : {
6789 : // ------------ checking pointers of SgType -------------------
6790 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
6791 :
6792 0 : if ( p_ref_to != NULL )
6793 : {
6794 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6795 : {
6796 0 : if ( p_ref_to->isInMemoryPool() == false )
6797 : {
6798 0 : std::cout << "SgType :: ";
6799 0 : std::cout << " p_ref_to is not in memory pool of ";
6800 0 : std::cout << p_ref_to->class_name() << std::endl;
6801 : }
6802 : }
6803 : else
6804 : {
6805 0 : std::cout << "SgType :: " << std::flush;
6806 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
6807 0 : std::cout << " not valid " << std::endl;
6808 : }
6809 : }
6810 :
6811 0 : if ( p_ptr_to != NULL )
6812 : {
6813 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6814 : {
6815 0 : if ( p_ptr_to->isInMemoryPool() == false )
6816 : {
6817 0 : std::cout << "SgType :: ";
6818 0 : std::cout << " p_ptr_to is not in memory pool of ";
6819 0 : std::cout << p_ptr_to->class_name() << std::endl;
6820 : }
6821 : }
6822 : else
6823 : {
6824 0 : std::cout << "SgType :: " << std::flush;
6825 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
6826 0 : std::cout << " not valid " << std::endl;
6827 : }
6828 : }
6829 :
6830 0 : if ( p_modifiers != NULL )
6831 : {
6832 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6833 : {
6834 0 : if ( p_modifiers->isInMemoryPool() == false )
6835 : {
6836 0 : std::cout << "SgType :: ";
6837 0 : std::cout << " p_modifiers is not in memory pool of ";
6838 0 : std::cout << p_modifiers->class_name() << std::endl;
6839 : }
6840 : }
6841 : else
6842 : {
6843 0 : std::cout << "SgType :: " << std::flush;
6844 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
6845 0 : std::cout << " not valid " << std::endl;
6846 : }
6847 : }
6848 :
6849 0 : if ( p_typedefs != NULL )
6850 : {
6851 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6852 : {
6853 0 : if ( p_typedefs->isInMemoryPool() == false )
6854 : {
6855 0 : std::cout << "SgType :: ";
6856 0 : std::cout << " p_typedefs is not in memory pool of ";
6857 0 : std::cout << p_typedefs->class_name() << std::endl;
6858 : }
6859 : }
6860 : else
6861 : {
6862 0 : std::cout << "SgType :: " << std::flush;
6863 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
6864 0 : std::cout << " not valid " << std::endl;
6865 : }
6866 : }
6867 :
6868 0 : if ( p_rvalue_ref_to != NULL )
6869 : {
6870 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6871 : {
6872 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
6873 : {
6874 0 : std::cout << "SgType :: ";
6875 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
6876 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
6877 : }
6878 : }
6879 : else
6880 : {
6881 0 : std::cout << "SgType :: " << std::flush;
6882 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
6883 0 : std::cout << " not valid " << std::endl;
6884 : }
6885 : }
6886 :
6887 0 : if ( p_decltype_ref_to != NULL )
6888 : {
6889 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6890 : {
6891 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
6892 : {
6893 0 : std::cout << "SgType :: ";
6894 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
6895 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
6896 : }
6897 : }
6898 : else
6899 : {
6900 0 : std::cout << "SgType :: " << std::flush;
6901 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
6902 0 : std::cout << " not valid " << std::endl;
6903 : }
6904 : }
6905 :
6906 0 : if ( p_typeof_ref_to != NULL )
6907 : {
6908 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6909 : {
6910 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
6911 : {
6912 0 : std::cout << "SgType :: ";
6913 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
6914 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
6915 : }
6916 : }
6917 : else
6918 : {
6919 0 : std::cout << "SgType :: " << std::flush;
6920 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
6921 0 : std::cout << " not valid " << std::endl;
6922 : }
6923 : }
6924 :
6925 0 : if ( p_type_kind != NULL )
6926 : {
6927 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6928 : {
6929 0 : if ( p_type_kind->isInMemoryPool() == false )
6930 : {
6931 0 : std::cout << "SgType :: ";
6932 0 : std::cout << " p_type_kind is not in memory pool of ";
6933 0 : std::cout << p_type_kind->class_name() << std::endl;
6934 : }
6935 : }
6936 : else
6937 : {
6938 0 : std::cout << "SgType :: " << std::flush;
6939 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
6940 0 : std::cout << " not valid " << std::endl;
6941 : }
6942 : }
6943 :
6944 0 : if ( p_parent != NULL )
6945 : {
6946 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
6947 : {
6948 0 : if ( p_parent->isInMemoryPool() == false )
6949 : {
6950 0 : std::cout << "SgType :: ";
6951 0 : std::cout << " p_parent is not in memory pool of ";
6952 0 : std::cout << p_parent->class_name() << std::endl;
6953 : }
6954 : }
6955 : else
6956 : {
6957 0 : std::cout << "SgType :: " << std::flush;
6958 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
6959 0 : std::cout << " not valid " << std::endl;
6960 : }
6961 : }
6962 :
6963 :
6964 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
6965 :
6966 0 : }
6967 :
6968 :
6969 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
6970 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
6971 : bool
6972 0 : SgType::isInMemoryPool ()
6973 : {
6974 0 : typedef unsigned char* TestType;
6975 :
6976 0 : bool found = false;
6977 :
6978 0 : ROSE_ASSERT(this != NULL);
6979 :
6980 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
6981 :
6982 0 : TestType tested = (TestType) ( this ) ;
6983 :
6984 0 : std::vector < unsigned char* > :: const_iterator block = SgType::pools.begin();
6985 :
6986 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
6987 : // while (found == false && block < Memory_Block_List.end())
6988 0 : while ( (found == false) && (block != SgType::pools.end()) )
6989 : {
6990 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgType::pool_size * sizeof(SgType) ) ) ;
6991 0 : ++block;
6992 : }
6993 :
6994 : // Special handling for static data
6995 :
6996 :
6997 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
6998 0 : ROSE_ASSERT(found == true);
6999 :
7000 0 : return found;
7001 : }
7002 : /* #line 7003 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
7003 :
7004 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
7005 :
7006 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
7007 :
7008 : /* #line 7009 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
7009 :
7010 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
7011 :
7012 : void
7013 0 : SgTypeUnknown::checkDataMemberPointersIfInMemoryPool()
7014 : {
7015 : // ------------ checking pointers of SgTypeUnknown -------------------
7016 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
7017 :
7018 0 : if ( p_ref_to != NULL )
7019 : {
7020 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7021 : {
7022 0 : if ( p_ref_to->isInMemoryPool() == false )
7023 : {
7024 0 : std::cout << "SgTypeUnknown :: ";
7025 0 : std::cout << " p_ref_to is not in memory pool of ";
7026 0 : std::cout << p_ref_to->class_name() << std::endl;
7027 : }
7028 : }
7029 : else
7030 : {
7031 0 : std::cout << "SgTypeUnknown :: " << std::flush;
7032 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
7033 0 : std::cout << " not valid " << std::endl;
7034 : }
7035 : }
7036 :
7037 0 : if ( p_ptr_to != NULL )
7038 : {
7039 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7040 : {
7041 0 : if ( p_ptr_to->isInMemoryPool() == false )
7042 : {
7043 0 : std::cout << "SgTypeUnknown :: ";
7044 0 : std::cout << " p_ptr_to is not in memory pool of ";
7045 0 : std::cout << p_ptr_to->class_name() << std::endl;
7046 : }
7047 : }
7048 : else
7049 : {
7050 0 : std::cout << "SgTypeUnknown :: " << std::flush;
7051 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
7052 0 : std::cout << " not valid " << std::endl;
7053 : }
7054 : }
7055 :
7056 0 : if ( p_modifiers != NULL )
7057 : {
7058 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7059 : {
7060 0 : if ( p_modifiers->isInMemoryPool() == false )
7061 : {
7062 0 : std::cout << "SgTypeUnknown :: ";
7063 0 : std::cout << " p_modifiers is not in memory pool of ";
7064 0 : std::cout << p_modifiers->class_name() << std::endl;
7065 : }
7066 : }
7067 : else
7068 : {
7069 0 : std::cout << "SgTypeUnknown :: " << std::flush;
7070 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
7071 0 : std::cout << " not valid " << std::endl;
7072 : }
7073 : }
7074 :
7075 0 : if ( p_typedefs != NULL )
7076 : {
7077 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7078 : {
7079 0 : if ( p_typedefs->isInMemoryPool() == false )
7080 : {
7081 0 : std::cout << "SgTypeUnknown :: ";
7082 0 : std::cout << " p_typedefs is not in memory pool of ";
7083 0 : std::cout << p_typedefs->class_name() << std::endl;
7084 : }
7085 : }
7086 : else
7087 : {
7088 0 : std::cout << "SgTypeUnknown :: " << std::flush;
7089 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
7090 0 : std::cout << " not valid " << std::endl;
7091 : }
7092 : }
7093 :
7094 0 : if ( p_rvalue_ref_to != NULL )
7095 : {
7096 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7097 : {
7098 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
7099 : {
7100 0 : std::cout << "SgTypeUnknown :: ";
7101 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
7102 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
7103 : }
7104 : }
7105 : else
7106 : {
7107 0 : std::cout << "SgTypeUnknown :: " << std::flush;
7108 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
7109 0 : std::cout << " not valid " << std::endl;
7110 : }
7111 : }
7112 :
7113 0 : if ( p_decltype_ref_to != NULL )
7114 : {
7115 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7116 : {
7117 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
7118 : {
7119 0 : std::cout << "SgTypeUnknown :: ";
7120 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
7121 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
7122 : }
7123 : }
7124 : else
7125 : {
7126 0 : std::cout << "SgTypeUnknown :: " << std::flush;
7127 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
7128 0 : std::cout << " not valid " << std::endl;
7129 : }
7130 : }
7131 :
7132 0 : if ( p_typeof_ref_to != NULL )
7133 : {
7134 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7135 : {
7136 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
7137 : {
7138 0 : std::cout << "SgTypeUnknown :: ";
7139 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
7140 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
7141 : }
7142 : }
7143 : else
7144 : {
7145 0 : std::cout << "SgTypeUnknown :: " << std::flush;
7146 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
7147 0 : std::cout << " not valid " << std::endl;
7148 : }
7149 : }
7150 :
7151 0 : if ( p_type_kind != NULL )
7152 : {
7153 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7154 : {
7155 0 : if ( p_type_kind->isInMemoryPool() == false )
7156 : {
7157 0 : std::cout << "SgTypeUnknown :: ";
7158 0 : std::cout << " p_type_kind is not in memory pool of ";
7159 0 : std::cout << p_type_kind->class_name() << std::endl;
7160 : }
7161 : }
7162 : else
7163 : {
7164 0 : std::cout << "SgTypeUnknown :: " << std::flush;
7165 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
7166 0 : std::cout << " not valid " << std::endl;
7167 : }
7168 : }
7169 :
7170 0 : if ( p_parent != NULL )
7171 : {
7172 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7173 : {
7174 0 : if ( p_parent->isInMemoryPool() == false )
7175 : {
7176 0 : std::cout << "SgTypeUnknown :: ";
7177 0 : std::cout << " p_parent is not in memory pool of ";
7178 0 : std::cout << p_parent->class_name() << std::endl;
7179 : }
7180 : }
7181 : else
7182 : {
7183 0 : std::cout << "SgTypeUnknown :: " << std::flush;
7184 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
7185 0 : std::cout << " not valid " << std::endl;
7186 : }
7187 : }
7188 :
7189 :
7190 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
7191 :
7192 0 : }
7193 :
7194 :
7195 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
7196 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
7197 : bool
7198 0 : SgTypeUnknown::isInMemoryPool ()
7199 : {
7200 0 : typedef unsigned char* TestType;
7201 :
7202 0 : bool found = false;
7203 :
7204 0 : ROSE_ASSERT(this != NULL);
7205 :
7206 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
7207 :
7208 0 : TestType tested = (TestType) ( this ) ;
7209 :
7210 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeUnknown::pools.begin();
7211 :
7212 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
7213 : // while (found == false && block < Memory_Block_List.end())
7214 0 : while ( (found == false) && (block != SgTypeUnknown::pools.end()) )
7215 : {
7216 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeUnknown::pool_size * sizeof(SgTypeUnknown) ) ) ;
7217 0 : ++block;
7218 : }
7219 :
7220 : // Special handling for static data
7221 :
7222 :
7223 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
7224 0 : ROSE_ASSERT(found == true);
7225 :
7226 0 : return found;
7227 : }
7228 : /* #line 7229 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
7229 :
7230 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
7231 :
7232 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
7233 :
7234 : /* #line 7235 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
7235 :
7236 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
7237 :
7238 : void
7239 0 : SgTypeChar::checkDataMemberPointersIfInMemoryPool()
7240 : {
7241 : // ------------ checking pointers of SgTypeChar -------------------
7242 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
7243 :
7244 0 : if ( p_ref_to != NULL )
7245 : {
7246 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7247 : {
7248 0 : if ( p_ref_to->isInMemoryPool() == false )
7249 : {
7250 0 : std::cout << "SgTypeChar :: ";
7251 0 : std::cout << " p_ref_to is not in memory pool of ";
7252 0 : std::cout << p_ref_to->class_name() << std::endl;
7253 : }
7254 : }
7255 : else
7256 : {
7257 0 : std::cout << "SgTypeChar :: " << std::flush;
7258 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
7259 0 : std::cout << " not valid " << std::endl;
7260 : }
7261 : }
7262 :
7263 0 : if ( p_ptr_to != NULL )
7264 : {
7265 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7266 : {
7267 0 : if ( p_ptr_to->isInMemoryPool() == false )
7268 : {
7269 0 : std::cout << "SgTypeChar :: ";
7270 0 : std::cout << " p_ptr_to is not in memory pool of ";
7271 0 : std::cout << p_ptr_to->class_name() << std::endl;
7272 : }
7273 : }
7274 : else
7275 : {
7276 0 : std::cout << "SgTypeChar :: " << std::flush;
7277 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
7278 0 : std::cout << " not valid " << std::endl;
7279 : }
7280 : }
7281 :
7282 0 : if ( p_modifiers != NULL )
7283 : {
7284 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7285 : {
7286 0 : if ( p_modifiers->isInMemoryPool() == false )
7287 : {
7288 0 : std::cout << "SgTypeChar :: ";
7289 0 : std::cout << " p_modifiers is not in memory pool of ";
7290 0 : std::cout << p_modifiers->class_name() << std::endl;
7291 : }
7292 : }
7293 : else
7294 : {
7295 0 : std::cout << "SgTypeChar :: " << std::flush;
7296 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
7297 0 : std::cout << " not valid " << std::endl;
7298 : }
7299 : }
7300 :
7301 0 : if ( p_typedefs != NULL )
7302 : {
7303 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7304 : {
7305 0 : if ( p_typedefs->isInMemoryPool() == false )
7306 : {
7307 0 : std::cout << "SgTypeChar :: ";
7308 0 : std::cout << " p_typedefs is not in memory pool of ";
7309 0 : std::cout << p_typedefs->class_name() << std::endl;
7310 : }
7311 : }
7312 : else
7313 : {
7314 0 : std::cout << "SgTypeChar :: " << std::flush;
7315 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
7316 0 : std::cout << " not valid " << std::endl;
7317 : }
7318 : }
7319 :
7320 0 : if ( p_rvalue_ref_to != NULL )
7321 : {
7322 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7323 : {
7324 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
7325 : {
7326 0 : std::cout << "SgTypeChar :: ";
7327 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
7328 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
7329 : }
7330 : }
7331 : else
7332 : {
7333 0 : std::cout << "SgTypeChar :: " << std::flush;
7334 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
7335 0 : std::cout << " not valid " << std::endl;
7336 : }
7337 : }
7338 :
7339 0 : if ( p_decltype_ref_to != NULL )
7340 : {
7341 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7342 : {
7343 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
7344 : {
7345 0 : std::cout << "SgTypeChar :: ";
7346 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
7347 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
7348 : }
7349 : }
7350 : else
7351 : {
7352 0 : std::cout << "SgTypeChar :: " << std::flush;
7353 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
7354 0 : std::cout << " not valid " << std::endl;
7355 : }
7356 : }
7357 :
7358 0 : if ( p_typeof_ref_to != NULL )
7359 : {
7360 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7361 : {
7362 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
7363 : {
7364 0 : std::cout << "SgTypeChar :: ";
7365 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
7366 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
7367 : }
7368 : }
7369 : else
7370 : {
7371 0 : std::cout << "SgTypeChar :: " << std::flush;
7372 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
7373 0 : std::cout << " not valid " << std::endl;
7374 : }
7375 : }
7376 :
7377 0 : if ( p_type_kind != NULL )
7378 : {
7379 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7380 : {
7381 0 : if ( p_type_kind->isInMemoryPool() == false )
7382 : {
7383 0 : std::cout << "SgTypeChar :: ";
7384 0 : std::cout << " p_type_kind is not in memory pool of ";
7385 0 : std::cout << p_type_kind->class_name() << std::endl;
7386 : }
7387 : }
7388 : else
7389 : {
7390 0 : std::cout << "SgTypeChar :: " << std::flush;
7391 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
7392 0 : std::cout << " not valid " << std::endl;
7393 : }
7394 : }
7395 :
7396 0 : if ( p_parent != NULL )
7397 : {
7398 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7399 : {
7400 0 : if ( p_parent->isInMemoryPool() == false )
7401 : {
7402 0 : std::cout << "SgTypeChar :: ";
7403 0 : std::cout << " p_parent is not in memory pool of ";
7404 0 : std::cout << p_parent->class_name() << std::endl;
7405 : }
7406 : }
7407 : else
7408 : {
7409 0 : std::cout << "SgTypeChar :: " << std::flush;
7410 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
7411 0 : std::cout << " not valid " << std::endl;
7412 : }
7413 : }
7414 :
7415 :
7416 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
7417 :
7418 0 : }
7419 :
7420 :
7421 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
7422 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
7423 : bool
7424 0 : SgTypeChar::isInMemoryPool ()
7425 : {
7426 0 : typedef unsigned char* TestType;
7427 :
7428 0 : bool found = false;
7429 :
7430 0 : ROSE_ASSERT(this != NULL);
7431 :
7432 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
7433 :
7434 0 : TestType tested = (TestType) ( this ) ;
7435 :
7436 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeChar::pools.begin();
7437 :
7438 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
7439 : // while (found == false && block < Memory_Block_List.end())
7440 0 : while ( (found == false) && (block != SgTypeChar::pools.end()) )
7441 : {
7442 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeChar::pool_size * sizeof(SgTypeChar) ) ) ;
7443 0 : ++block;
7444 : }
7445 :
7446 : // Special handling for static data
7447 :
7448 :
7449 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
7450 0 : ROSE_ASSERT(found == true);
7451 :
7452 0 : return found;
7453 : }
7454 : /* #line 7455 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
7455 :
7456 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
7457 :
7458 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
7459 :
7460 : /* #line 7461 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
7461 :
7462 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
7463 :
7464 : void
7465 0 : SgTypeSignedChar::checkDataMemberPointersIfInMemoryPool()
7466 : {
7467 : // ------------ checking pointers of SgTypeSignedChar -------------------
7468 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
7469 :
7470 0 : if ( p_ref_to != NULL )
7471 : {
7472 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7473 : {
7474 0 : if ( p_ref_to->isInMemoryPool() == false )
7475 : {
7476 0 : std::cout << "SgTypeSignedChar :: ";
7477 0 : std::cout << " p_ref_to is not in memory pool of ";
7478 0 : std::cout << p_ref_to->class_name() << std::endl;
7479 : }
7480 : }
7481 : else
7482 : {
7483 0 : std::cout << "SgTypeSignedChar :: " << std::flush;
7484 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
7485 0 : std::cout << " not valid " << std::endl;
7486 : }
7487 : }
7488 :
7489 0 : if ( p_ptr_to != NULL )
7490 : {
7491 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7492 : {
7493 0 : if ( p_ptr_to->isInMemoryPool() == false )
7494 : {
7495 0 : std::cout << "SgTypeSignedChar :: ";
7496 0 : std::cout << " p_ptr_to is not in memory pool of ";
7497 0 : std::cout << p_ptr_to->class_name() << std::endl;
7498 : }
7499 : }
7500 : else
7501 : {
7502 0 : std::cout << "SgTypeSignedChar :: " << std::flush;
7503 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
7504 0 : std::cout << " not valid " << std::endl;
7505 : }
7506 : }
7507 :
7508 0 : if ( p_modifiers != NULL )
7509 : {
7510 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7511 : {
7512 0 : if ( p_modifiers->isInMemoryPool() == false )
7513 : {
7514 0 : std::cout << "SgTypeSignedChar :: ";
7515 0 : std::cout << " p_modifiers is not in memory pool of ";
7516 0 : std::cout << p_modifiers->class_name() << std::endl;
7517 : }
7518 : }
7519 : else
7520 : {
7521 0 : std::cout << "SgTypeSignedChar :: " << std::flush;
7522 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
7523 0 : std::cout << " not valid " << std::endl;
7524 : }
7525 : }
7526 :
7527 0 : if ( p_typedefs != NULL )
7528 : {
7529 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7530 : {
7531 0 : if ( p_typedefs->isInMemoryPool() == false )
7532 : {
7533 0 : std::cout << "SgTypeSignedChar :: ";
7534 0 : std::cout << " p_typedefs is not in memory pool of ";
7535 0 : std::cout << p_typedefs->class_name() << std::endl;
7536 : }
7537 : }
7538 : else
7539 : {
7540 0 : std::cout << "SgTypeSignedChar :: " << std::flush;
7541 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
7542 0 : std::cout << " not valid " << std::endl;
7543 : }
7544 : }
7545 :
7546 0 : if ( p_rvalue_ref_to != NULL )
7547 : {
7548 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7549 : {
7550 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
7551 : {
7552 0 : std::cout << "SgTypeSignedChar :: ";
7553 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
7554 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
7555 : }
7556 : }
7557 : else
7558 : {
7559 0 : std::cout << "SgTypeSignedChar :: " << std::flush;
7560 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
7561 0 : std::cout << " not valid " << std::endl;
7562 : }
7563 : }
7564 :
7565 0 : if ( p_decltype_ref_to != NULL )
7566 : {
7567 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7568 : {
7569 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
7570 : {
7571 0 : std::cout << "SgTypeSignedChar :: ";
7572 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
7573 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
7574 : }
7575 : }
7576 : else
7577 : {
7578 0 : std::cout << "SgTypeSignedChar :: " << std::flush;
7579 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
7580 0 : std::cout << " not valid " << std::endl;
7581 : }
7582 : }
7583 :
7584 0 : if ( p_typeof_ref_to != NULL )
7585 : {
7586 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7587 : {
7588 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
7589 : {
7590 0 : std::cout << "SgTypeSignedChar :: ";
7591 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
7592 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
7593 : }
7594 : }
7595 : else
7596 : {
7597 0 : std::cout << "SgTypeSignedChar :: " << std::flush;
7598 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
7599 0 : std::cout << " not valid " << std::endl;
7600 : }
7601 : }
7602 :
7603 0 : if ( p_type_kind != NULL )
7604 : {
7605 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7606 : {
7607 0 : if ( p_type_kind->isInMemoryPool() == false )
7608 : {
7609 0 : std::cout << "SgTypeSignedChar :: ";
7610 0 : std::cout << " p_type_kind is not in memory pool of ";
7611 0 : std::cout << p_type_kind->class_name() << std::endl;
7612 : }
7613 : }
7614 : else
7615 : {
7616 0 : std::cout << "SgTypeSignedChar :: " << std::flush;
7617 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
7618 0 : std::cout << " not valid " << std::endl;
7619 : }
7620 : }
7621 :
7622 0 : if ( p_parent != NULL )
7623 : {
7624 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7625 : {
7626 0 : if ( p_parent->isInMemoryPool() == false )
7627 : {
7628 0 : std::cout << "SgTypeSignedChar :: ";
7629 0 : std::cout << " p_parent is not in memory pool of ";
7630 0 : std::cout << p_parent->class_name() << std::endl;
7631 : }
7632 : }
7633 : else
7634 : {
7635 0 : std::cout << "SgTypeSignedChar :: " << std::flush;
7636 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
7637 0 : std::cout << " not valid " << std::endl;
7638 : }
7639 : }
7640 :
7641 :
7642 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
7643 :
7644 0 : }
7645 :
7646 :
7647 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
7648 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
7649 : bool
7650 0 : SgTypeSignedChar::isInMemoryPool ()
7651 : {
7652 0 : typedef unsigned char* TestType;
7653 :
7654 0 : bool found = false;
7655 :
7656 0 : ROSE_ASSERT(this != NULL);
7657 :
7658 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
7659 :
7660 0 : TestType tested = (TestType) ( this ) ;
7661 :
7662 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeSignedChar::pools.begin();
7663 :
7664 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
7665 : // while (found == false && block < Memory_Block_List.end())
7666 0 : while ( (found == false) && (block != SgTypeSignedChar::pools.end()) )
7667 : {
7668 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeSignedChar::pool_size * sizeof(SgTypeSignedChar) ) ) ;
7669 0 : ++block;
7670 : }
7671 :
7672 : // Special handling for static data
7673 :
7674 :
7675 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
7676 0 : ROSE_ASSERT(found == true);
7677 :
7678 0 : return found;
7679 : }
7680 : /* #line 7681 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
7681 :
7682 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
7683 :
7684 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
7685 :
7686 : /* #line 7687 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
7687 :
7688 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
7689 :
7690 : void
7691 0 : SgTypeUnsignedChar::checkDataMemberPointersIfInMemoryPool()
7692 : {
7693 : // ------------ checking pointers of SgTypeUnsignedChar -------------------
7694 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
7695 :
7696 0 : if ( p_ref_to != NULL )
7697 : {
7698 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7699 : {
7700 0 : if ( p_ref_to->isInMemoryPool() == false )
7701 : {
7702 0 : std::cout << "SgTypeUnsignedChar :: ";
7703 0 : std::cout << " p_ref_to is not in memory pool of ";
7704 0 : std::cout << p_ref_to->class_name() << std::endl;
7705 : }
7706 : }
7707 : else
7708 : {
7709 0 : std::cout << "SgTypeUnsignedChar :: " << std::flush;
7710 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
7711 0 : std::cout << " not valid " << std::endl;
7712 : }
7713 : }
7714 :
7715 0 : if ( p_ptr_to != NULL )
7716 : {
7717 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7718 : {
7719 0 : if ( p_ptr_to->isInMemoryPool() == false )
7720 : {
7721 0 : std::cout << "SgTypeUnsignedChar :: ";
7722 0 : std::cout << " p_ptr_to is not in memory pool of ";
7723 0 : std::cout << p_ptr_to->class_name() << std::endl;
7724 : }
7725 : }
7726 : else
7727 : {
7728 0 : std::cout << "SgTypeUnsignedChar :: " << std::flush;
7729 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
7730 0 : std::cout << " not valid " << std::endl;
7731 : }
7732 : }
7733 :
7734 0 : if ( p_modifiers != NULL )
7735 : {
7736 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7737 : {
7738 0 : if ( p_modifiers->isInMemoryPool() == false )
7739 : {
7740 0 : std::cout << "SgTypeUnsignedChar :: ";
7741 0 : std::cout << " p_modifiers is not in memory pool of ";
7742 0 : std::cout << p_modifiers->class_name() << std::endl;
7743 : }
7744 : }
7745 : else
7746 : {
7747 0 : std::cout << "SgTypeUnsignedChar :: " << std::flush;
7748 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
7749 0 : std::cout << " not valid " << std::endl;
7750 : }
7751 : }
7752 :
7753 0 : if ( p_typedefs != NULL )
7754 : {
7755 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7756 : {
7757 0 : if ( p_typedefs->isInMemoryPool() == false )
7758 : {
7759 0 : std::cout << "SgTypeUnsignedChar :: ";
7760 0 : std::cout << " p_typedefs is not in memory pool of ";
7761 0 : std::cout << p_typedefs->class_name() << std::endl;
7762 : }
7763 : }
7764 : else
7765 : {
7766 0 : std::cout << "SgTypeUnsignedChar :: " << std::flush;
7767 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
7768 0 : std::cout << " not valid " << std::endl;
7769 : }
7770 : }
7771 :
7772 0 : if ( p_rvalue_ref_to != NULL )
7773 : {
7774 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7775 : {
7776 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
7777 : {
7778 0 : std::cout << "SgTypeUnsignedChar :: ";
7779 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
7780 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
7781 : }
7782 : }
7783 : else
7784 : {
7785 0 : std::cout << "SgTypeUnsignedChar :: " << std::flush;
7786 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
7787 0 : std::cout << " not valid " << std::endl;
7788 : }
7789 : }
7790 :
7791 0 : if ( p_decltype_ref_to != NULL )
7792 : {
7793 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7794 : {
7795 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
7796 : {
7797 0 : std::cout << "SgTypeUnsignedChar :: ";
7798 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
7799 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
7800 : }
7801 : }
7802 : else
7803 : {
7804 0 : std::cout << "SgTypeUnsignedChar :: " << std::flush;
7805 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
7806 0 : std::cout << " not valid " << std::endl;
7807 : }
7808 : }
7809 :
7810 0 : if ( p_typeof_ref_to != NULL )
7811 : {
7812 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7813 : {
7814 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
7815 : {
7816 0 : std::cout << "SgTypeUnsignedChar :: ";
7817 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
7818 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
7819 : }
7820 : }
7821 : else
7822 : {
7823 0 : std::cout << "SgTypeUnsignedChar :: " << std::flush;
7824 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
7825 0 : std::cout << " not valid " << std::endl;
7826 : }
7827 : }
7828 :
7829 0 : if ( p_type_kind != NULL )
7830 : {
7831 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7832 : {
7833 0 : if ( p_type_kind->isInMemoryPool() == false )
7834 : {
7835 0 : std::cout << "SgTypeUnsignedChar :: ";
7836 0 : std::cout << " p_type_kind is not in memory pool of ";
7837 0 : std::cout << p_type_kind->class_name() << std::endl;
7838 : }
7839 : }
7840 : else
7841 : {
7842 0 : std::cout << "SgTypeUnsignedChar :: " << std::flush;
7843 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
7844 0 : std::cout << " not valid " << std::endl;
7845 : }
7846 : }
7847 :
7848 0 : if ( p_parent != NULL )
7849 : {
7850 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7851 : {
7852 0 : if ( p_parent->isInMemoryPool() == false )
7853 : {
7854 0 : std::cout << "SgTypeUnsignedChar :: ";
7855 0 : std::cout << " p_parent is not in memory pool of ";
7856 0 : std::cout << p_parent->class_name() << std::endl;
7857 : }
7858 : }
7859 : else
7860 : {
7861 0 : std::cout << "SgTypeUnsignedChar :: " << std::flush;
7862 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
7863 0 : std::cout << " not valid " << std::endl;
7864 : }
7865 : }
7866 :
7867 :
7868 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
7869 :
7870 0 : }
7871 :
7872 :
7873 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
7874 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
7875 : bool
7876 0 : SgTypeUnsignedChar::isInMemoryPool ()
7877 : {
7878 0 : typedef unsigned char* TestType;
7879 :
7880 0 : bool found = false;
7881 :
7882 0 : ROSE_ASSERT(this != NULL);
7883 :
7884 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
7885 :
7886 0 : TestType tested = (TestType) ( this ) ;
7887 :
7888 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeUnsignedChar::pools.begin();
7889 :
7890 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
7891 : // while (found == false && block < Memory_Block_List.end())
7892 0 : while ( (found == false) && (block != SgTypeUnsignedChar::pools.end()) )
7893 : {
7894 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeUnsignedChar::pool_size * sizeof(SgTypeUnsignedChar) ) ) ;
7895 0 : ++block;
7896 : }
7897 :
7898 : // Special handling for static data
7899 :
7900 :
7901 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
7902 0 : ROSE_ASSERT(found == true);
7903 :
7904 0 : return found;
7905 : }
7906 : /* #line 7907 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
7907 :
7908 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
7909 :
7910 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
7911 :
7912 : /* #line 7913 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
7913 :
7914 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
7915 :
7916 : void
7917 0 : SgTypeShort::checkDataMemberPointersIfInMemoryPool()
7918 : {
7919 : // ------------ checking pointers of SgTypeShort -------------------
7920 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
7921 :
7922 0 : if ( p_ref_to != NULL )
7923 : {
7924 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7925 : {
7926 0 : if ( p_ref_to->isInMemoryPool() == false )
7927 : {
7928 0 : std::cout << "SgTypeShort :: ";
7929 0 : std::cout << " p_ref_to is not in memory pool of ";
7930 0 : std::cout << p_ref_to->class_name() << std::endl;
7931 : }
7932 : }
7933 : else
7934 : {
7935 0 : std::cout << "SgTypeShort :: " << std::flush;
7936 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
7937 0 : std::cout << " not valid " << std::endl;
7938 : }
7939 : }
7940 :
7941 0 : if ( p_ptr_to != NULL )
7942 : {
7943 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7944 : {
7945 0 : if ( p_ptr_to->isInMemoryPool() == false )
7946 : {
7947 0 : std::cout << "SgTypeShort :: ";
7948 0 : std::cout << " p_ptr_to is not in memory pool of ";
7949 0 : std::cout << p_ptr_to->class_name() << std::endl;
7950 : }
7951 : }
7952 : else
7953 : {
7954 0 : std::cout << "SgTypeShort :: " << std::flush;
7955 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
7956 0 : std::cout << " not valid " << std::endl;
7957 : }
7958 : }
7959 :
7960 0 : if ( p_modifiers != NULL )
7961 : {
7962 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7963 : {
7964 0 : if ( p_modifiers->isInMemoryPool() == false )
7965 : {
7966 0 : std::cout << "SgTypeShort :: ";
7967 0 : std::cout << " p_modifiers is not in memory pool of ";
7968 0 : std::cout << p_modifiers->class_name() << std::endl;
7969 : }
7970 : }
7971 : else
7972 : {
7973 0 : std::cout << "SgTypeShort :: " << std::flush;
7974 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
7975 0 : std::cout << " not valid " << std::endl;
7976 : }
7977 : }
7978 :
7979 0 : if ( p_typedefs != NULL )
7980 : {
7981 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
7982 : {
7983 0 : if ( p_typedefs->isInMemoryPool() == false )
7984 : {
7985 0 : std::cout << "SgTypeShort :: ";
7986 0 : std::cout << " p_typedefs is not in memory pool of ";
7987 0 : std::cout << p_typedefs->class_name() << std::endl;
7988 : }
7989 : }
7990 : else
7991 : {
7992 0 : std::cout << "SgTypeShort :: " << std::flush;
7993 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
7994 0 : std::cout << " not valid " << std::endl;
7995 : }
7996 : }
7997 :
7998 0 : if ( p_rvalue_ref_to != NULL )
7999 : {
8000 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8001 : {
8002 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
8003 : {
8004 0 : std::cout << "SgTypeShort :: ";
8005 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
8006 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
8007 : }
8008 : }
8009 : else
8010 : {
8011 0 : std::cout << "SgTypeShort :: " << std::flush;
8012 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
8013 0 : std::cout << " not valid " << std::endl;
8014 : }
8015 : }
8016 :
8017 0 : if ( p_decltype_ref_to != NULL )
8018 : {
8019 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8020 : {
8021 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
8022 : {
8023 0 : std::cout << "SgTypeShort :: ";
8024 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
8025 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
8026 : }
8027 : }
8028 : else
8029 : {
8030 0 : std::cout << "SgTypeShort :: " << std::flush;
8031 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
8032 0 : std::cout << " not valid " << std::endl;
8033 : }
8034 : }
8035 :
8036 0 : if ( p_typeof_ref_to != NULL )
8037 : {
8038 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8039 : {
8040 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
8041 : {
8042 0 : std::cout << "SgTypeShort :: ";
8043 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
8044 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
8045 : }
8046 : }
8047 : else
8048 : {
8049 0 : std::cout << "SgTypeShort :: " << std::flush;
8050 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
8051 0 : std::cout << " not valid " << std::endl;
8052 : }
8053 : }
8054 :
8055 0 : if ( p_type_kind != NULL )
8056 : {
8057 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8058 : {
8059 0 : if ( p_type_kind->isInMemoryPool() == false )
8060 : {
8061 0 : std::cout << "SgTypeShort :: ";
8062 0 : std::cout << " p_type_kind is not in memory pool of ";
8063 0 : std::cout << p_type_kind->class_name() << std::endl;
8064 : }
8065 : }
8066 : else
8067 : {
8068 0 : std::cout << "SgTypeShort :: " << std::flush;
8069 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
8070 0 : std::cout << " not valid " << std::endl;
8071 : }
8072 : }
8073 :
8074 0 : if ( p_parent != NULL )
8075 : {
8076 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8077 : {
8078 0 : if ( p_parent->isInMemoryPool() == false )
8079 : {
8080 0 : std::cout << "SgTypeShort :: ";
8081 0 : std::cout << " p_parent is not in memory pool of ";
8082 0 : std::cout << p_parent->class_name() << std::endl;
8083 : }
8084 : }
8085 : else
8086 : {
8087 0 : std::cout << "SgTypeShort :: " << std::flush;
8088 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
8089 0 : std::cout << " not valid " << std::endl;
8090 : }
8091 : }
8092 :
8093 :
8094 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
8095 :
8096 0 : }
8097 :
8098 :
8099 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
8100 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
8101 : bool
8102 0 : SgTypeShort::isInMemoryPool ()
8103 : {
8104 0 : typedef unsigned char* TestType;
8105 :
8106 0 : bool found = false;
8107 :
8108 0 : ROSE_ASSERT(this != NULL);
8109 :
8110 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
8111 :
8112 0 : TestType tested = (TestType) ( this ) ;
8113 :
8114 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeShort::pools.begin();
8115 :
8116 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
8117 : // while (found == false && block < Memory_Block_List.end())
8118 0 : while ( (found == false) && (block != SgTypeShort::pools.end()) )
8119 : {
8120 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeShort::pool_size * sizeof(SgTypeShort) ) ) ;
8121 0 : ++block;
8122 : }
8123 :
8124 : // Special handling for static data
8125 :
8126 :
8127 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
8128 0 : ROSE_ASSERT(found == true);
8129 :
8130 0 : return found;
8131 : }
8132 : /* #line 8133 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
8133 :
8134 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
8135 :
8136 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
8137 :
8138 : /* #line 8139 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
8139 :
8140 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
8141 :
8142 : void
8143 0 : SgTypeSignedShort::checkDataMemberPointersIfInMemoryPool()
8144 : {
8145 : // ------------ checking pointers of SgTypeSignedShort -------------------
8146 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
8147 :
8148 0 : if ( p_ref_to != NULL )
8149 : {
8150 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8151 : {
8152 0 : if ( p_ref_to->isInMemoryPool() == false )
8153 : {
8154 0 : std::cout << "SgTypeSignedShort :: ";
8155 0 : std::cout << " p_ref_to is not in memory pool of ";
8156 0 : std::cout << p_ref_to->class_name() << std::endl;
8157 : }
8158 : }
8159 : else
8160 : {
8161 0 : std::cout << "SgTypeSignedShort :: " << std::flush;
8162 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
8163 0 : std::cout << " not valid " << std::endl;
8164 : }
8165 : }
8166 :
8167 0 : if ( p_ptr_to != NULL )
8168 : {
8169 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8170 : {
8171 0 : if ( p_ptr_to->isInMemoryPool() == false )
8172 : {
8173 0 : std::cout << "SgTypeSignedShort :: ";
8174 0 : std::cout << " p_ptr_to is not in memory pool of ";
8175 0 : std::cout << p_ptr_to->class_name() << std::endl;
8176 : }
8177 : }
8178 : else
8179 : {
8180 0 : std::cout << "SgTypeSignedShort :: " << std::flush;
8181 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
8182 0 : std::cout << " not valid " << std::endl;
8183 : }
8184 : }
8185 :
8186 0 : if ( p_modifiers != NULL )
8187 : {
8188 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8189 : {
8190 0 : if ( p_modifiers->isInMemoryPool() == false )
8191 : {
8192 0 : std::cout << "SgTypeSignedShort :: ";
8193 0 : std::cout << " p_modifiers is not in memory pool of ";
8194 0 : std::cout << p_modifiers->class_name() << std::endl;
8195 : }
8196 : }
8197 : else
8198 : {
8199 0 : std::cout << "SgTypeSignedShort :: " << std::flush;
8200 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
8201 0 : std::cout << " not valid " << std::endl;
8202 : }
8203 : }
8204 :
8205 0 : if ( p_typedefs != NULL )
8206 : {
8207 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8208 : {
8209 0 : if ( p_typedefs->isInMemoryPool() == false )
8210 : {
8211 0 : std::cout << "SgTypeSignedShort :: ";
8212 0 : std::cout << " p_typedefs is not in memory pool of ";
8213 0 : std::cout << p_typedefs->class_name() << std::endl;
8214 : }
8215 : }
8216 : else
8217 : {
8218 0 : std::cout << "SgTypeSignedShort :: " << std::flush;
8219 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
8220 0 : std::cout << " not valid " << std::endl;
8221 : }
8222 : }
8223 :
8224 0 : if ( p_rvalue_ref_to != NULL )
8225 : {
8226 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8227 : {
8228 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
8229 : {
8230 0 : std::cout << "SgTypeSignedShort :: ";
8231 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
8232 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
8233 : }
8234 : }
8235 : else
8236 : {
8237 0 : std::cout << "SgTypeSignedShort :: " << std::flush;
8238 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
8239 0 : std::cout << " not valid " << std::endl;
8240 : }
8241 : }
8242 :
8243 0 : if ( p_decltype_ref_to != NULL )
8244 : {
8245 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8246 : {
8247 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
8248 : {
8249 0 : std::cout << "SgTypeSignedShort :: ";
8250 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
8251 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
8252 : }
8253 : }
8254 : else
8255 : {
8256 0 : std::cout << "SgTypeSignedShort :: " << std::flush;
8257 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
8258 0 : std::cout << " not valid " << std::endl;
8259 : }
8260 : }
8261 :
8262 0 : if ( p_typeof_ref_to != NULL )
8263 : {
8264 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8265 : {
8266 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
8267 : {
8268 0 : std::cout << "SgTypeSignedShort :: ";
8269 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
8270 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
8271 : }
8272 : }
8273 : else
8274 : {
8275 0 : std::cout << "SgTypeSignedShort :: " << std::flush;
8276 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
8277 0 : std::cout << " not valid " << std::endl;
8278 : }
8279 : }
8280 :
8281 0 : if ( p_type_kind != NULL )
8282 : {
8283 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8284 : {
8285 0 : if ( p_type_kind->isInMemoryPool() == false )
8286 : {
8287 0 : std::cout << "SgTypeSignedShort :: ";
8288 0 : std::cout << " p_type_kind is not in memory pool of ";
8289 0 : std::cout << p_type_kind->class_name() << std::endl;
8290 : }
8291 : }
8292 : else
8293 : {
8294 0 : std::cout << "SgTypeSignedShort :: " << std::flush;
8295 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
8296 0 : std::cout << " not valid " << std::endl;
8297 : }
8298 : }
8299 :
8300 0 : if ( p_parent != NULL )
8301 : {
8302 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8303 : {
8304 0 : if ( p_parent->isInMemoryPool() == false )
8305 : {
8306 0 : std::cout << "SgTypeSignedShort :: ";
8307 0 : std::cout << " p_parent is not in memory pool of ";
8308 0 : std::cout << p_parent->class_name() << std::endl;
8309 : }
8310 : }
8311 : else
8312 : {
8313 0 : std::cout << "SgTypeSignedShort :: " << std::flush;
8314 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
8315 0 : std::cout << " not valid " << std::endl;
8316 : }
8317 : }
8318 :
8319 :
8320 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
8321 :
8322 0 : }
8323 :
8324 :
8325 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
8326 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
8327 : bool
8328 0 : SgTypeSignedShort::isInMemoryPool ()
8329 : {
8330 0 : typedef unsigned char* TestType;
8331 :
8332 0 : bool found = false;
8333 :
8334 0 : ROSE_ASSERT(this != NULL);
8335 :
8336 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
8337 :
8338 0 : TestType tested = (TestType) ( this ) ;
8339 :
8340 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeSignedShort::pools.begin();
8341 :
8342 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
8343 : // while (found == false && block < Memory_Block_List.end())
8344 0 : while ( (found == false) && (block != SgTypeSignedShort::pools.end()) )
8345 : {
8346 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeSignedShort::pool_size * sizeof(SgTypeSignedShort) ) ) ;
8347 0 : ++block;
8348 : }
8349 :
8350 : // Special handling for static data
8351 :
8352 :
8353 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
8354 0 : ROSE_ASSERT(found == true);
8355 :
8356 0 : return found;
8357 : }
8358 : /* #line 8359 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
8359 :
8360 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
8361 :
8362 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
8363 :
8364 : /* #line 8365 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
8365 :
8366 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
8367 :
8368 : void
8369 0 : SgTypeUnsignedShort::checkDataMemberPointersIfInMemoryPool()
8370 : {
8371 : // ------------ checking pointers of SgTypeUnsignedShort -------------------
8372 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
8373 :
8374 0 : if ( p_ref_to != NULL )
8375 : {
8376 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8377 : {
8378 0 : if ( p_ref_to->isInMemoryPool() == false )
8379 : {
8380 0 : std::cout << "SgTypeUnsignedShort :: ";
8381 0 : std::cout << " p_ref_to is not in memory pool of ";
8382 0 : std::cout << p_ref_to->class_name() << std::endl;
8383 : }
8384 : }
8385 : else
8386 : {
8387 0 : std::cout << "SgTypeUnsignedShort :: " << std::flush;
8388 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
8389 0 : std::cout << " not valid " << std::endl;
8390 : }
8391 : }
8392 :
8393 0 : if ( p_ptr_to != NULL )
8394 : {
8395 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8396 : {
8397 0 : if ( p_ptr_to->isInMemoryPool() == false )
8398 : {
8399 0 : std::cout << "SgTypeUnsignedShort :: ";
8400 0 : std::cout << " p_ptr_to is not in memory pool of ";
8401 0 : std::cout << p_ptr_to->class_name() << std::endl;
8402 : }
8403 : }
8404 : else
8405 : {
8406 0 : std::cout << "SgTypeUnsignedShort :: " << std::flush;
8407 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
8408 0 : std::cout << " not valid " << std::endl;
8409 : }
8410 : }
8411 :
8412 0 : if ( p_modifiers != NULL )
8413 : {
8414 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8415 : {
8416 0 : if ( p_modifiers->isInMemoryPool() == false )
8417 : {
8418 0 : std::cout << "SgTypeUnsignedShort :: ";
8419 0 : std::cout << " p_modifiers is not in memory pool of ";
8420 0 : std::cout << p_modifiers->class_name() << std::endl;
8421 : }
8422 : }
8423 : else
8424 : {
8425 0 : std::cout << "SgTypeUnsignedShort :: " << std::flush;
8426 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
8427 0 : std::cout << " not valid " << std::endl;
8428 : }
8429 : }
8430 :
8431 0 : if ( p_typedefs != NULL )
8432 : {
8433 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8434 : {
8435 0 : if ( p_typedefs->isInMemoryPool() == false )
8436 : {
8437 0 : std::cout << "SgTypeUnsignedShort :: ";
8438 0 : std::cout << " p_typedefs is not in memory pool of ";
8439 0 : std::cout << p_typedefs->class_name() << std::endl;
8440 : }
8441 : }
8442 : else
8443 : {
8444 0 : std::cout << "SgTypeUnsignedShort :: " << std::flush;
8445 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
8446 0 : std::cout << " not valid " << std::endl;
8447 : }
8448 : }
8449 :
8450 0 : if ( p_rvalue_ref_to != NULL )
8451 : {
8452 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8453 : {
8454 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
8455 : {
8456 0 : std::cout << "SgTypeUnsignedShort :: ";
8457 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
8458 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
8459 : }
8460 : }
8461 : else
8462 : {
8463 0 : std::cout << "SgTypeUnsignedShort :: " << std::flush;
8464 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
8465 0 : std::cout << " not valid " << std::endl;
8466 : }
8467 : }
8468 :
8469 0 : if ( p_decltype_ref_to != NULL )
8470 : {
8471 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8472 : {
8473 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
8474 : {
8475 0 : std::cout << "SgTypeUnsignedShort :: ";
8476 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
8477 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
8478 : }
8479 : }
8480 : else
8481 : {
8482 0 : std::cout << "SgTypeUnsignedShort :: " << std::flush;
8483 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
8484 0 : std::cout << " not valid " << std::endl;
8485 : }
8486 : }
8487 :
8488 0 : if ( p_typeof_ref_to != NULL )
8489 : {
8490 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8491 : {
8492 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
8493 : {
8494 0 : std::cout << "SgTypeUnsignedShort :: ";
8495 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
8496 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
8497 : }
8498 : }
8499 : else
8500 : {
8501 0 : std::cout << "SgTypeUnsignedShort :: " << std::flush;
8502 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
8503 0 : std::cout << " not valid " << std::endl;
8504 : }
8505 : }
8506 :
8507 0 : if ( p_type_kind != NULL )
8508 : {
8509 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8510 : {
8511 0 : if ( p_type_kind->isInMemoryPool() == false )
8512 : {
8513 0 : std::cout << "SgTypeUnsignedShort :: ";
8514 0 : std::cout << " p_type_kind is not in memory pool of ";
8515 0 : std::cout << p_type_kind->class_name() << std::endl;
8516 : }
8517 : }
8518 : else
8519 : {
8520 0 : std::cout << "SgTypeUnsignedShort :: " << std::flush;
8521 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
8522 0 : std::cout << " not valid " << std::endl;
8523 : }
8524 : }
8525 :
8526 0 : if ( p_parent != NULL )
8527 : {
8528 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8529 : {
8530 0 : if ( p_parent->isInMemoryPool() == false )
8531 : {
8532 0 : std::cout << "SgTypeUnsignedShort :: ";
8533 0 : std::cout << " p_parent is not in memory pool of ";
8534 0 : std::cout << p_parent->class_name() << std::endl;
8535 : }
8536 : }
8537 : else
8538 : {
8539 0 : std::cout << "SgTypeUnsignedShort :: " << std::flush;
8540 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
8541 0 : std::cout << " not valid " << std::endl;
8542 : }
8543 : }
8544 :
8545 :
8546 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
8547 :
8548 0 : }
8549 :
8550 :
8551 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
8552 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
8553 : bool
8554 0 : SgTypeUnsignedShort::isInMemoryPool ()
8555 : {
8556 0 : typedef unsigned char* TestType;
8557 :
8558 0 : bool found = false;
8559 :
8560 0 : ROSE_ASSERT(this != NULL);
8561 :
8562 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
8563 :
8564 0 : TestType tested = (TestType) ( this ) ;
8565 :
8566 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeUnsignedShort::pools.begin();
8567 :
8568 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
8569 : // while (found == false && block < Memory_Block_List.end())
8570 0 : while ( (found == false) && (block != SgTypeUnsignedShort::pools.end()) )
8571 : {
8572 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeUnsignedShort::pool_size * sizeof(SgTypeUnsignedShort) ) ) ;
8573 0 : ++block;
8574 : }
8575 :
8576 : // Special handling for static data
8577 :
8578 :
8579 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
8580 0 : ROSE_ASSERT(found == true);
8581 :
8582 0 : return found;
8583 : }
8584 : /* #line 8585 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
8585 :
8586 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
8587 :
8588 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
8589 :
8590 : /* #line 8591 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
8591 :
8592 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
8593 :
8594 : void
8595 0 : SgTypeInt::checkDataMemberPointersIfInMemoryPool()
8596 : {
8597 : // ------------ checking pointers of SgTypeInt -------------------
8598 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
8599 :
8600 0 : if ( p_ref_to != NULL )
8601 : {
8602 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8603 : {
8604 0 : if ( p_ref_to->isInMemoryPool() == false )
8605 : {
8606 0 : std::cout << "SgTypeInt :: ";
8607 0 : std::cout << " p_ref_to is not in memory pool of ";
8608 0 : std::cout << p_ref_to->class_name() << std::endl;
8609 : }
8610 : }
8611 : else
8612 : {
8613 0 : std::cout << "SgTypeInt :: " << std::flush;
8614 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
8615 0 : std::cout << " not valid " << std::endl;
8616 : }
8617 : }
8618 :
8619 0 : if ( p_ptr_to != NULL )
8620 : {
8621 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8622 : {
8623 0 : if ( p_ptr_to->isInMemoryPool() == false )
8624 : {
8625 0 : std::cout << "SgTypeInt :: ";
8626 0 : std::cout << " p_ptr_to is not in memory pool of ";
8627 0 : std::cout << p_ptr_to->class_name() << std::endl;
8628 : }
8629 : }
8630 : else
8631 : {
8632 0 : std::cout << "SgTypeInt :: " << std::flush;
8633 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
8634 0 : std::cout << " not valid " << std::endl;
8635 : }
8636 : }
8637 :
8638 0 : if ( p_modifiers != NULL )
8639 : {
8640 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8641 : {
8642 0 : if ( p_modifiers->isInMemoryPool() == false )
8643 : {
8644 0 : std::cout << "SgTypeInt :: ";
8645 0 : std::cout << " p_modifiers is not in memory pool of ";
8646 0 : std::cout << p_modifiers->class_name() << std::endl;
8647 : }
8648 : }
8649 : else
8650 : {
8651 0 : std::cout << "SgTypeInt :: " << std::flush;
8652 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
8653 0 : std::cout << " not valid " << std::endl;
8654 : }
8655 : }
8656 :
8657 0 : if ( p_typedefs != NULL )
8658 : {
8659 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8660 : {
8661 0 : if ( p_typedefs->isInMemoryPool() == false )
8662 : {
8663 0 : std::cout << "SgTypeInt :: ";
8664 0 : std::cout << " p_typedefs is not in memory pool of ";
8665 0 : std::cout << p_typedefs->class_name() << std::endl;
8666 : }
8667 : }
8668 : else
8669 : {
8670 0 : std::cout << "SgTypeInt :: " << std::flush;
8671 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
8672 0 : std::cout << " not valid " << std::endl;
8673 : }
8674 : }
8675 :
8676 0 : if ( p_rvalue_ref_to != NULL )
8677 : {
8678 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8679 : {
8680 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
8681 : {
8682 0 : std::cout << "SgTypeInt :: ";
8683 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
8684 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
8685 : }
8686 : }
8687 : else
8688 : {
8689 0 : std::cout << "SgTypeInt :: " << std::flush;
8690 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
8691 0 : std::cout << " not valid " << std::endl;
8692 : }
8693 : }
8694 :
8695 0 : if ( p_decltype_ref_to != NULL )
8696 : {
8697 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8698 : {
8699 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
8700 : {
8701 0 : std::cout << "SgTypeInt :: ";
8702 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
8703 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
8704 : }
8705 : }
8706 : else
8707 : {
8708 0 : std::cout << "SgTypeInt :: " << std::flush;
8709 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
8710 0 : std::cout << " not valid " << std::endl;
8711 : }
8712 : }
8713 :
8714 0 : if ( p_typeof_ref_to != NULL )
8715 : {
8716 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8717 : {
8718 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
8719 : {
8720 0 : std::cout << "SgTypeInt :: ";
8721 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
8722 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
8723 : }
8724 : }
8725 : else
8726 : {
8727 0 : std::cout << "SgTypeInt :: " << std::flush;
8728 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
8729 0 : std::cout << " not valid " << std::endl;
8730 : }
8731 : }
8732 :
8733 0 : if ( p_type_kind != NULL )
8734 : {
8735 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8736 : {
8737 0 : if ( p_type_kind->isInMemoryPool() == false )
8738 : {
8739 0 : std::cout << "SgTypeInt :: ";
8740 0 : std::cout << " p_type_kind is not in memory pool of ";
8741 0 : std::cout << p_type_kind->class_name() << std::endl;
8742 : }
8743 : }
8744 : else
8745 : {
8746 0 : std::cout << "SgTypeInt :: " << std::flush;
8747 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
8748 0 : std::cout << " not valid " << std::endl;
8749 : }
8750 : }
8751 :
8752 0 : if ( p_parent != NULL )
8753 : {
8754 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8755 : {
8756 0 : if ( p_parent->isInMemoryPool() == false )
8757 : {
8758 0 : std::cout << "SgTypeInt :: ";
8759 0 : std::cout << " p_parent is not in memory pool of ";
8760 0 : std::cout << p_parent->class_name() << std::endl;
8761 : }
8762 : }
8763 : else
8764 : {
8765 0 : std::cout << "SgTypeInt :: " << std::flush;
8766 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
8767 0 : std::cout << " not valid " << std::endl;
8768 : }
8769 : }
8770 :
8771 :
8772 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
8773 :
8774 0 : }
8775 :
8776 :
8777 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
8778 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
8779 : bool
8780 0 : SgTypeInt::isInMemoryPool ()
8781 : {
8782 0 : typedef unsigned char* TestType;
8783 :
8784 0 : bool found = false;
8785 :
8786 0 : ROSE_ASSERT(this != NULL);
8787 :
8788 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
8789 :
8790 0 : TestType tested = (TestType) ( this ) ;
8791 :
8792 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeInt::pools.begin();
8793 :
8794 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
8795 : // while (found == false && block < Memory_Block_List.end())
8796 0 : while ( (found == false) && (block != SgTypeInt::pools.end()) )
8797 : {
8798 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeInt::pool_size * sizeof(SgTypeInt) ) ) ;
8799 0 : ++block;
8800 : }
8801 :
8802 : // Special handling for static data
8803 :
8804 :
8805 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
8806 0 : ROSE_ASSERT(found == true);
8807 :
8808 0 : return found;
8809 : }
8810 : /* #line 8811 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
8811 :
8812 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
8813 :
8814 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
8815 :
8816 : /* #line 8817 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
8817 :
8818 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
8819 :
8820 : void
8821 0 : SgTypeSignedInt::checkDataMemberPointersIfInMemoryPool()
8822 : {
8823 : // ------------ checking pointers of SgTypeSignedInt -------------------
8824 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
8825 :
8826 0 : if ( p_ref_to != NULL )
8827 : {
8828 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8829 : {
8830 0 : if ( p_ref_to->isInMemoryPool() == false )
8831 : {
8832 0 : std::cout << "SgTypeSignedInt :: ";
8833 0 : std::cout << " p_ref_to is not in memory pool of ";
8834 0 : std::cout << p_ref_to->class_name() << std::endl;
8835 : }
8836 : }
8837 : else
8838 : {
8839 0 : std::cout << "SgTypeSignedInt :: " << std::flush;
8840 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
8841 0 : std::cout << " not valid " << std::endl;
8842 : }
8843 : }
8844 :
8845 0 : if ( p_ptr_to != NULL )
8846 : {
8847 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8848 : {
8849 0 : if ( p_ptr_to->isInMemoryPool() == false )
8850 : {
8851 0 : std::cout << "SgTypeSignedInt :: ";
8852 0 : std::cout << " p_ptr_to is not in memory pool of ";
8853 0 : std::cout << p_ptr_to->class_name() << std::endl;
8854 : }
8855 : }
8856 : else
8857 : {
8858 0 : std::cout << "SgTypeSignedInt :: " << std::flush;
8859 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
8860 0 : std::cout << " not valid " << std::endl;
8861 : }
8862 : }
8863 :
8864 0 : if ( p_modifiers != NULL )
8865 : {
8866 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8867 : {
8868 0 : if ( p_modifiers->isInMemoryPool() == false )
8869 : {
8870 0 : std::cout << "SgTypeSignedInt :: ";
8871 0 : std::cout << " p_modifiers is not in memory pool of ";
8872 0 : std::cout << p_modifiers->class_name() << std::endl;
8873 : }
8874 : }
8875 : else
8876 : {
8877 0 : std::cout << "SgTypeSignedInt :: " << std::flush;
8878 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
8879 0 : std::cout << " not valid " << std::endl;
8880 : }
8881 : }
8882 :
8883 0 : if ( p_typedefs != NULL )
8884 : {
8885 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8886 : {
8887 0 : if ( p_typedefs->isInMemoryPool() == false )
8888 : {
8889 0 : std::cout << "SgTypeSignedInt :: ";
8890 0 : std::cout << " p_typedefs is not in memory pool of ";
8891 0 : std::cout << p_typedefs->class_name() << std::endl;
8892 : }
8893 : }
8894 : else
8895 : {
8896 0 : std::cout << "SgTypeSignedInt :: " << std::flush;
8897 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
8898 0 : std::cout << " not valid " << std::endl;
8899 : }
8900 : }
8901 :
8902 0 : if ( p_rvalue_ref_to != NULL )
8903 : {
8904 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8905 : {
8906 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
8907 : {
8908 0 : std::cout << "SgTypeSignedInt :: ";
8909 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
8910 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
8911 : }
8912 : }
8913 : else
8914 : {
8915 0 : std::cout << "SgTypeSignedInt :: " << std::flush;
8916 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
8917 0 : std::cout << " not valid " << std::endl;
8918 : }
8919 : }
8920 :
8921 0 : if ( p_decltype_ref_to != NULL )
8922 : {
8923 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8924 : {
8925 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
8926 : {
8927 0 : std::cout << "SgTypeSignedInt :: ";
8928 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
8929 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
8930 : }
8931 : }
8932 : else
8933 : {
8934 0 : std::cout << "SgTypeSignedInt :: " << std::flush;
8935 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
8936 0 : std::cout << " not valid " << std::endl;
8937 : }
8938 : }
8939 :
8940 0 : if ( p_typeof_ref_to != NULL )
8941 : {
8942 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8943 : {
8944 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
8945 : {
8946 0 : std::cout << "SgTypeSignedInt :: ";
8947 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
8948 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
8949 : }
8950 : }
8951 : else
8952 : {
8953 0 : std::cout << "SgTypeSignedInt :: " << std::flush;
8954 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
8955 0 : std::cout << " not valid " << std::endl;
8956 : }
8957 : }
8958 :
8959 0 : if ( p_type_kind != NULL )
8960 : {
8961 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8962 : {
8963 0 : if ( p_type_kind->isInMemoryPool() == false )
8964 : {
8965 0 : std::cout << "SgTypeSignedInt :: ";
8966 0 : std::cout << " p_type_kind is not in memory pool of ";
8967 0 : std::cout << p_type_kind->class_name() << std::endl;
8968 : }
8969 : }
8970 : else
8971 : {
8972 0 : std::cout << "SgTypeSignedInt :: " << std::flush;
8973 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
8974 0 : std::cout << " not valid " << std::endl;
8975 : }
8976 : }
8977 :
8978 0 : if ( p_parent != NULL )
8979 : {
8980 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
8981 : {
8982 0 : if ( p_parent->isInMemoryPool() == false )
8983 : {
8984 0 : std::cout << "SgTypeSignedInt :: ";
8985 0 : std::cout << " p_parent is not in memory pool of ";
8986 0 : std::cout << p_parent->class_name() << std::endl;
8987 : }
8988 : }
8989 : else
8990 : {
8991 0 : std::cout << "SgTypeSignedInt :: " << std::flush;
8992 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
8993 0 : std::cout << " not valid " << std::endl;
8994 : }
8995 : }
8996 :
8997 :
8998 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
8999 :
9000 0 : }
9001 :
9002 :
9003 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
9004 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
9005 : bool
9006 0 : SgTypeSignedInt::isInMemoryPool ()
9007 : {
9008 0 : typedef unsigned char* TestType;
9009 :
9010 0 : bool found = false;
9011 :
9012 0 : ROSE_ASSERT(this != NULL);
9013 :
9014 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
9015 :
9016 0 : TestType tested = (TestType) ( this ) ;
9017 :
9018 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeSignedInt::pools.begin();
9019 :
9020 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
9021 : // while (found == false && block < Memory_Block_List.end())
9022 0 : while ( (found == false) && (block != SgTypeSignedInt::pools.end()) )
9023 : {
9024 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeSignedInt::pool_size * sizeof(SgTypeSignedInt) ) ) ;
9025 0 : ++block;
9026 : }
9027 :
9028 : // Special handling for static data
9029 :
9030 :
9031 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
9032 0 : ROSE_ASSERT(found == true);
9033 :
9034 0 : return found;
9035 : }
9036 : /* #line 9037 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
9037 :
9038 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
9039 :
9040 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
9041 :
9042 : /* #line 9043 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
9043 :
9044 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
9045 :
9046 : void
9047 0 : SgTypeUnsignedInt::checkDataMemberPointersIfInMemoryPool()
9048 : {
9049 : // ------------ checking pointers of SgTypeUnsignedInt -------------------
9050 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
9051 :
9052 0 : if ( p_ref_to != NULL )
9053 : {
9054 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9055 : {
9056 0 : if ( p_ref_to->isInMemoryPool() == false )
9057 : {
9058 0 : std::cout << "SgTypeUnsignedInt :: ";
9059 0 : std::cout << " p_ref_to is not in memory pool of ";
9060 0 : std::cout << p_ref_to->class_name() << std::endl;
9061 : }
9062 : }
9063 : else
9064 : {
9065 0 : std::cout << "SgTypeUnsignedInt :: " << std::flush;
9066 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
9067 0 : std::cout << " not valid " << std::endl;
9068 : }
9069 : }
9070 :
9071 0 : if ( p_ptr_to != NULL )
9072 : {
9073 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9074 : {
9075 0 : if ( p_ptr_to->isInMemoryPool() == false )
9076 : {
9077 0 : std::cout << "SgTypeUnsignedInt :: ";
9078 0 : std::cout << " p_ptr_to is not in memory pool of ";
9079 0 : std::cout << p_ptr_to->class_name() << std::endl;
9080 : }
9081 : }
9082 : else
9083 : {
9084 0 : std::cout << "SgTypeUnsignedInt :: " << std::flush;
9085 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
9086 0 : std::cout << " not valid " << std::endl;
9087 : }
9088 : }
9089 :
9090 0 : if ( p_modifiers != NULL )
9091 : {
9092 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9093 : {
9094 0 : if ( p_modifiers->isInMemoryPool() == false )
9095 : {
9096 0 : std::cout << "SgTypeUnsignedInt :: ";
9097 0 : std::cout << " p_modifiers is not in memory pool of ";
9098 0 : std::cout << p_modifiers->class_name() << std::endl;
9099 : }
9100 : }
9101 : else
9102 : {
9103 0 : std::cout << "SgTypeUnsignedInt :: " << std::flush;
9104 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
9105 0 : std::cout << " not valid " << std::endl;
9106 : }
9107 : }
9108 :
9109 0 : if ( p_typedefs != NULL )
9110 : {
9111 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9112 : {
9113 0 : if ( p_typedefs->isInMemoryPool() == false )
9114 : {
9115 0 : std::cout << "SgTypeUnsignedInt :: ";
9116 0 : std::cout << " p_typedefs is not in memory pool of ";
9117 0 : std::cout << p_typedefs->class_name() << std::endl;
9118 : }
9119 : }
9120 : else
9121 : {
9122 0 : std::cout << "SgTypeUnsignedInt :: " << std::flush;
9123 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
9124 0 : std::cout << " not valid " << std::endl;
9125 : }
9126 : }
9127 :
9128 0 : if ( p_rvalue_ref_to != NULL )
9129 : {
9130 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9131 : {
9132 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
9133 : {
9134 0 : std::cout << "SgTypeUnsignedInt :: ";
9135 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
9136 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
9137 : }
9138 : }
9139 : else
9140 : {
9141 0 : std::cout << "SgTypeUnsignedInt :: " << std::flush;
9142 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
9143 0 : std::cout << " not valid " << std::endl;
9144 : }
9145 : }
9146 :
9147 0 : if ( p_decltype_ref_to != NULL )
9148 : {
9149 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9150 : {
9151 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
9152 : {
9153 0 : std::cout << "SgTypeUnsignedInt :: ";
9154 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
9155 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
9156 : }
9157 : }
9158 : else
9159 : {
9160 0 : std::cout << "SgTypeUnsignedInt :: " << std::flush;
9161 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
9162 0 : std::cout << " not valid " << std::endl;
9163 : }
9164 : }
9165 :
9166 0 : if ( p_typeof_ref_to != NULL )
9167 : {
9168 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9169 : {
9170 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
9171 : {
9172 0 : std::cout << "SgTypeUnsignedInt :: ";
9173 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
9174 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
9175 : }
9176 : }
9177 : else
9178 : {
9179 0 : std::cout << "SgTypeUnsignedInt :: " << std::flush;
9180 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
9181 0 : std::cout << " not valid " << std::endl;
9182 : }
9183 : }
9184 :
9185 0 : if ( p_type_kind != NULL )
9186 : {
9187 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9188 : {
9189 0 : if ( p_type_kind->isInMemoryPool() == false )
9190 : {
9191 0 : std::cout << "SgTypeUnsignedInt :: ";
9192 0 : std::cout << " p_type_kind is not in memory pool of ";
9193 0 : std::cout << p_type_kind->class_name() << std::endl;
9194 : }
9195 : }
9196 : else
9197 : {
9198 0 : std::cout << "SgTypeUnsignedInt :: " << std::flush;
9199 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
9200 0 : std::cout << " not valid " << std::endl;
9201 : }
9202 : }
9203 :
9204 0 : if ( p_parent != NULL )
9205 : {
9206 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9207 : {
9208 0 : if ( p_parent->isInMemoryPool() == false )
9209 : {
9210 0 : std::cout << "SgTypeUnsignedInt :: ";
9211 0 : std::cout << " p_parent is not in memory pool of ";
9212 0 : std::cout << p_parent->class_name() << std::endl;
9213 : }
9214 : }
9215 : else
9216 : {
9217 0 : std::cout << "SgTypeUnsignedInt :: " << std::flush;
9218 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
9219 0 : std::cout << " not valid " << std::endl;
9220 : }
9221 : }
9222 :
9223 :
9224 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
9225 :
9226 0 : }
9227 :
9228 :
9229 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
9230 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
9231 : bool
9232 0 : SgTypeUnsignedInt::isInMemoryPool ()
9233 : {
9234 0 : typedef unsigned char* TestType;
9235 :
9236 0 : bool found = false;
9237 :
9238 0 : ROSE_ASSERT(this != NULL);
9239 :
9240 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
9241 :
9242 0 : TestType tested = (TestType) ( this ) ;
9243 :
9244 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeUnsignedInt::pools.begin();
9245 :
9246 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
9247 : // while (found == false && block < Memory_Block_List.end())
9248 0 : while ( (found == false) && (block != SgTypeUnsignedInt::pools.end()) )
9249 : {
9250 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeUnsignedInt::pool_size * sizeof(SgTypeUnsignedInt) ) ) ;
9251 0 : ++block;
9252 : }
9253 :
9254 : // Special handling for static data
9255 :
9256 :
9257 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
9258 0 : ROSE_ASSERT(found == true);
9259 :
9260 0 : return found;
9261 : }
9262 : /* #line 9263 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
9263 :
9264 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
9265 :
9266 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
9267 :
9268 : /* #line 9269 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
9269 :
9270 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
9271 :
9272 : void
9273 0 : SgTypeLong::checkDataMemberPointersIfInMemoryPool()
9274 : {
9275 : // ------------ checking pointers of SgTypeLong -------------------
9276 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
9277 :
9278 0 : if ( p_ref_to != NULL )
9279 : {
9280 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9281 : {
9282 0 : if ( p_ref_to->isInMemoryPool() == false )
9283 : {
9284 0 : std::cout << "SgTypeLong :: ";
9285 0 : std::cout << " p_ref_to is not in memory pool of ";
9286 0 : std::cout << p_ref_to->class_name() << std::endl;
9287 : }
9288 : }
9289 : else
9290 : {
9291 0 : std::cout << "SgTypeLong :: " << std::flush;
9292 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
9293 0 : std::cout << " not valid " << std::endl;
9294 : }
9295 : }
9296 :
9297 0 : if ( p_ptr_to != NULL )
9298 : {
9299 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9300 : {
9301 0 : if ( p_ptr_to->isInMemoryPool() == false )
9302 : {
9303 0 : std::cout << "SgTypeLong :: ";
9304 0 : std::cout << " p_ptr_to is not in memory pool of ";
9305 0 : std::cout << p_ptr_to->class_name() << std::endl;
9306 : }
9307 : }
9308 : else
9309 : {
9310 0 : std::cout << "SgTypeLong :: " << std::flush;
9311 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
9312 0 : std::cout << " not valid " << std::endl;
9313 : }
9314 : }
9315 :
9316 0 : if ( p_modifiers != NULL )
9317 : {
9318 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9319 : {
9320 0 : if ( p_modifiers->isInMemoryPool() == false )
9321 : {
9322 0 : std::cout << "SgTypeLong :: ";
9323 0 : std::cout << " p_modifiers is not in memory pool of ";
9324 0 : std::cout << p_modifiers->class_name() << std::endl;
9325 : }
9326 : }
9327 : else
9328 : {
9329 0 : std::cout << "SgTypeLong :: " << std::flush;
9330 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
9331 0 : std::cout << " not valid " << std::endl;
9332 : }
9333 : }
9334 :
9335 0 : if ( p_typedefs != NULL )
9336 : {
9337 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9338 : {
9339 0 : if ( p_typedefs->isInMemoryPool() == false )
9340 : {
9341 0 : std::cout << "SgTypeLong :: ";
9342 0 : std::cout << " p_typedefs is not in memory pool of ";
9343 0 : std::cout << p_typedefs->class_name() << std::endl;
9344 : }
9345 : }
9346 : else
9347 : {
9348 0 : std::cout << "SgTypeLong :: " << std::flush;
9349 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
9350 0 : std::cout << " not valid " << std::endl;
9351 : }
9352 : }
9353 :
9354 0 : if ( p_rvalue_ref_to != NULL )
9355 : {
9356 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9357 : {
9358 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
9359 : {
9360 0 : std::cout << "SgTypeLong :: ";
9361 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
9362 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
9363 : }
9364 : }
9365 : else
9366 : {
9367 0 : std::cout << "SgTypeLong :: " << std::flush;
9368 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
9369 0 : std::cout << " not valid " << std::endl;
9370 : }
9371 : }
9372 :
9373 0 : if ( p_decltype_ref_to != NULL )
9374 : {
9375 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9376 : {
9377 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
9378 : {
9379 0 : std::cout << "SgTypeLong :: ";
9380 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
9381 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
9382 : }
9383 : }
9384 : else
9385 : {
9386 0 : std::cout << "SgTypeLong :: " << std::flush;
9387 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
9388 0 : std::cout << " not valid " << std::endl;
9389 : }
9390 : }
9391 :
9392 0 : if ( p_typeof_ref_to != NULL )
9393 : {
9394 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9395 : {
9396 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
9397 : {
9398 0 : std::cout << "SgTypeLong :: ";
9399 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
9400 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
9401 : }
9402 : }
9403 : else
9404 : {
9405 0 : std::cout << "SgTypeLong :: " << std::flush;
9406 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
9407 0 : std::cout << " not valid " << std::endl;
9408 : }
9409 : }
9410 :
9411 0 : if ( p_type_kind != NULL )
9412 : {
9413 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9414 : {
9415 0 : if ( p_type_kind->isInMemoryPool() == false )
9416 : {
9417 0 : std::cout << "SgTypeLong :: ";
9418 0 : std::cout << " p_type_kind is not in memory pool of ";
9419 0 : std::cout << p_type_kind->class_name() << std::endl;
9420 : }
9421 : }
9422 : else
9423 : {
9424 0 : std::cout << "SgTypeLong :: " << std::flush;
9425 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
9426 0 : std::cout << " not valid " << std::endl;
9427 : }
9428 : }
9429 :
9430 0 : if ( p_parent != NULL )
9431 : {
9432 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9433 : {
9434 0 : if ( p_parent->isInMemoryPool() == false )
9435 : {
9436 0 : std::cout << "SgTypeLong :: ";
9437 0 : std::cout << " p_parent is not in memory pool of ";
9438 0 : std::cout << p_parent->class_name() << std::endl;
9439 : }
9440 : }
9441 : else
9442 : {
9443 0 : std::cout << "SgTypeLong :: " << std::flush;
9444 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
9445 0 : std::cout << " not valid " << std::endl;
9446 : }
9447 : }
9448 :
9449 :
9450 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
9451 :
9452 0 : }
9453 :
9454 :
9455 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
9456 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
9457 : bool
9458 0 : SgTypeLong::isInMemoryPool ()
9459 : {
9460 0 : typedef unsigned char* TestType;
9461 :
9462 0 : bool found = false;
9463 :
9464 0 : ROSE_ASSERT(this != NULL);
9465 :
9466 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
9467 :
9468 0 : TestType tested = (TestType) ( this ) ;
9469 :
9470 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeLong::pools.begin();
9471 :
9472 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
9473 : // while (found == false && block < Memory_Block_List.end())
9474 0 : while ( (found == false) && (block != SgTypeLong::pools.end()) )
9475 : {
9476 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeLong::pool_size * sizeof(SgTypeLong) ) ) ;
9477 0 : ++block;
9478 : }
9479 :
9480 : // Special handling for static data
9481 :
9482 :
9483 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
9484 0 : ROSE_ASSERT(found == true);
9485 :
9486 0 : return found;
9487 : }
9488 : /* #line 9489 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
9489 :
9490 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
9491 :
9492 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
9493 :
9494 : /* #line 9495 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
9495 :
9496 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
9497 :
9498 : void
9499 0 : SgTypeSignedLong::checkDataMemberPointersIfInMemoryPool()
9500 : {
9501 : // ------------ checking pointers of SgTypeSignedLong -------------------
9502 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
9503 :
9504 0 : if ( p_ref_to != NULL )
9505 : {
9506 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9507 : {
9508 0 : if ( p_ref_to->isInMemoryPool() == false )
9509 : {
9510 0 : std::cout << "SgTypeSignedLong :: ";
9511 0 : std::cout << " p_ref_to is not in memory pool of ";
9512 0 : std::cout << p_ref_to->class_name() << std::endl;
9513 : }
9514 : }
9515 : else
9516 : {
9517 0 : std::cout << "SgTypeSignedLong :: " << std::flush;
9518 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
9519 0 : std::cout << " not valid " << std::endl;
9520 : }
9521 : }
9522 :
9523 0 : if ( p_ptr_to != NULL )
9524 : {
9525 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9526 : {
9527 0 : if ( p_ptr_to->isInMemoryPool() == false )
9528 : {
9529 0 : std::cout << "SgTypeSignedLong :: ";
9530 0 : std::cout << " p_ptr_to is not in memory pool of ";
9531 0 : std::cout << p_ptr_to->class_name() << std::endl;
9532 : }
9533 : }
9534 : else
9535 : {
9536 0 : std::cout << "SgTypeSignedLong :: " << std::flush;
9537 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
9538 0 : std::cout << " not valid " << std::endl;
9539 : }
9540 : }
9541 :
9542 0 : if ( p_modifiers != NULL )
9543 : {
9544 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9545 : {
9546 0 : if ( p_modifiers->isInMemoryPool() == false )
9547 : {
9548 0 : std::cout << "SgTypeSignedLong :: ";
9549 0 : std::cout << " p_modifiers is not in memory pool of ";
9550 0 : std::cout << p_modifiers->class_name() << std::endl;
9551 : }
9552 : }
9553 : else
9554 : {
9555 0 : std::cout << "SgTypeSignedLong :: " << std::flush;
9556 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
9557 0 : std::cout << " not valid " << std::endl;
9558 : }
9559 : }
9560 :
9561 0 : if ( p_typedefs != NULL )
9562 : {
9563 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9564 : {
9565 0 : if ( p_typedefs->isInMemoryPool() == false )
9566 : {
9567 0 : std::cout << "SgTypeSignedLong :: ";
9568 0 : std::cout << " p_typedefs is not in memory pool of ";
9569 0 : std::cout << p_typedefs->class_name() << std::endl;
9570 : }
9571 : }
9572 : else
9573 : {
9574 0 : std::cout << "SgTypeSignedLong :: " << std::flush;
9575 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
9576 0 : std::cout << " not valid " << std::endl;
9577 : }
9578 : }
9579 :
9580 0 : if ( p_rvalue_ref_to != NULL )
9581 : {
9582 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9583 : {
9584 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
9585 : {
9586 0 : std::cout << "SgTypeSignedLong :: ";
9587 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
9588 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
9589 : }
9590 : }
9591 : else
9592 : {
9593 0 : std::cout << "SgTypeSignedLong :: " << std::flush;
9594 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
9595 0 : std::cout << " not valid " << std::endl;
9596 : }
9597 : }
9598 :
9599 0 : if ( p_decltype_ref_to != NULL )
9600 : {
9601 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9602 : {
9603 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
9604 : {
9605 0 : std::cout << "SgTypeSignedLong :: ";
9606 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
9607 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
9608 : }
9609 : }
9610 : else
9611 : {
9612 0 : std::cout << "SgTypeSignedLong :: " << std::flush;
9613 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
9614 0 : std::cout << " not valid " << std::endl;
9615 : }
9616 : }
9617 :
9618 0 : if ( p_typeof_ref_to != NULL )
9619 : {
9620 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9621 : {
9622 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
9623 : {
9624 0 : std::cout << "SgTypeSignedLong :: ";
9625 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
9626 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
9627 : }
9628 : }
9629 : else
9630 : {
9631 0 : std::cout << "SgTypeSignedLong :: " << std::flush;
9632 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
9633 0 : std::cout << " not valid " << std::endl;
9634 : }
9635 : }
9636 :
9637 0 : if ( p_type_kind != NULL )
9638 : {
9639 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9640 : {
9641 0 : if ( p_type_kind->isInMemoryPool() == false )
9642 : {
9643 0 : std::cout << "SgTypeSignedLong :: ";
9644 0 : std::cout << " p_type_kind is not in memory pool of ";
9645 0 : std::cout << p_type_kind->class_name() << std::endl;
9646 : }
9647 : }
9648 : else
9649 : {
9650 0 : std::cout << "SgTypeSignedLong :: " << std::flush;
9651 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
9652 0 : std::cout << " not valid " << std::endl;
9653 : }
9654 : }
9655 :
9656 0 : if ( p_parent != NULL )
9657 : {
9658 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9659 : {
9660 0 : if ( p_parent->isInMemoryPool() == false )
9661 : {
9662 0 : std::cout << "SgTypeSignedLong :: ";
9663 0 : std::cout << " p_parent is not in memory pool of ";
9664 0 : std::cout << p_parent->class_name() << std::endl;
9665 : }
9666 : }
9667 : else
9668 : {
9669 0 : std::cout << "SgTypeSignedLong :: " << std::flush;
9670 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
9671 0 : std::cout << " not valid " << std::endl;
9672 : }
9673 : }
9674 :
9675 :
9676 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
9677 :
9678 0 : }
9679 :
9680 :
9681 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
9682 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
9683 : bool
9684 0 : SgTypeSignedLong::isInMemoryPool ()
9685 : {
9686 0 : typedef unsigned char* TestType;
9687 :
9688 0 : bool found = false;
9689 :
9690 0 : ROSE_ASSERT(this != NULL);
9691 :
9692 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
9693 :
9694 0 : TestType tested = (TestType) ( this ) ;
9695 :
9696 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeSignedLong::pools.begin();
9697 :
9698 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
9699 : // while (found == false && block < Memory_Block_List.end())
9700 0 : while ( (found == false) && (block != SgTypeSignedLong::pools.end()) )
9701 : {
9702 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeSignedLong::pool_size * sizeof(SgTypeSignedLong) ) ) ;
9703 0 : ++block;
9704 : }
9705 :
9706 : // Special handling for static data
9707 :
9708 :
9709 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
9710 0 : ROSE_ASSERT(found == true);
9711 :
9712 0 : return found;
9713 : }
9714 : /* #line 9715 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
9715 :
9716 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
9717 :
9718 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
9719 :
9720 : /* #line 9721 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
9721 :
9722 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
9723 :
9724 : void
9725 0 : SgTypeUnsignedLong::checkDataMemberPointersIfInMemoryPool()
9726 : {
9727 : // ------------ checking pointers of SgTypeUnsignedLong -------------------
9728 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
9729 :
9730 0 : if ( p_ref_to != NULL )
9731 : {
9732 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9733 : {
9734 0 : if ( p_ref_to->isInMemoryPool() == false )
9735 : {
9736 0 : std::cout << "SgTypeUnsignedLong :: ";
9737 0 : std::cout << " p_ref_to is not in memory pool of ";
9738 0 : std::cout << p_ref_to->class_name() << std::endl;
9739 : }
9740 : }
9741 : else
9742 : {
9743 0 : std::cout << "SgTypeUnsignedLong :: " << std::flush;
9744 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
9745 0 : std::cout << " not valid " << std::endl;
9746 : }
9747 : }
9748 :
9749 0 : if ( p_ptr_to != NULL )
9750 : {
9751 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9752 : {
9753 0 : if ( p_ptr_to->isInMemoryPool() == false )
9754 : {
9755 0 : std::cout << "SgTypeUnsignedLong :: ";
9756 0 : std::cout << " p_ptr_to is not in memory pool of ";
9757 0 : std::cout << p_ptr_to->class_name() << std::endl;
9758 : }
9759 : }
9760 : else
9761 : {
9762 0 : std::cout << "SgTypeUnsignedLong :: " << std::flush;
9763 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
9764 0 : std::cout << " not valid " << std::endl;
9765 : }
9766 : }
9767 :
9768 0 : if ( p_modifiers != NULL )
9769 : {
9770 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9771 : {
9772 0 : if ( p_modifiers->isInMemoryPool() == false )
9773 : {
9774 0 : std::cout << "SgTypeUnsignedLong :: ";
9775 0 : std::cout << " p_modifiers is not in memory pool of ";
9776 0 : std::cout << p_modifiers->class_name() << std::endl;
9777 : }
9778 : }
9779 : else
9780 : {
9781 0 : std::cout << "SgTypeUnsignedLong :: " << std::flush;
9782 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
9783 0 : std::cout << " not valid " << std::endl;
9784 : }
9785 : }
9786 :
9787 0 : if ( p_typedefs != NULL )
9788 : {
9789 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9790 : {
9791 0 : if ( p_typedefs->isInMemoryPool() == false )
9792 : {
9793 0 : std::cout << "SgTypeUnsignedLong :: ";
9794 0 : std::cout << " p_typedefs is not in memory pool of ";
9795 0 : std::cout << p_typedefs->class_name() << std::endl;
9796 : }
9797 : }
9798 : else
9799 : {
9800 0 : std::cout << "SgTypeUnsignedLong :: " << std::flush;
9801 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
9802 0 : std::cout << " not valid " << std::endl;
9803 : }
9804 : }
9805 :
9806 0 : if ( p_rvalue_ref_to != NULL )
9807 : {
9808 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9809 : {
9810 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
9811 : {
9812 0 : std::cout << "SgTypeUnsignedLong :: ";
9813 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
9814 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
9815 : }
9816 : }
9817 : else
9818 : {
9819 0 : std::cout << "SgTypeUnsignedLong :: " << std::flush;
9820 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
9821 0 : std::cout << " not valid " << std::endl;
9822 : }
9823 : }
9824 :
9825 0 : if ( p_decltype_ref_to != NULL )
9826 : {
9827 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9828 : {
9829 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
9830 : {
9831 0 : std::cout << "SgTypeUnsignedLong :: ";
9832 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
9833 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
9834 : }
9835 : }
9836 : else
9837 : {
9838 0 : std::cout << "SgTypeUnsignedLong :: " << std::flush;
9839 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
9840 0 : std::cout << " not valid " << std::endl;
9841 : }
9842 : }
9843 :
9844 0 : if ( p_typeof_ref_to != NULL )
9845 : {
9846 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9847 : {
9848 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
9849 : {
9850 0 : std::cout << "SgTypeUnsignedLong :: ";
9851 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
9852 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
9853 : }
9854 : }
9855 : else
9856 : {
9857 0 : std::cout << "SgTypeUnsignedLong :: " << std::flush;
9858 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
9859 0 : std::cout << " not valid " << std::endl;
9860 : }
9861 : }
9862 :
9863 0 : if ( p_type_kind != NULL )
9864 : {
9865 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9866 : {
9867 0 : if ( p_type_kind->isInMemoryPool() == false )
9868 : {
9869 0 : std::cout << "SgTypeUnsignedLong :: ";
9870 0 : std::cout << " p_type_kind is not in memory pool of ";
9871 0 : std::cout << p_type_kind->class_name() << std::endl;
9872 : }
9873 : }
9874 : else
9875 : {
9876 0 : std::cout << "SgTypeUnsignedLong :: " << std::flush;
9877 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
9878 0 : std::cout << " not valid " << std::endl;
9879 : }
9880 : }
9881 :
9882 0 : if ( p_parent != NULL )
9883 : {
9884 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9885 : {
9886 0 : if ( p_parent->isInMemoryPool() == false )
9887 : {
9888 0 : std::cout << "SgTypeUnsignedLong :: ";
9889 0 : std::cout << " p_parent is not in memory pool of ";
9890 0 : std::cout << p_parent->class_name() << std::endl;
9891 : }
9892 : }
9893 : else
9894 : {
9895 0 : std::cout << "SgTypeUnsignedLong :: " << std::flush;
9896 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
9897 0 : std::cout << " not valid " << std::endl;
9898 : }
9899 : }
9900 :
9901 :
9902 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
9903 :
9904 0 : }
9905 :
9906 :
9907 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
9908 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
9909 : bool
9910 0 : SgTypeUnsignedLong::isInMemoryPool ()
9911 : {
9912 0 : typedef unsigned char* TestType;
9913 :
9914 0 : bool found = false;
9915 :
9916 0 : ROSE_ASSERT(this != NULL);
9917 :
9918 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
9919 :
9920 0 : TestType tested = (TestType) ( this ) ;
9921 :
9922 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeUnsignedLong::pools.begin();
9923 :
9924 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
9925 : // while (found == false && block < Memory_Block_List.end())
9926 0 : while ( (found == false) && (block != SgTypeUnsignedLong::pools.end()) )
9927 : {
9928 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeUnsignedLong::pool_size * sizeof(SgTypeUnsignedLong) ) ) ;
9929 0 : ++block;
9930 : }
9931 :
9932 : // Special handling for static data
9933 :
9934 :
9935 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
9936 0 : ROSE_ASSERT(found == true);
9937 :
9938 0 : return found;
9939 : }
9940 : /* #line 9941 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
9941 :
9942 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
9943 :
9944 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
9945 :
9946 : /* #line 9947 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
9947 :
9948 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
9949 :
9950 : void
9951 0 : SgTypeVoid::checkDataMemberPointersIfInMemoryPool()
9952 : {
9953 : // ------------ checking pointers of SgTypeVoid -------------------
9954 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
9955 :
9956 0 : if ( p_ref_to != NULL )
9957 : {
9958 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9959 : {
9960 0 : if ( p_ref_to->isInMemoryPool() == false )
9961 : {
9962 0 : std::cout << "SgTypeVoid :: ";
9963 0 : std::cout << " p_ref_to is not in memory pool of ";
9964 0 : std::cout << p_ref_to->class_name() << std::endl;
9965 : }
9966 : }
9967 : else
9968 : {
9969 0 : std::cout << "SgTypeVoid :: " << std::flush;
9970 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
9971 0 : std::cout << " not valid " << std::endl;
9972 : }
9973 : }
9974 :
9975 0 : if ( p_ptr_to != NULL )
9976 : {
9977 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9978 : {
9979 0 : if ( p_ptr_to->isInMemoryPool() == false )
9980 : {
9981 0 : std::cout << "SgTypeVoid :: ";
9982 0 : std::cout << " p_ptr_to is not in memory pool of ";
9983 0 : std::cout << p_ptr_to->class_name() << std::endl;
9984 : }
9985 : }
9986 : else
9987 : {
9988 0 : std::cout << "SgTypeVoid :: " << std::flush;
9989 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
9990 0 : std::cout << " not valid " << std::endl;
9991 : }
9992 : }
9993 :
9994 0 : if ( p_modifiers != NULL )
9995 : {
9996 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
9997 : {
9998 0 : if ( p_modifiers->isInMemoryPool() == false )
9999 : {
10000 0 : std::cout << "SgTypeVoid :: ";
10001 0 : std::cout << " p_modifiers is not in memory pool of ";
10002 0 : std::cout << p_modifiers->class_name() << std::endl;
10003 : }
10004 : }
10005 : else
10006 : {
10007 0 : std::cout << "SgTypeVoid :: " << std::flush;
10008 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
10009 0 : std::cout << " not valid " << std::endl;
10010 : }
10011 : }
10012 :
10013 0 : if ( p_typedefs != NULL )
10014 : {
10015 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10016 : {
10017 0 : if ( p_typedefs->isInMemoryPool() == false )
10018 : {
10019 0 : std::cout << "SgTypeVoid :: ";
10020 0 : std::cout << " p_typedefs is not in memory pool of ";
10021 0 : std::cout << p_typedefs->class_name() << std::endl;
10022 : }
10023 : }
10024 : else
10025 : {
10026 0 : std::cout << "SgTypeVoid :: " << std::flush;
10027 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
10028 0 : std::cout << " not valid " << std::endl;
10029 : }
10030 : }
10031 :
10032 0 : if ( p_rvalue_ref_to != NULL )
10033 : {
10034 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10035 : {
10036 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
10037 : {
10038 0 : std::cout << "SgTypeVoid :: ";
10039 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
10040 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
10041 : }
10042 : }
10043 : else
10044 : {
10045 0 : std::cout << "SgTypeVoid :: " << std::flush;
10046 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
10047 0 : std::cout << " not valid " << std::endl;
10048 : }
10049 : }
10050 :
10051 0 : if ( p_decltype_ref_to != NULL )
10052 : {
10053 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10054 : {
10055 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
10056 : {
10057 0 : std::cout << "SgTypeVoid :: ";
10058 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
10059 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
10060 : }
10061 : }
10062 : else
10063 : {
10064 0 : std::cout << "SgTypeVoid :: " << std::flush;
10065 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
10066 0 : std::cout << " not valid " << std::endl;
10067 : }
10068 : }
10069 :
10070 0 : if ( p_typeof_ref_to != NULL )
10071 : {
10072 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10073 : {
10074 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
10075 : {
10076 0 : std::cout << "SgTypeVoid :: ";
10077 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
10078 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
10079 : }
10080 : }
10081 : else
10082 : {
10083 0 : std::cout << "SgTypeVoid :: " << std::flush;
10084 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
10085 0 : std::cout << " not valid " << std::endl;
10086 : }
10087 : }
10088 :
10089 0 : if ( p_type_kind != NULL )
10090 : {
10091 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10092 : {
10093 0 : if ( p_type_kind->isInMemoryPool() == false )
10094 : {
10095 0 : std::cout << "SgTypeVoid :: ";
10096 0 : std::cout << " p_type_kind is not in memory pool of ";
10097 0 : std::cout << p_type_kind->class_name() << std::endl;
10098 : }
10099 : }
10100 : else
10101 : {
10102 0 : std::cout << "SgTypeVoid :: " << std::flush;
10103 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
10104 0 : std::cout << " not valid " << std::endl;
10105 : }
10106 : }
10107 :
10108 0 : if ( p_parent != NULL )
10109 : {
10110 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10111 : {
10112 0 : if ( p_parent->isInMemoryPool() == false )
10113 : {
10114 0 : std::cout << "SgTypeVoid :: ";
10115 0 : std::cout << " p_parent is not in memory pool of ";
10116 0 : std::cout << p_parent->class_name() << std::endl;
10117 : }
10118 : }
10119 : else
10120 : {
10121 0 : std::cout << "SgTypeVoid :: " << std::flush;
10122 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
10123 0 : std::cout << " not valid " << std::endl;
10124 : }
10125 : }
10126 :
10127 :
10128 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
10129 :
10130 0 : }
10131 :
10132 :
10133 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
10134 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
10135 : bool
10136 0 : SgTypeVoid::isInMemoryPool ()
10137 : {
10138 0 : typedef unsigned char* TestType;
10139 :
10140 0 : bool found = false;
10141 :
10142 0 : ROSE_ASSERT(this != NULL);
10143 :
10144 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
10145 :
10146 0 : TestType tested = (TestType) ( this ) ;
10147 :
10148 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeVoid::pools.begin();
10149 :
10150 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
10151 : // while (found == false && block < Memory_Block_List.end())
10152 0 : while ( (found == false) && (block != SgTypeVoid::pools.end()) )
10153 : {
10154 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeVoid::pool_size * sizeof(SgTypeVoid) ) ) ;
10155 0 : ++block;
10156 : }
10157 :
10158 : // Special handling for static data
10159 :
10160 :
10161 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
10162 0 : ROSE_ASSERT(found == true);
10163 :
10164 0 : return found;
10165 : }
10166 : /* #line 10167 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
10167 :
10168 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
10169 :
10170 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
10171 :
10172 : /* #line 10173 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
10173 :
10174 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
10175 :
10176 : void
10177 0 : SgTypeGlobalVoid::checkDataMemberPointersIfInMemoryPool()
10178 : {
10179 : // ------------ checking pointers of SgTypeGlobalVoid -------------------
10180 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
10181 :
10182 0 : if ( p_ref_to != NULL )
10183 : {
10184 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10185 : {
10186 0 : if ( p_ref_to->isInMemoryPool() == false )
10187 : {
10188 0 : std::cout << "SgTypeGlobalVoid :: ";
10189 0 : std::cout << " p_ref_to is not in memory pool of ";
10190 0 : std::cout << p_ref_to->class_name() << std::endl;
10191 : }
10192 : }
10193 : else
10194 : {
10195 0 : std::cout << "SgTypeGlobalVoid :: " << std::flush;
10196 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
10197 0 : std::cout << " not valid " << std::endl;
10198 : }
10199 : }
10200 :
10201 0 : if ( p_ptr_to != NULL )
10202 : {
10203 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10204 : {
10205 0 : if ( p_ptr_to->isInMemoryPool() == false )
10206 : {
10207 0 : std::cout << "SgTypeGlobalVoid :: ";
10208 0 : std::cout << " p_ptr_to is not in memory pool of ";
10209 0 : std::cout << p_ptr_to->class_name() << std::endl;
10210 : }
10211 : }
10212 : else
10213 : {
10214 0 : std::cout << "SgTypeGlobalVoid :: " << std::flush;
10215 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
10216 0 : std::cout << " not valid " << std::endl;
10217 : }
10218 : }
10219 :
10220 0 : if ( p_modifiers != NULL )
10221 : {
10222 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10223 : {
10224 0 : if ( p_modifiers->isInMemoryPool() == false )
10225 : {
10226 0 : std::cout << "SgTypeGlobalVoid :: ";
10227 0 : std::cout << " p_modifiers is not in memory pool of ";
10228 0 : std::cout << p_modifiers->class_name() << std::endl;
10229 : }
10230 : }
10231 : else
10232 : {
10233 0 : std::cout << "SgTypeGlobalVoid :: " << std::flush;
10234 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
10235 0 : std::cout << " not valid " << std::endl;
10236 : }
10237 : }
10238 :
10239 0 : if ( p_typedefs != NULL )
10240 : {
10241 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10242 : {
10243 0 : if ( p_typedefs->isInMemoryPool() == false )
10244 : {
10245 0 : std::cout << "SgTypeGlobalVoid :: ";
10246 0 : std::cout << " p_typedefs is not in memory pool of ";
10247 0 : std::cout << p_typedefs->class_name() << std::endl;
10248 : }
10249 : }
10250 : else
10251 : {
10252 0 : std::cout << "SgTypeGlobalVoid :: " << std::flush;
10253 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
10254 0 : std::cout << " not valid " << std::endl;
10255 : }
10256 : }
10257 :
10258 0 : if ( p_rvalue_ref_to != NULL )
10259 : {
10260 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10261 : {
10262 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
10263 : {
10264 0 : std::cout << "SgTypeGlobalVoid :: ";
10265 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
10266 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
10267 : }
10268 : }
10269 : else
10270 : {
10271 0 : std::cout << "SgTypeGlobalVoid :: " << std::flush;
10272 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
10273 0 : std::cout << " not valid " << std::endl;
10274 : }
10275 : }
10276 :
10277 0 : if ( p_decltype_ref_to != NULL )
10278 : {
10279 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10280 : {
10281 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
10282 : {
10283 0 : std::cout << "SgTypeGlobalVoid :: ";
10284 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
10285 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
10286 : }
10287 : }
10288 : else
10289 : {
10290 0 : std::cout << "SgTypeGlobalVoid :: " << std::flush;
10291 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
10292 0 : std::cout << " not valid " << std::endl;
10293 : }
10294 : }
10295 :
10296 0 : if ( p_typeof_ref_to != NULL )
10297 : {
10298 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10299 : {
10300 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
10301 : {
10302 0 : std::cout << "SgTypeGlobalVoid :: ";
10303 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
10304 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
10305 : }
10306 : }
10307 : else
10308 : {
10309 0 : std::cout << "SgTypeGlobalVoid :: " << std::flush;
10310 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
10311 0 : std::cout << " not valid " << std::endl;
10312 : }
10313 : }
10314 :
10315 0 : if ( p_type_kind != NULL )
10316 : {
10317 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10318 : {
10319 0 : if ( p_type_kind->isInMemoryPool() == false )
10320 : {
10321 0 : std::cout << "SgTypeGlobalVoid :: ";
10322 0 : std::cout << " p_type_kind is not in memory pool of ";
10323 0 : std::cout << p_type_kind->class_name() << std::endl;
10324 : }
10325 : }
10326 : else
10327 : {
10328 0 : std::cout << "SgTypeGlobalVoid :: " << std::flush;
10329 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
10330 0 : std::cout << " not valid " << std::endl;
10331 : }
10332 : }
10333 :
10334 0 : if ( p_parent != NULL )
10335 : {
10336 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10337 : {
10338 0 : if ( p_parent->isInMemoryPool() == false )
10339 : {
10340 0 : std::cout << "SgTypeGlobalVoid :: ";
10341 0 : std::cout << " p_parent is not in memory pool of ";
10342 0 : std::cout << p_parent->class_name() << std::endl;
10343 : }
10344 : }
10345 : else
10346 : {
10347 0 : std::cout << "SgTypeGlobalVoid :: " << std::flush;
10348 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
10349 0 : std::cout << " not valid " << std::endl;
10350 : }
10351 : }
10352 :
10353 :
10354 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
10355 :
10356 0 : }
10357 :
10358 :
10359 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
10360 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
10361 : bool
10362 0 : SgTypeGlobalVoid::isInMemoryPool ()
10363 : {
10364 0 : typedef unsigned char* TestType;
10365 :
10366 0 : bool found = false;
10367 :
10368 0 : ROSE_ASSERT(this != NULL);
10369 :
10370 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
10371 :
10372 0 : TestType tested = (TestType) ( this ) ;
10373 :
10374 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeGlobalVoid::pools.begin();
10375 :
10376 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
10377 : // while (found == false && block < Memory_Block_List.end())
10378 0 : while ( (found == false) && (block != SgTypeGlobalVoid::pools.end()) )
10379 : {
10380 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeGlobalVoid::pool_size * sizeof(SgTypeGlobalVoid) ) ) ;
10381 0 : ++block;
10382 : }
10383 :
10384 : // Special handling for static data
10385 :
10386 :
10387 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
10388 0 : ROSE_ASSERT(found == true);
10389 :
10390 0 : return found;
10391 : }
10392 : /* #line 10393 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
10393 :
10394 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
10395 :
10396 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
10397 :
10398 : /* #line 10399 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
10399 :
10400 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
10401 :
10402 : void
10403 0 : SgTypeWchar::checkDataMemberPointersIfInMemoryPool()
10404 : {
10405 : // ------------ checking pointers of SgTypeWchar -------------------
10406 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
10407 :
10408 0 : if ( p_ref_to != NULL )
10409 : {
10410 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10411 : {
10412 0 : if ( p_ref_to->isInMemoryPool() == false )
10413 : {
10414 0 : std::cout << "SgTypeWchar :: ";
10415 0 : std::cout << " p_ref_to is not in memory pool of ";
10416 0 : std::cout << p_ref_to->class_name() << std::endl;
10417 : }
10418 : }
10419 : else
10420 : {
10421 0 : std::cout << "SgTypeWchar :: " << std::flush;
10422 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
10423 0 : std::cout << " not valid " << std::endl;
10424 : }
10425 : }
10426 :
10427 0 : if ( p_ptr_to != NULL )
10428 : {
10429 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10430 : {
10431 0 : if ( p_ptr_to->isInMemoryPool() == false )
10432 : {
10433 0 : std::cout << "SgTypeWchar :: ";
10434 0 : std::cout << " p_ptr_to is not in memory pool of ";
10435 0 : std::cout << p_ptr_to->class_name() << std::endl;
10436 : }
10437 : }
10438 : else
10439 : {
10440 0 : std::cout << "SgTypeWchar :: " << std::flush;
10441 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
10442 0 : std::cout << " not valid " << std::endl;
10443 : }
10444 : }
10445 :
10446 0 : if ( p_modifiers != NULL )
10447 : {
10448 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10449 : {
10450 0 : if ( p_modifiers->isInMemoryPool() == false )
10451 : {
10452 0 : std::cout << "SgTypeWchar :: ";
10453 0 : std::cout << " p_modifiers is not in memory pool of ";
10454 0 : std::cout << p_modifiers->class_name() << std::endl;
10455 : }
10456 : }
10457 : else
10458 : {
10459 0 : std::cout << "SgTypeWchar :: " << std::flush;
10460 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
10461 0 : std::cout << " not valid " << std::endl;
10462 : }
10463 : }
10464 :
10465 0 : if ( p_typedefs != NULL )
10466 : {
10467 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10468 : {
10469 0 : if ( p_typedefs->isInMemoryPool() == false )
10470 : {
10471 0 : std::cout << "SgTypeWchar :: ";
10472 0 : std::cout << " p_typedefs is not in memory pool of ";
10473 0 : std::cout << p_typedefs->class_name() << std::endl;
10474 : }
10475 : }
10476 : else
10477 : {
10478 0 : std::cout << "SgTypeWchar :: " << std::flush;
10479 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
10480 0 : std::cout << " not valid " << std::endl;
10481 : }
10482 : }
10483 :
10484 0 : if ( p_rvalue_ref_to != NULL )
10485 : {
10486 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10487 : {
10488 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
10489 : {
10490 0 : std::cout << "SgTypeWchar :: ";
10491 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
10492 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
10493 : }
10494 : }
10495 : else
10496 : {
10497 0 : std::cout << "SgTypeWchar :: " << std::flush;
10498 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
10499 0 : std::cout << " not valid " << std::endl;
10500 : }
10501 : }
10502 :
10503 0 : if ( p_decltype_ref_to != NULL )
10504 : {
10505 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10506 : {
10507 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
10508 : {
10509 0 : std::cout << "SgTypeWchar :: ";
10510 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
10511 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
10512 : }
10513 : }
10514 : else
10515 : {
10516 0 : std::cout << "SgTypeWchar :: " << std::flush;
10517 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
10518 0 : std::cout << " not valid " << std::endl;
10519 : }
10520 : }
10521 :
10522 0 : if ( p_typeof_ref_to != NULL )
10523 : {
10524 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10525 : {
10526 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
10527 : {
10528 0 : std::cout << "SgTypeWchar :: ";
10529 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
10530 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
10531 : }
10532 : }
10533 : else
10534 : {
10535 0 : std::cout << "SgTypeWchar :: " << std::flush;
10536 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
10537 0 : std::cout << " not valid " << std::endl;
10538 : }
10539 : }
10540 :
10541 0 : if ( p_type_kind != NULL )
10542 : {
10543 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10544 : {
10545 0 : if ( p_type_kind->isInMemoryPool() == false )
10546 : {
10547 0 : std::cout << "SgTypeWchar :: ";
10548 0 : std::cout << " p_type_kind is not in memory pool of ";
10549 0 : std::cout << p_type_kind->class_name() << std::endl;
10550 : }
10551 : }
10552 : else
10553 : {
10554 0 : std::cout << "SgTypeWchar :: " << std::flush;
10555 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
10556 0 : std::cout << " not valid " << std::endl;
10557 : }
10558 : }
10559 :
10560 0 : if ( p_parent != NULL )
10561 : {
10562 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10563 : {
10564 0 : if ( p_parent->isInMemoryPool() == false )
10565 : {
10566 0 : std::cout << "SgTypeWchar :: ";
10567 0 : std::cout << " p_parent is not in memory pool of ";
10568 0 : std::cout << p_parent->class_name() << std::endl;
10569 : }
10570 : }
10571 : else
10572 : {
10573 0 : std::cout << "SgTypeWchar :: " << std::flush;
10574 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
10575 0 : std::cout << " not valid " << std::endl;
10576 : }
10577 : }
10578 :
10579 :
10580 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
10581 :
10582 0 : }
10583 :
10584 :
10585 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
10586 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
10587 : bool
10588 0 : SgTypeWchar::isInMemoryPool ()
10589 : {
10590 0 : typedef unsigned char* TestType;
10591 :
10592 0 : bool found = false;
10593 :
10594 0 : ROSE_ASSERT(this != NULL);
10595 :
10596 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
10597 :
10598 0 : TestType tested = (TestType) ( this ) ;
10599 :
10600 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeWchar::pools.begin();
10601 :
10602 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
10603 : // while (found == false && block < Memory_Block_List.end())
10604 0 : while ( (found == false) && (block != SgTypeWchar::pools.end()) )
10605 : {
10606 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeWchar::pool_size * sizeof(SgTypeWchar) ) ) ;
10607 0 : ++block;
10608 : }
10609 :
10610 : // Special handling for static data
10611 :
10612 :
10613 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
10614 0 : ROSE_ASSERT(found == true);
10615 :
10616 0 : return found;
10617 : }
10618 : /* #line 10619 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
10619 :
10620 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
10621 :
10622 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
10623 :
10624 : /* #line 10625 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
10625 :
10626 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
10627 :
10628 : void
10629 0 : SgTypeFloat::checkDataMemberPointersIfInMemoryPool()
10630 : {
10631 : // ------------ checking pointers of SgTypeFloat -------------------
10632 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
10633 :
10634 0 : if ( p_ref_to != NULL )
10635 : {
10636 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10637 : {
10638 0 : if ( p_ref_to->isInMemoryPool() == false )
10639 : {
10640 0 : std::cout << "SgTypeFloat :: ";
10641 0 : std::cout << " p_ref_to is not in memory pool of ";
10642 0 : std::cout << p_ref_to->class_name() << std::endl;
10643 : }
10644 : }
10645 : else
10646 : {
10647 0 : std::cout << "SgTypeFloat :: " << std::flush;
10648 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
10649 0 : std::cout << " not valid " << std::endl;
10650 : }
10651 : }
10652 :
10653 0 : if ( p_ptr_to != NULL )
10654 : {
10655 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10656 : {
10657 0 : if ( p_ptr_to->isInMemoryPool() == false )
10658 : {
10659 0 : std::cout << "SgTypeFloat :: ";
10660 0 : std::cout << " p_ptr_to is not in memory pool of ";
10661 0 : std::cout << p_ptr_to->class_name() << std::endl;
10662 : }
10663 : }
10664 : else
10665 : {
10666 0 : std::cout << "SgTypeFloat :: " << std::flush;
10667 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
10668 0 : std::cout << " not valid " << std::endl;
10669 : }
10670 : }
10671 :
10672 0 : if ( p_modifiers != NULL )
10673 : {
10674 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10675 : {
10676 0 : if ( p_modifiers->isInMemoryPool() == false )
10677 : {
10678 0 : std::cout << "SgTypeFloat :: ";
10679 0 : std::cout << " p_modifiers is not in memory pool of ";
10680 0 : std::cout << p_modifiers->class_name() << std::endl;
10681 : }
10682 : }
10683 : else
10684 : {
10685 0 : std::cout << "SgTypeFloat :: " << std::flush;
10686 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
10687 0 : std::cout << " not valid " << std::endl;
10688 : }
10689 : }
10690 :
10691 0 : if ( p_typedefs != NULL )
10692 : {
10693 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10694 : {
10695 0 : if ( p_typedefs->isInMemoryPool() == false )
10696 : {
10697 0 : std::cout << "SgTypeFloat :: ";
10698 0 : std::cout << " p_typedefs is not in memory pool of ";
10699 0 : std::cout << p_typedefs->class_name() << std::endl;
10700 : }
10701 : }
10702 : else
10703 : {
10704 0 : std::cout << "SgTypeFloat :: " << std::flush;
10705 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
10706 0 : std::cout << " not valid " << std::endl;
10707 : }
10708 : }
10709 :
10710 0 : if ( p_rvalue_ref_to != NULL )
10711 : {
10712 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10713 : {
10714 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
10715 : {
10716 0 : std::cout << "SgTypeFloat :: ";
10717 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
10718 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
10719 : }
10720 : }
10721 : else
10722 : {
10723 0 : std::cout << "SgTypeFloat :: " << std::flush;
10724 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
10725 0 : std::cout << " not valid " << std::endl;
10726 : }
10727 : }
10728 :
10729 0 : if ( p_decltype_ref_to != NULL )
10730 : {
10731 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10732 : {
10733 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
10734 : {
10735 0 : std::cout << "SgTypeFloat :: ";
10736 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
10737 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
10738 : }
10739 : }
10740 : else
10741 : {
10742 0 : std::cout << "SgTypeFloat :: " << std::flush;
10743 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
10744 0 : std::cout << " not valid " << std::endl;
10745 : }
10746 : }
10747 :
10748 0 : if ( p_typeof_ref_to != NULL )
10749 : {
10750 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10751 : {
10752 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
10753 : {
10754 0 : std::cout << "SgTypeFloat :: ";
10755 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
10756 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
10757 : }
10758 : }
10759 : else
10760 : {
10761 0 : std::cout << "SgTypeFloat :: " << std::flush;
10762 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
10763 0 : std::cout << " not valid " << std::endl;
10764 : }
10765 : }
10766 :
10767 0 : if ( p_type_kind != NULL )
10768 : {
10769 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10770 : {
10771 0 : if ( p_type_kind->isInMemoryPool() == false )
10772 : {
10773 0 : std::cout << "SgTypeFloat :: ";
10774 0 : std::cout << " p_type_kind is not in memory pool of ";
10775 0 : std::cout << p_type_kind->class_name() << std::endl;
10776 : }
10777 : }
10778 : else
10779 : {
10780 0 : std::cout << "SgTypeFloat :: " << std::flush;
10781 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
10782 0 : std::cout << " not valid " << std::endl;
10783 : }
10784 : }
10785 :
10786 0 : if ( p_parent != NULL )
10787 : {
10788 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10789 : {
10790 0 : if ( p_parent->isInMemoryPool() == false )
10791 : {
10792 0 : std::cout << "SgTypeFloat :: ";
10793 0 : std::cout << " p_parent is not in memory pool of ";
10794 0 : std::cout << p_parent->class_name() << std::endl;
10795 : }
10796 : }
10797 : else
10798 : {
10799 0 : std::cout << "SgTypeFloat :: " << std::flush;
10800 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
10801 0 : std::cout << " not valid " << std::endl;
10802 : }
10803 : }
10804 :
10805 :
10806 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
10807 :
10808 0 : }
10809 :
10810 :
10811 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
10812 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
10813 : bool
10814 0 : SgTypeFloat::isInMemoryPool ()
10815 : {
10816 0 : typedef unsigned char* TestType;
10817 :
10818 0 : bool found = false;
10819 :
10820 0 : ROSE_ASSERT(this != NULL);
10821 :
10822 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
10823 :
10824 0 : TestType tested = (TestType) ( this ) ;
10825 :
10826 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeFloat::pools.begin();
10827 :
10828 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
10829 : // while (found == false && block < Memory_Block_List.end())
10830 0 : while ( (found == false) && (block != SgTypeFloat::pools.end()) )
10831 : {
10832 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeFloat::pool_size * sizeof(SgTypeFloat) ) ) ;
10833 0 : ++block;
10834 : }
10835 :
10836 : // Special handling for static data
10837 :
10838 :
10839 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
10840 0 : ROSE_ASSERT(found == true);
10841 :
10842 0 : return found;
10843 : }
10844 : /* #line 10845 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
10845 :
10846 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
10847 :
10848 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
10849 :
10850 : /* #line 10851 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
10851 :
10852 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
10853 :
10854 : void
10855 0 : SgTypeDouble::checkDataMemberPointersIfInMemoryPool()
10856 : {
10857 : // ------------ checking pointers of SgTypeDouble -------------------
10858 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
10859 :
10860 0 : if ( p_ref_to != NULL )
10861 : {
10862 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10863 : {
10864 0 : if ( p_ref_to->isInMemoryPool() == false )
10865 : {
10866 0 : std::cout << "SgTypeDouble :: ";
10867 0 : std::cout << " p_ref_to is not in memory pool of ";
10868 0 : std::cout << p_ref_to->class_name() << std::endl;
10869 : }
10870 : }
10871 : else
10872 : {
10873 0 : std::cout << "SgTypeDouble :: " << std::flush;
10874 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
10875 0 : std::cout << " not valid " << std::endl;
10876 : }
10877 : }
10878 :
10879 0 : if ( p_ptr_to != NULL )
10880 : {
10881 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10882 : {
10883 0 : if ( p_ptr_to->isInMemoryPool() == false )
10884 : {
10885 0 : std::cout << "SgTypeDouble :: ";
10886 0 : std::cout << " p_ptr_to is not in memory pool of ";
10887 0 : std::cout << p_ptr_to->class_name() << std::endl;
10888 : }
10889 : }
10890 : else
10891 : {
10892 0 : std::cout << "SgTypeDouble :: " << std::flush;
10893 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
10894 0 : std::cout << " not valid " << std::endl;
10895 : }
10896 : }
10897 :
10898 0 : if ( p_modifiers != NULL )
10899 : {
10900 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10901 : {
10902 0 : if ( p_modifiers->isInMemoryPool() == false )
10903 : {
10904 0 : std::cout << "SgTypeDouble :: ";
10905 0 : std::cout << " p_modifiers is not in memory pool of ";
10906 0 : std::cout << p_modifiers->class_name() << std::endl;
10907 : }
10908 : }
10909 : else
10910 : {
10911 0 : std::cout << "SgTypeDouble :: " << std::flush;
10912 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
10913 0 : std::cout << " not valid " << std::endl;
10914 : }
10915 : }
10916 :
10917 0 : if ( p_typedefs != NULL )
10918 : {
10919 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10920 : {
10921 0 : if ( p_typedefs->isInMemoryPool() == false )
10922 : {
10923 0 : std::cout << "SgTypeDouble :: ";
10924 0 : std::cout << " p_typedefs is not in memory pool of ";
10925 0 : std::cout << p_typedefs->class_name() << std::endl;
10926 : }
10927 : }
10928 : else
10929 : {
10930 0 : std::cout << "SgTypeDouble :: " << std::flush;
10931 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
10932 0 : std::cout << " not valid " << std::endl;
10933 : }
10934 : }
10935 :
10936 0 : if ( p_rvalue_ref_to != NULL )
10937 : {
10938 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10939 : {
10940 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
10941 : {
10942 0 : std::cout << "SgTypeDouble :: ";
10943 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
10944 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
10945 : }
10946 : }
10947 : else
10948 : {
10949 0 : std::cout << "SgTypeDouble :: " << std::flush;
10950 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
10951 0 : std::cout << " not valid " << std::endl;
10952 : }
10953 : }
10954 :
10955 0 : if ( p_decltype_ref_to != NULL )
10956 : {
10957 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10958 : {
10959 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
10960 : {
10961 0 : std::cout << "SgTypeDouble :: ";
10962 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
10963 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
10964 : }
10965 : }
10966 : else
10967 : {
10968 0 : std::cout << "SgTypeDouble :: " << std::flush;
10969 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
10970 0 : std::cout << " not valid " << std::endl;
10971 : }
10972 : }
10973 :
10974 0 : if ( p_typeof_ref_to != NULL )
10975 : {
10976 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10977 : {
10978 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
10979 : {
10980 0 : std::cout << "SgTypeDouble :: ";
10981 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
10982 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
10983 : }
10984 : }
10985 : else
10986 : {
10987 0 : std::cout << "SgTypeDouble :: " << std::flush;
10988 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
10989 0 : std::cout << " not valid " << std::endl;
10990 : }
10991 : }
10992 :
10993 0 : if ( p_type_kind != NULL )
10994 : {
10995 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
10996 : {
10997 0 : if ( p_type_kind->isInMemoryPool() == false )
10998 : {
10999 0 : std::cout << "SgTypeDouble :: ";
11000 0 : std::cout << " p_type_kind is not in memory pool of ";
11001 0 : std::cout << p_type_kind->class_name() << std::endl;
11002 : }
11003 : }
11004 : else
11005 : {
11006 0 : std::cout << "SgTypeDouble :: " << std::flush;
11007 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
11008 0 : std::cout << " not valid " << std::endl;
11009 : }
11010 : }
11011 :
11012 0 : if ( p_parent != NULL )
11013 : {
11014 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11015 : {
11016 0 : if ( p_parent->isInMemoryPool() == false )
11017 : {
11018 0 : std::cout << "SgTypeDouble :: ";
11019 0 : std::cout << " p_parent is not in memory pool of ";
11020 0 : std::cout << p_parent->class_name() << std::endl;
11021 : }
11022 : }
11023 : else
11024 : {
11025 0 : std::cout << "SgTypeDouble :: " << std::flush;
11026 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
11027 0 : std::cout << " not valid " << std::endl;
11028 : }
11029 : }
11030 :
11031 :
11032 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
11033 :
11034 0 : }
11035 :
11036 :
11037 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
11038 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
11039 : bool
11040 0 : SgTypeDouble::isInMemoryPool ()
11041 : {
11042 0 : typedef unsigned char* TestType;
11043 :
11044 0 : bool found = false;
11045 :
11046 0 : ROSE_ASSERT(this != NULL);
11047 :
11048 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
11049 :
11050 0 : TestType tested = (TestType) ( this ) ;
11051 :
11052 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeDouble::pools.begin();
11053 :
11054 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
11055 : // while (found == false && block < Memory_Block_List.end())
11056 0 : while ( (found == false) && (block != SgTypeDouble::pools.end()) )
11057 : {
11058 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeDouble::pool_size * sizeof(SgTypeDouble) ) ) ;
11059 0 : ++block;
11060 : }
11061 :
11062 : // Special handling for static data
11063 :
11064 :
11065 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
11066 0 : ROSE_ASSERT(found == true);
11067 :
11068 0 : return found;
11069 : }
11070 : /* #line 11071 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
11071 :
11072 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
11073 :
11074 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
11075 :
11076 : /* #line 11077 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
11077 :
11078 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
11079 :
11080 : void
11081 0 : SgTypeLongLong::checkDataMemberPointersIfInMemoryPool()
11082 : {
11083 : // ------------ checking pointers of SgTypeLongLong -------------------
11084 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
11085 :
11086 0 : if ( p_ref_to != NULL )
11087 : {
11088 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11089 : {
11090 0 : if ( p_ref_to->isInMemoryPool() == false )
11091 : {
11092 0 : std::cout << "SgTypeLongLong :: ";
11093 0 : std::cout << " p_ref_to is not in memory pool of ";
11094 0 : std::cout << p_ref_to->class_name() << std::endl;
11095 : }
11096 : }
11097 : else
11098 : {
11099 0 : std::cout << "SgTypeLongLong :: " << std::flush;
11100 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
11101 0 : std::cout << " not valid " << std::endl;
11102 : }
11103 : }
11104 :
11105 0 : if ( p_ptr_to != NULL )
11106 : {
11107 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11108 : {
11109 0 : if ( p_ptr_to->isInMemoryPool() == false )
11110 : {
11111 0 : std::cout << "SgTypeLongLong :: ";
11112 0 : std::cout << " p_ptr_to is not in memory pool of ";
11113 0 : std::cout << p_ptr_to->class_name() << std::endl;
11114 : }
11115 : }
11116 : else
11117 : {
11118 0 : std::cout << "SgTypeLongLong :: " << std::flush;
11119 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
11120 0 : std::cout << " not valid " << std::endl;
11121 : }
11122 : }
11123 :
11124 0 : if ( p_modifiers != NULL )
11125 : {
11126 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11127 : {
11128 0 : if ( p_modifiers->isInMemoryPool() == false )
11129 : {
11130 0 : std::cout << "SgTypeLongLong :: ";
11131 0 : std::cout << " p_modifiers is not in memory pool of ";
11132 0 : std::cout << p_modifiers->class_name() << std::endl;
11133 : }
11134 : }
11135 : else
11136 : {
11137 0 : std::cout << "SgTypeLongLong :: " << std::flush;
11138 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
11139 0 : std::cout << " not valid " << std::endl;
11140 : }
11141 : }
11142 :
11143 0 : if ( p_typedefs != NULL )
11144 : {
11145 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11146 : {
11147 0 : if ( p_typedefs->isInMemoryPool() == false )
11148 : {
11149 0 : std::cout << "SgTypeLongLong :: ";
11150 0 : std::cout << " p_typedefs is not in memory pool of ";
11151 0 : std::cout << p_typedefs->class_name() << std::endl;
11152 : }
11153 : }
11154 : else
11155 : {
11156 0 : std::cout << "SgTypeLongLong :: " << std::flush;
11157 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
11158 0 : std::cout << " not valid " << std::endl;
11159 : }
11160 : }
11161 :
11162 0 : if ( p_rvalue_ref_to != NULL )
11163 : {
11164 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11165 : {
11166 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
11167 : {
11168 0 : std::cout << "SgTypeLongLong :: ";
11169 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
11170 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
11171 : }
11172 : }
11173 : else
11174 : {
11175 0 : std::cout << "SgTypeLongLong :: " << std::flush;
11176 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
11177 0 : std::cout << " not valid " << std::endl;
11178 : }
11179 : }
11180 :
11181 0 : if ( p_decltype_ref_to != NULL )
11182 : {
11183 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11184 : {
11185 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
11186 : {
11187 0 : std::cout << "SgTypeLongLong :: ";
11188 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
11189 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
11190 : }
11191 : }
11192 : else
11193 : {
11194 0 : std::cout << "SgTypeLongLong :: " << std::flush;
11195 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
11196 0 : std::cout << " not valid " << std::endl;
11197 : }
11198 : }
11199 :
11200 0 : if ( p_typeof_ref_to != NULL )
11201 : {
11202 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11203 : {
11204 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
11205 : {
11206 0 : std::cout << "SgTypeLongLong :: ";
11207 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
11208 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
11209 : }
11210 : }
11211 : else
11212 : {
11213 0 : std::cout << "SgTypeLongLong :: " << std::flush;
11214 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
11215 0 : std::cout << " not valid " << std::endl;
11216 : }
11217 : }
11218 :
11219 0 : if ( p_type_kind != NULL )
11220 : {
11221 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11222 : {
11223 0 : if ( p_type_kind->isInMemoryPool() == false )
11224 : {
11225 0 : std::cout << "SgTypeLongLong :: ";
11226 0 : std::cout << " p_type_kind is not in memory pool of ";
11227 0 : std::cout << p_type_kind->class_name() << std::endl;
11228 : }
11229 : }
11230 : else
11231 : {
11232 0 : std::cout << "SgTypeLongLong :: " << std::flush;
11233 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
11234 0 : std::cout << " not valid " << std::endl;
11235 : }
11236 : }
11237 :
11238 0 : if ( p_parent != NULL )
11239 : {
11240 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11241 : {
11242 0 : if ( p_parent->isInMemoryPool() == false )
11243 : {
11244 0 : std::cout << "SgTypeLongLong :: ";
11245 0 : std::cout << " p_parent is not in memory pool of ";
11246 0 : std::cout << p_parent->class_name() << std::endl;
11247 : }
11248 : }
11249 : else
11250 : {
11251 0 : std::cout << "SgTypeLongLong :: " << std::flush;
11252 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
11253 0 : std::cout << " not valid " << std::endl;
11254 : }
11255 : }
11256 :
11257 :
11258 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
11259 :
11260 0 : }
11261 :
11262 :
11263 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
11264 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
11265 : bool
11266 0 : SgTypeLongLong::isInMemoryPool ()
11267 : {
11268 0 : typedef unsigned char* TestType;
11269 :
11270 0 : bool found = false;
11271 :
11272 0 : ROSE_ASSERT(this != NULL);
11273 :
11274 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
11275 :
11276 0 : TestType tested = (TestType) ( this ) ;
11277 :
11278 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeLongLong::pools.begin();
11279 :
11280 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
11281 : // while (found == false && block < Memory_Block_List.end())
11282 0 : while ( (found == false) && (block != SgTypeLongLong::pools.end()) )
11283 : {
11284 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeLongLong::pool_size * sizeof(SgTypeLongLong) ) ) ;
11285 0 : ++block;
11286 : }
11287 :
11288 : // Special handling for static data
11289 :
11290 :
11291 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
11292 0 : ROSE_ASSERT(found == true);
11293 :
11294 0 : return found;
11295 : }
11296 : /* #line 11297 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
11297 :
11298 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
11299 :
11300 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
11301 :
11302 : /* #line 11303 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
11303 :
11304 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
11305 :
11306 : void
11307 0 : SgTypeSignedLongLong::checkDataMemberPointersIfInMemoryPool()
11308 : {
11309 : // ------------ checking pointers of SgTypeSignedLongLong -------------------
11310 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
11311 :
11312 0 : if ( p_ref_to != NULL )
11313 : {
11314 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11315 : {
11316 0 : if ( p_ref_to->isInMemoryPool() == false )
11317 : {
11318 0 : std::cout << "SgTypeSignedLongLong :: ";
11319 0 : std::cout << " p_ref_to is not in memory pool of ";
11320 0 : std::cout << p_ref_to->class_name() << std::endl;
11321 : }
11322 : }
11323 : else
11324 : {
11325 0 : std::cout << "SgTypeSignedLongLong :: " << std::flush;
11326 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
11327 0 : std::cout << " not valid " << std::endl;
11328 : }
11329 : }
11330 :
11331 0 : if ( p_ptr_to != NULL )
11332 : {
11333 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11334 : {
11335 0 : if ( p_ptr_to->isInMemoryPool() == false )
11336 : {
11337 0 : std::cout << "SgTypeSignedLongLong :: ";
11338 0 : std::cout << " p_ptr_to is not in memory pool of ";
11339 0 : std::cout << p_ptr_to->class_name() << std::endl;
11340 : }
11341 : }
11342 : else
11343 : {
11344 0 : std::cout << "SgTypeSignedLongLong :: " << std::flush;
11345 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
11346 0 : std::cout << " not valid " << std::endl;
11347 : }
11348 : }
11349 :
11350 0 : if ( p_modifiers != NULL )
11351 : {
11352 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11353 : {
11354 0 : if ( p_modifiers->isInMemoryPool() == false )
11355 : {
11356 0 : std::cout << "SgTypeSignedLongLong :: ";
11357 0 : std::cout << " p_modifiers is not in memory pool of ";
11358 0 : std::cout << p_modifiers->class_name() << std::endl;
11359 : }
11360 : }
11361 : else
11362 : {
11363 0 : std::cout << "SgTypeSignedLongLong :: " << std::flush;
11364 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
11365 0 : std::cout << " not valid " << std::endl;
11366 : }
11367 : }
11368 :
11369 0 : if ( p_typedefs != NULL )
11370 : {
11371 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11372 : {
11373 0 : if ( p_typedefs->isInMemoryPool() == false )
11374 : {
11375 0 : std::cout << "SgTypeSignedLongLong :: ";
11376 0 : std::cout << " p_typedefs is not in memory pool of ";
11377 0 : std::cout << p_typedefs->class_name() << std::endl;
11378 : }
11379 : }
11380 : else
11381 : {
11382 0 : std::cout << "SgTypeSignedLongLong :: " << std::flush;
11383 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
11384 0 : std::cout << " not valid " << std::endl;
11385 : }
11386 : }
11387 :
11388 0 : if ( p_rvalue_ref_to != NULL )
11389 : {
11390 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11391 : {
11392 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
11393 : {
11394 0 : std::cout << "SgTypeSignedLongLong :: ";
11395 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
11396 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
11397 : }
11398 : }
11399 : else
11400 : {
11401 0 : std::cout << "SgTypeSignedLongLong :: " << std::flush;
11402 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
11403 0 : std::cout << " not valid " << std::endl;
11404 : }
11405 : }
11406 :
11407 0 : if ( p_decltype_ref_to != NULL )
11408 : {
11409 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11410 : {
11411 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
11412 : {
11413 0 : std::cout << "SgTypeSignedLongLong :: ";
11414 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
11415 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
11416 : }
11417 : }
11418 : else
11419 : {
11420 0 : std::cout << "SgTypeSignedLongLong :: " << std::flush;
11421 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
11422 0 : std::cout << " not valid " << std::endl;
11423 : }
11424 : }
11425 :
11426 0 : if ( p_typeof_ref_to != NULL )
11427 : {
11428 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11429 : {
11430 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
11431 : {
11432 0 : std::cout << "SgTypeSignedLongLong :: ";
11433 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
11434 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
11435 : }
11436 : }
11437 : else
11438 : {
11439 0 : std::cout << "SgTypeSignedLongLong :: " << std::flush;
11440 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
11441 0 : std::cout << " not valid " << std::endl;
11442 : }
11443 : }
11444 :
11445 0 : if ( p_type_kind != NULL )
11446 : {
11447 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11448 : {
11449 0 : if ( p_type_kind->isInMemoryPool() == false )
11450 : {
11451 0 : std::cout << "SgTypeSignedLongLong :: ";
11452 0 : std::cout << " p_type_kind is not in memory pool of ";
11453 0 : std::cout << p_type_kind->class_name() << std::endl;
11454 : }
11455 : }
11456 : else
11457 : {
11458 0 : std::cout << "SgTypeSignedLongLong :: " << std::flush;
11459 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
11460 0 : std::cout << " not valid " << std::endl;
11461 : }
11462 : }
11463 :
11464 0 : if ( p_parent != NULL )
11465 : {
11466 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11467 : {
11468 0 : if ( p_parent->isInMemoryPool() == false )
11469 : {
11470 0 : std::cout << "SgTypeSignedLongLong :: ";
11471 0 : std::cout << " p_parent is not in memory pool of ";
11472 0 : std::cout << p_parent->class_name() << std::endl;
11473 : }
11474 : }
11475 : else
11476 : {
11477 0 : std::cout << "SgTypeSignedLongLong :: " << std::flush;
11478 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
11479 0 : std::cout << " not valid " << std::endl;
11480 : }
11481 : }
11482 :
11483 :
11484 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
11485 :
11486 0 : }
11487 :
11488 :
11489 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
11490 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
11491 : bool
11492 0 : SgTypeSignedLongLong::isInMemoryPool ()
11493 : {
11494 0 : typedef unsigned char* TestType;
11495 :
11496 0 : bool found = false;
11497 :
11498 0 : ROSE_ASSERT(this != NULL);
11499 :
11500 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
11501 :
11502 0 : TestType tested = (TestType) ( this ) ;
11503 :
11504 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeSignedLongLong::pools.begin();
11505 :
11506 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
11507 : // while (found == false && block < Memory_Block_List.end())
11508 0 : while ( (found == false) && (block != SgTypeSignedLongLong::pools.end()) )
11509 : {
11510 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeSignedLongLong::pool_size * sizeof(SgTypeSignedLongLong) ) ) ;
11511 0 : ++block;
11512 : }
11513 :
11514 : // Special handling for static data
11515 :
11516 :
11517 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
11518 0 : ROSE_ASSERT(found == true);
11519 :
11520 0 : return found;
11521 : }
11522 : /* #line 11523 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
11523 :
11524 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
11525 :
11526 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
11527 :
11528 : /* #line 11529 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
11529 :
11530 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
11531 :
11532 : void
11533 0 : SgTypeUnsignedLongLong::checkDataMemberPointersIfInMemoryPool()
11534 : {
11535 : // ------------ checking pointers of SgTypeUnsignedLongLong -------------------
11536 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
11537 :
11538 0 : if ( p_ref_to != NULL )
11539 : {
11540 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11541 : {
11542 0 : if ( p_ref_to->isInMemoryPool() == false )
11543 : {
11544 0 : std::cout << "SgTypeUnsignedLongLong :: ";
11545 0 : std::cout << " p_ref_to is not in memory pool of ";
11546 0 : std::cout << p_ref_to->class_name() << std::endl;
11547 : }
11548 : }
11549 : else
11550 : {
11551 0 : std::cout << "SgTypeUnsignedLongLong :: " << std::flush;
11552 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
11553 0 : std::cout << " not valid " << std::endl;
11554 : }
11555 : }
11556 :
11557 0 : if ( p_ptr_to != NULL )
11558 : {
11559 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11560 : {
11561 0 : if ( p_ptr_to->isInMemoryPool() == false )
11562 : {
11563 0 : std::cout << "SgTypeUnsignedLongLong :: ";
11564 0 : std::cout << " p_ptr_to is not in memory pool of ";
11565 0 : std::cout << p_ptr_to->class_name() << std::endl;
11566 : }
11567 : }
11568 : else
11569 : {
11570 0 : std::cout << "SgTypeUnsignedLongLong :: " << std::flush;
11571 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
11572 0 : std::cout << " not valid " << std::endl;
11573 : }
11574 : }
11575 :
11576 0 : if ( p_modifiers != NULL )
11577 : {
11578 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11579 : {
11580 0 : if ( p_modifiers->isInMemoryPool() == false )
11581 : {
11582 0 : std::cout << "SgTypeUnsignedLongLong :: ";
11583 0 : std::cout << " p_modifiers is not in memory pool of ";
11584 0 : std::cout << p_modifiers->class_name() << std::endl;
11585 : }
11586 : }
11587 : else
11588 : {
11589 0 : std::cout << "SgTypeUnsignedLongLong :: " << std::flush;
11590 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
11591 0 : std::cout << " not valid " << std::endl;
11592 : }
11593 : }
11594 :
11595 0 : if ( p_typedefs != NULL )
11596 : {
11597 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11598 : {
11599 0 : if ( p_typedefs->isInMemoryPool() == false )
11600 : {
11601 0 : std::cout << "SgTypeUnsignedLongLong :: ";
11602 0 : std::cout << " p_typedefs is not in memory pool of ";
11603 0 : std::cout << p_typedefs->class_name() << std::endl;
11604 : }
11605 : }
11606 : else
11607 : {
11608 0 : std::cout << "SgTypeUnsignedLongLong :: " << std::flush;
11609 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
11610 0 : std::cout << " not valid " << std::endl;
11611 : }
11612 : }
11613 :
11614 0 : if ( p_rvalue_ref_to != NULL )
11615 : {
11616 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11617 : {
11618 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
11619 : {
11620 0 : std::cout << "SgTypeUnsignedLongLong :: ";
11621 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
11622 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
11623 : }
11624 : }
11625 : else
11626 : {
11627 0 : std::cout << "SgTypeUnsignedLongLong :: " << std::flush;
11628 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
11629 0 : std::cout << " not valid " << std::endl;
11630 : }
11631 : }
11632 :
11633 0 : if ( p_decltype_ref_to != NULL )
11634 : {
11635 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11636 : {
11637 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
11638 : {
11639 0 : std::cout << "SgTypeUnsignedLongLong :: ";
11640 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
11641 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
11642 : }
11643 : }
11644 : else
11645 : {
11646 0 : std::cout << "SgTypeUnsignedLongLong :: " << std::flush;
11647 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
11648 0 : std::cout << " not valid " << std::endl;
11649 : }
11650 : }
11651 :
11652 0 : if ( p_typeof_ref_to != NULL )
11653 : {
11654 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11655 : {
11656 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
11657 : {
11658 0 : std::cout << "SgTypeUnsignedLongLong :: ";
11659 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
11660 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
11661 : }
11662 : }
11663 : else
11664 : {
11665 0 : std::cout << "SgTypeUnsignedLongLong :: " << std::flush;
11666 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
11667 0 : std::cout << " not valid " << std::endl;
11668 : }
11669 : }
11670 :
11671 0 : if ( p_type_kind != NULL )
11672 : {
11673 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11674 : {
11675 0 : if ( p_type_kind->isInMemoryPool() == false )
11676 : {
11677 0 : std::cout << "SgTypeUnsignedLongLong :: ";
11678 0 : std::cout << " p_type_kind is not in memory pool of ";
11679 0 : std::cout << p_type_kind->class_name() << std::endl;
11680 : }
11681 : }
11682 : else
11683 : {
11684 0 : std::cout << "SgTypeUnsignedLongLong :: " << std::flush;
11685 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
11686 0 : std::cout << " not valid " << std::endl;
11687 : }
11688 : }
11689 :
11690 0 : if ( p_parent != NULL )
11691 : {
11692 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11693 : {
11694 0 : if ( p_parent->isInMemoryPool() == false )
11695 : {
11696 0 : std::cout << "SgTypeUnsignedLongLong :: ";
11697 0 : std::cout << " p_parent is not in memory pool of ";
11698 0 : std::cout << p_parent->class_name() << std::endl;
11699 : }
11700 : }
11701 : else
11702 : {
11703 0 : std::cout << "SgTypeUnsignedLongLong :: " << std::flush;
11704 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
11705 0 : std::cout << " not valid " << std::endl;
11706 : }
11707 : }
11708 :
11709 :
11710 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
11711 :
11712 0 : }
11713 :
11714 :
11715 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
11716 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
11717 : bool
11718 0 : SgTypeUnsignedLongLong::isInMemoryPool ()
11719 : {
11720 0 : typedef unsigned char* TestType;
11721 :
11722 0 : bool found = false;
11723 :
11724 0 : ROSE_ASSERT(this != NULL);
11725 :
11726 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
11727 :
11728 0 : TestType tested = (TestType) ( this ) ;
11729 :
11730 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeUnsignedLongLong::pools.begin();
11731 :
11732 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
11733 : // while (found == false && block < Memory_Block_List.end())
11734 0 : while ( (found == false) && (block != SgTypeUnsignedLongLong::pools.end()) )
11735 : {
11736 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeUnsignedLongLong::pool_size * sizeof(SgTypeUnsignedLongLong) ) ) ;
11737 0 : ++block;
11738 : }
11739 :
11740 : // Special handling for static data
11741 :
11742 :
11743 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
11744 0 : ROSE_ASSERT(found == true);
11745 :
11746 0 : return found;
11747 : }
11748 : /* #line 11749 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
11749 :
11750 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
11751 :
11752 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
11753 :
11754 : /* #line 11755 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
11755 :
11756 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
11757 :
11758 : void
11759 0 : SgTypeSigned128bitInteger::checkDataMemberPointersIfInMemoryPool()
11760 : {
11761 : // ------------ checking pointers of SgTypeSigned128bitInteger -------------------
11762 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
11763 :
11764 0 : if ( p_ref_to != NULL )
11765 : {
11766 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11767 : {
11768 0 : if ( p_ref_to->isInMemoryPool() == false )
11769 : {
11770 0 : std::cout << "SgTypeSigned128bitInteger :: ";
11771 0 : std::cout << " p_ref_to is not in memory pool of ";
11772 0 : std::cout << p_ref_to->class_name() << std::endl;
11773 : }
11774 : }
11775 : else
11776 : {
11777 0 : std::cout << "SgTypeSigned128bitInteger :: " << std::flush;
11778 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
11779 0 : std::cout << " not valid " << std::endl;
11780 : }
11781 : }
11782 :
11783 0 : if ( p_ptr_to != NULL )
11784 : {
11785 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11786 : {
11787 0 : if ( p_ptr_to->isInMemoryPool() == false )
11788 : {
11789 0 : std::cout << "SgTypeSigned128bitInteger :: ";
11790 0 : std::cout << " p_ptr_to is not in memory pool of ";
11791 0 : std::cout << p_ptr_to->class_name() << std::endl;
11792 : }
11793 : }
11794 : else
11795 : {
11796 0 : std::cout << "SgTypeSigned128bitInteger :: " << std::flush;
11797 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
11798 0 : std::cout << " not valid " << std::endl;
11799 : }
11800 : }
11801 :
11802 0 : if ( p_modifiers != NULL )
11803 : {
11804 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11805 : {
11806 0 : if ( p_modifiers->isInMemoryPool() == false )
11807 : {
11808 0 : std::cout << "SgTypeSigned128bitInteger :: ";
11809 0 : std::cout << " p_modifiers is not in memory pool of ";
11810 0 : std::cout << p_modifiers->class_name() << std::endl;
11811 : }
11812 : }
11813 : else
11814 : {
11815 0 : std::cout << "SgTypeSigned128bitInteger :: " << std::flush;
11816 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
11817 0 : std::cout << " not valid " << std::endl;
11818 : }
11819 : }
11820 :
11821 0 : if ( p_typedefs != NULL )
11822 : {
11823 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11824 : {
11825 0 : if ( p_typedefs->isInMemoryPool() == false )
11826 : {
11827 0 : std::cout << "SgTypeSigned128bitInteger :: ";
11828 0 : std::cout << " p_typedefs is not in memory pool of ";
11829 0 : std::cout << p_typedefs->class_name() << std::endl;
11830 : }
11831 : }
11832 : else
11833 : {
11834 0 : std::cout << "SgTypeSigned128bitInteger :: " << std::flush;
11835 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
11836 0 : std::cout << " not valid " << std::endl;
11837 : }
11838 : }
11839 :
11840 0 : if ( p_rvalue_ref_to != NULL )
11841 : {
11842 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11843 : {
11844 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
11845 : {
11846 0 : std::cout << "SgTypeSigned128bitInteger :: ";
11847 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
11848 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
11849 : }
11850 : }
11851 : else
11852 : {
11853 0 : std::cout << "SgTypeSigned128bitInteger :: " << std::flush;
11854 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
11855 0 : std::cout << " not valid " << std::endl;
11856 : }
11857 : }
11858 :
11859 0 : if ( p_decltype_ref_to != NULL )
11860 : {
11861 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11862 : {
11863 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
11864 : {
11865 0 : std::cout << "SgTypeSigned128bitInteger :: ";
11866 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
11867 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
11868 : }
11869 : }
11870 : else
11871 : {
11872 0 : std::cout << "SgTypeSigned128bitInteger :: " << std::flush;
11873 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
11874 0 : std::cout << " not valid " << std::endl;
11875 : }
11876 : }
11877 :
11878 0 : if ( p_typeof_ref_to != NULL )
11879 : {
11880 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11881 : {
11882 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
11883 : {
11884 0 : std::cout << "SgTypeSigned128bitInteger :: ";
11885 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
11886 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
11887 : }
11888 : }
11889 : else
11890 : {
11891 0 : std::cout << "SgTypeSigned128bitInteger :: " << std::flush;
11892 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
11893 0 : std::cout << " not valid " << std::endl;
11894 : }
11895 : }
11896 :
11897 0 : if ( p_type_kind != NULL )
11898 : {
11899 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11900 : {
11901 0 : if ( p_type_kind->isInMemoryPool() == false )
11902 : {
11903 0 : std::cout << "SgTypeSigned128bitInteger :: ";
11904 0 : std::cout << " p_type_kind is not in memory pool of ";
11905 0 : std::cout << p_type_kind->class_name() << std::endl;
11906 : }
11907 : }
11908 : else
11909 : {
11910 0 : std::cout << "SgTypeSigned128bitInteger :: " << std::flush;
11911 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
11912 0 : std::cout << " not valid " << std::endl;
11913 : }
11914 : }
11915 :
11916 0 : if ( p_parent != NULL )
11917 : {
11918 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11919 : {
11920 0 : if ( p_parent->isInMemoryPool() == false )
11921 : {
11922 0 : std::cout << "SgTypeSigned128bitInteger :: ";
11923 0 : std::cout << " p_parent is not in memory pool of ";
11924 0 : std::cout << p_parent->class_name() << std::endl;
11925 : }
11926 : }
11927 : else
11928 : {
11929 0 : std::cout << "SgTypeSigned128bitInteger :: " << std::flush;
11930 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
11931 0 : std::cout << " not valid " << std::endl;
11932 : }
11933 : }
11934 :
11935 :
11936 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
11937 :
11938 0 : }
11939 :
11940 :
11941 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
11942 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
11943 : bool
11944 0 : SgTypeSigned128bitInteger::isInMemoryPool ()
11945 : {
11946 0 : typedef unsigned char* TestType;
11947 :
11948 0 : bool found = false;
11949 :
11950 0 : ROSE_ASSERT(this != NULL);
11951 :
11952 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
11953 :
11954 0 : TestType tested = (TestType) ( this ) ;
11955 :
11956 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeSigned128bitInteger::pools.begin();
11957 :
11958 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
11959 : // while (found == false && block < Memory_Block_List.end())
11960 0 : while ( (found == false) && (block != SgTypeSigned128bitInteger::pools.end()) )
11961 : {
11962 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeSigned128bitInteger::pool_size * sizeof(SgTypeSigned128bitInteger) ) ) ;
11963 0 : ++block;
11964 : }
11965 :
11966 : // Special handling for static data
11967 :
11968 :
11969 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
11970 0 : ROSE_ASSERT(found == true);
11971 :
11972 0 : return found;
11973 : }
11974 : /* #line 11975 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
11975 :
11976 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
11977 :
11978 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
11979 :
11980 : /* #line 11981 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
11981 :
11982 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
11983 :
11984 : void
11985 0 : SgTypeUnsigned128bitInteger::checkDataMemberPointersIfInMemoryPool()
11986 : {
11987 : // ------------ checking pointers of SgTypeUnsigned128bitInteger -------------------
11988 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
11989 :
11990 0 : if ( p_ref_to != NULL )
11991 : {
11992 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
11993 : {
11994 0 : if ( p_ref_to->isInMemoryPool() == false )
11995 : {
11996 0 : std::cout << "SgTypeUnsigned128bitInteger :: ";
11997 0 : std::cout << " p_ref_to is not in memory pool of ";
11998 0 : std::cout << p_ref_to->class_name() << std::endl;
11999 : }
12000 : }
12001 : else
12002 : {
12003 0 : std::cout << "SgTypeUnsigned128bitInteger :: " << std::flush;
12004 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
12005 0 : std::cout << " not valid " << std::endl;
12006 : }
12007 : }
12008 :
12009 0 : if ( p_ptr_to != NULL )
12010 : {
12011 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12012 : {
12013 0 : if ( p_ptr_to->isInMemoryPool() == false )
12014 : {
12015 0 : std::cout << "SgTypeUnsigned128bitInteger :: ";
12016 0 : std::cout << " p_ptr_to is not in memory pool of ";
12017 0 : std::cout << p_ptr_to->class_name() << std::endl;
12018 : }
12019 : }
12020 : else
12021 : {
12022 0 : std::cout << "SgTypeUnsigned128bitInteger :: " << std::flush;
12023 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
12024 0 : std::cout << " not valid " << std::endl;
12025 : }
12026 : }
12027 :
12028 0 : if ( p_modifiers != NULL )
12029 : {
12030 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12031 : {
12032 0 : if ( p_modifiers->isInMemoryPool() == false )
12033 : {
12034 0 : std::cout << "SgTypeUnsigned128bitInteger :: ";
12035 0 : std::cout << " p_modifiers is not in memory pool of ";
12036 0 : std::cout << p_modifiers->class_name() << std::endl;
12037 : }
12038 : }
12039 : else
12040 : {
12041 0 : std::cout << "SgTypeUnsigned128bitInteger :: " << std::flush;
12042 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
12043 0 : std::cout << " not valid " << std::endl;
12044 : }
12045 : }
12046 :
12047 0 : if ( p_typedefs != NULL )
12048 : {
12049 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12050 : {
12051 0 : if ( p_typedefs->isInMemoryPool() == false )
12052 : {
12053 0 : std::cout << "SgTypeUnsigned128bitInteger :: ";
12054 0 : std::cout << " p_typedefs is not in memory pool of ";
12055 0 : std::cout << p_typedefs->class_name() << std::endl;
12056 : }
12057 : }
12058 : else
12059 : {
12060 0 : std::cout << "SgTypeUnsigned128bitInteger :: " << std::flush;
12061 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
12062 0 : std::cout << " not valid " << std::endl;
12063 : }
12064 : }
12065 :
12066 0 : if ( p_rvalue_ref_to != NULL )
12067 : {
12068 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12069 : {
12070 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
12071 : {
12072 0 : std::cout << "SgTypeUnsigned128bitInteger :: ";
12073 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
12074 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
12075 : }
12076 : }
12077 : else
12078 : {
12079 0 : std::cout << "SgTypeUnsigned128bitInteger :: " << std::flush;
12080 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
12081 0 : std::cout << " not valid " << std::endl;
12082 : }
12083 : }
12084 :
12085 0 : if ( p_decltype_ref_to != NULL )
12086 : {
12087 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12088 : {
12089 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
12090 : {
12091 0 : std::cout << "SgTypeUnsigned128bitInteger :: ";
12092 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
12093 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
12094 : }
12095 : }
12096 : else
12097 : {
12098 0 : std::cout << "SgTypeUnsigned128bitInteger :: " << std::flush;
12099 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
12100 0 : std::cout << " not valid " << std::endl;
12101 : }
12102 : }
12103 :
12104 0 : if ( p_typeof_ref_to != NULL )
12105 : {
12106 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12107 : {
12108 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
12109 : {
12110 0 : std::cout << "SgTypeUnsigned128bitInteger :: ";
12111 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
12112 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
12113 : }
12114 : }
12115 : else
12116 : {
12117 0 : std::cout << "SgTypeUnsigned128bitInteger :: " << std::flush;
12118 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
12119 0 : std::cout << " not valid " << std::endl;
12120 : }
12121 : }
12122 :
12123 0 : if ( p_type_kind != NULL )
12124 : {
12125 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12126 : {
12127 0 : if ( p_type_kind->isInMemoryPool() == false )
12128 : {
12129 0 : std::cout << "SgTypeUnsigned128bitInteger :: ";
12130 0 : std::cout << " p_type_kind is not in memory pool of ";
12131 0 : std::cout << p_type_kind->class_name() << std::endl;
12132 : }
12133 : }
12134 : else
12135 : {
12136 0 : std::cout << "SgTypeUnsigned128bitInteger :: " << std::flush;
12137 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
12138 0 : std::cout << " not valid " << std::endl;
12139 : }
12140 : }
12141 :
12142 0 : if ( p_parent != NULL )
12143 : {
12144 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12145 : {
12146 0 : if ( p_parent->isInMemoryPool() == false )
12147 : {
12148 0 : std::cout << "SgTypeUnsigned128bitInteger :: ";
12149 0 : std::cout << " p_parent is not in memory pool of ";
12150 0 : std::cout << p_parent->class_name() << std::endl;
12151 : }
12152 : }
12153 : else
12154 : {
12155 0 : std::cout << "SgTypeUnsigned128bitInteger :: " << std::flush;
12156 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
12157 0 : std::cout << " not valid " << std::endl;
12158 : }
12159 : }
12160 :
12161 :
12162 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
12163 :
12164 0 : }
12165 :
12166 :
12167 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
12168 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
12169 : bool
12170 0 : SgTypeUnsigned128bitInteger::isInMemoryPool ()
12171 : {
12172 0 : typedef unsigned char* TestType;
12173 :
12174 0 : bool found = false;
12175 :
12176 0 : ROSE_ASSERT(this != NULL);
12177 :
12178 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
12179 :
12180 0 : TestType tested = (TestType) ( this ) ;
12181 :
12182 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeUnsigned128bitInteger::pools.begin();
12183 :
12184 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
12185 : // while (found == false && block < Memory_Block_List.end())
12186 0 : while ( (found == false) && (block != SgTypeUnsigned128bitInteger::pools.end()) )
12187 : {
12188 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeUnsigned128bitInteger::pool_size * sizeof(SgTypeUnsigned128bitInteger) ) ) ;
12189 0 : ++block;
12190 : }
12191 :
12192 : // Special handling for static data
12193 :
12194 :
12195 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
12196 0 : ROSE_ASSERT(found == true);
12197 :
12198 0 : return found;
12199 : }
12200 : /* #line 12201 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
12201 :
12202 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
12203 :
12204 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
12205 :
12206 : /* #line 12207 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
12207 :
12208 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
12209 :
12210 : void
12211 0 : SgTypeFloat80::checkDataMemberPointersIfInMemoryPool()
12212 : {
12213 : // ------------ checking pointers of SgTypeFloat80 -------------------
12214 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
12215 :
12216 0 : if ( p_ref_to != NULL )
12217 : {
12218 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12219 : {
12220 0 : if ( p_ref_to->isInMemoryPool() == false )
12221 : {
12222 0 : std::cout << "SgTypeFloat80 :: ";
12223 0 : std::cout << " p_ref_to is not in memory pool of ";
12224 0 : std::cout << p_ref_to->class_name() << std::endl;
12225 : }
12226 : }
12227 : else
12228 : {
12229 0 : std::cout << "SgTypeFloat80 :: " << std::flush;
12230 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
12231 0 : std::cout << " not valid " << std::endl;
12232 : }
12233 : }
12234 :
12235 0 : if ( p_ptr_to != NULL )
12236 : {
12237 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12238 : {
12239 0 : if ( p_ptr_to->isInMemoryPool() == false )
12240 : {
12241 0 : std::cout << "SgTypeFloat80 :: ";
12242 0 : std::cout << " p_ptr_to is not in memory pool of ";
12243 0 : std::cout << p_ptr_to->class_name() << std::endl;
12244 : }
12245 : }
12246 : else
12247 : {
12248 0 : std::cout << "SgTypeFloat80 :: " << std::flush;
12249 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
12250 0 : std::cout << " not valid " << std::endl;
12251 : }
12252 : }
12253 :
12254 0 : if ( p_modifiers != NULL )
12255 : {
12256 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12257 : {
12258 0 : if ( p_modifiers->isInMemoryPool() == false )
12259 : {
12260 0 : std::cout << "SgTypeFloat80 :: ";
12261 0 : std::cout << " p_modifiers is not in memory pool of ";
12262 0 : std::cout << p_modifiers->class_name() << std::endl;
12263 : }
12264 : }
12265 : else
12266 : {
12267 0 : std::cout << "SgTypeFloat80 :: " << std::flush;
12268 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
12269 0 : std::cout << " not valid " << std::endl;
12270 : }
12271 : }
12272 :
12273 0 : if ( p_typedefs != NULL )
12274 : {
12275 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12276 : {
12277 0 : if ( p_typedefs->isInMemoryPool() == false )
12278 : {
12279 0 : std::cout << "SgTypeFloat80 :: ";
12280 0 : std::cout << " p_typedefs is not in memory pool of ";
12281 0 : std::cout << p_typedefs->class_name() << std::endl;
12282 : }
12283 : }
12284 : else
12285 : {
12286 0 : std::cout << "SgTypeFloat80 :: " << std::flush;
12287 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
12288 0 : std::cout << " not valid " << std::endl;
12289 : }
12290 : }
12291 :
12292 0 : if ( p_rvalue_ref_to != NULL )
12293 : {
12294 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12295 : {
12296 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
12297 : {
12298 0 : std::cout << "SgTypeFloat80 :: ";
12299 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
12300 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
12301 : }
12302 : }
12303 : else
12304 : {
12305 0 : std::cout << "SgTypeFloat80 :: " << std::flush;
12306 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
12307 0 : std::cout << " not valid " << std::endl;
12308 : }
12309 : }
12310 :
12311 0 : if ( p_decltype_ref_to != NULL )
12312 : {
12313 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12314 : {
12315 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
12316 : {
12317 0 : std::cout << "SgTypeFloat80 :: ";
12318 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
12319 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
12320 : }
12321 : }
12322 : else
12323 : {
12324 0 : std::cout << "SgTypeFloat80 :: " << std::flush;
12325 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
12326 0 : std::cout << " not valid " << std::endl;
12327 : }
12328 : }
12329 :
12330 0 : if ( p_typeof_ref_to != NULL )
12331 : {
12332 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12333 : {
12334 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
12335 : {
12336 0 : std::cout << "SgTypeFloat80 :: ";
12337 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
12338 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
12339 : }
12340 : }
12341 : else
12342 : {
12343 0 : std::cout << "SgTypeFloat80 :: " << std::flush;
12344 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
12345 0 : std::cout << " not valid " << std::endl;
12346 : }
12347 : }
12348 :
12349 0 : if ( p_type_kind != NULL )
12350 : {
12351 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12352 : {
12353 0 : if ( p_type_kind->isInMemoryPool() == false )
12354 : {
12355 0 : std::cout << "SgTypeFloat80 :: ";
12356 0 : std::cout << " p_type_kind is not in memory pool of ";
12357 0 : std::cout << p_type_kind->class_name() << std::endl;
12358 : }
12359 : }
12360 : else
12361 : {
12362 0 : std::cout << "SgTypeFloat80 :: " << std::flush;
12363 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
12364 0 : std::cout << " not valid " << std::endl;
12365 : }
12366 : }
12367 :
12368 0 : if ( p_parent != NULL )
12369 : {
12370 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12371 : {
12372 0 : if ( p_parent->isInMemoryPool() == false )
12373 : {
12374 0 : std::cout << "SgTypeFloat80 :: ";
12375 0 : std::cout << " p_parent is not in memory pool of ";
12376 0 : std::cout << p_parent->class_name() << std::endl;
12377 : }
12378 : }
12379 : else
12380 : {
12381 0 : std::cout << "SgTypeFloat80 :: " << std::flush;
12382 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
12383 0 : std::cout << " not valid " << std::endl;
12384 : }
12385 : }
12386 :
12387 :
12388 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
12389 :
12390 0 : }
12391 :
12392 :
12393 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
12394 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
12395 : bool
12396 0 : SgTypeFloat80::isInMemoryPool ()
12397 : {
12398 0 : typedef unsigned char* TestType;
12399 :
12400 0 : bool found = false;
12401 :
12402 0 : ROSE_ASSERT(this != NULL);
12403 :
12404 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
12405 :
12406 0 : TestType tested = (TestType) ( this ) ;
12407 :
12408 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeFloat80::pools.begin();
12409 :
12410 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
12411 : // while (found == false && block < Memory_Block_List.end())
12412 0 : while ( (found == false) && (block != SgTypeFloat80::pools.end()) )
12413 : {
12414 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeFloat80::pool_size * sizeof(SgTypeFloat80) ) ) ;
12415 0 : ++block;
12416 : }
12417 :
12418 : // Special handling for static data
12419 :
12420 :
12421 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
12422 0 : ROSE_ASSERT(found == true);
12423 :
12424 0 : return found;
12425 : }
12426 : /* #line 12427 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
12427 :
12428 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
12429 :
12430 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
12431 :
12432 : /* #line 12433 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
12433 :
12434 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
12435 :
12436 : void
12437 0 : SgTypeLongDouble::checkDataMemberPointersIfInMemoryPool()
12438 : {
12439 : // ------------ checking pointers of SgTypeLongDouble -------------------
12440 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
12441 :
12442 0 : if ( p_ref_to != NULL )
12443 : {
12444 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12445 : {
12446 0 : if ( p_ref_to->isInMemoryPool() == false )
12447 : {
12448 0 : std::cout << "SgTypeLongDouble :: ";
12449 0 : std::cout << " p_ref_to is not in memory pool of ";
12450 0 : std::cout << p_ref_to->class_name() << std::endl;
12451 : }
12452 : }
12453 : else
12454 : {
12455 0 : std::cout << "SgTypeLongDouble :: " << std::flush;
12456 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
12457 0 : std::cout << " not valid " << std::endl;
12458 : }
12459 : }
12460 :
12461 0 : if ( p_ptr_to != NULL )
12462 : {
12463 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12464 : {
12465 0 : if ( p_ptr_to->isInMemoryPool() == false )
12466 : {
12467 0 : std::cout << "SgTypeLongDouble :: ";
12468 0 : std::cout << " p_ptr_to is not in memory pool of ";
12469 0 : std::cout << p_ptr_to->class_name() << std::endl;
12470 : }
12471 : }
12472 : else
12473 : {
12474 0 : std::cout << "SgTypeLongDouble :: " << std::flush;
12475 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
12476 0 : std::cout << " not valid " << std::endl;
12477 : }
12478 : }
12479 :
12480 0 : if ( p_modifiers != NULL )
12481 : {
12482 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12483 : {
12484 0 : if ( p_modifiers->isInMemoryPool() == false )
12485 : {
12486 0 : std::cout << "SgTypeLongDouble :: ";
12487 0 : std::cout << " p_modifiers is not in memory pool of ";
12488 0 : std::cout << p_modifiers->class_name() << std::endl;
12489 : }
12490 : }
12491 : else
12492 : {
12493 0 : std::cout << "SgTypeLongDouble :: " << std::flush;
12494 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
12495 0 : std::cout << " not valid " << std::endl;
12496 : }
12497 : }
12498 :
12499 0 : if ( p_typedefs != NULL )
12500 : {
12501 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12502 : {
12503 0 : if ( p_typedefs->isInMemoryPool() == false )
12504 : {
12505 0 : std::cout << "SgTypeLongDouble :: ";
12506 0 : std::cout << " p_typedefs is not in memory pool of ";
12507 0 : std::cout << p_typedefs->class_name() << std::endl;
12508 : }
12509 : }
12510 : else
12511 : {
12512 0 : std::cout << "SgTypeLongDouble :: " << std::flush;
12513 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
12514 0 : std::cout << " not valid " << std::endl;
12515 : }
12516 : }
12517 :
12518 0 : if ( p_rvalue_ref_to != NULL )
12519 : {
12520 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12521 : {
12522 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
12523 : {
12524 0 : std::cout << "SgTypeLongDouble :: ";
12525 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
12526 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
12527 : }
12528 : }
12529 : else
12530 : {
12531 0 : std::cout << "SgTypeLongDouble :: " << std::flush;
12532 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
12533 0 : std::cout << " not valid " << std::endl;
12534 : }
12535 : }
12536 :
12537 0 : if ( p_decltype_ref_to != NULL )
12538 : {
12539 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12540 : {
12541 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
12542 : {
12543 0 : std::cout << "SgTypeLongDouble :: ";
12544 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
12545 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
12546 : }
12547 : }
12548 : else
12549 : {
12550 0 : std::cout << "SgTypeLongDouble :: " << std::flush;
12551 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
12552 0 : std::cout << " not valid " << std::endl;
12553 : }
12554 : }
12555 :
12556 0 : if ( p_typeof_ref_to != NULL )
12557 : {
12558 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12559 : {
12560 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
12561 : {
12562 0 : std::cout << "SgTypeLongDouble :: ";
12563 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
12564 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
12565 : }
12566 : }
12567 : else
12568 : {
12569 0 : std::cout << "SgTypeLongDouble :: " << std::flush;
12570 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
12571 0 : std::cout << " not valid " << std::endl;
12572 : }
12573 : }
12574 :
12575 0 : if ( p_type_kind != NULL )
12576 : {
12577 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12578 : {
12579 0 : if ( p_type_kind->isInMemoryPool() == false )
12580 : {
12581 0 : std::cout << "SgTypeLongDouble :: ";
12582 0 : std::cout << " p_type_kind is not in memory pool of ";
12583 0 : std::cout << p_type_kind->class_name() << std::endl;
12584 : }
12585 : }
12586 : else
12587 : {
12588 0 : std::cout << "SgTypeLongDouble :: " << std::flush;
12589 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
12590 0 : std::cout << " not valid " << std::endl;
12591 : }
12592 : }
12593 :
12594 0 : if ( p_parent != NULL )
12595 : {
12596 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12597 : {
12598 0 : if ( p_parent->isInMemoryPool() == false )
12599 : {
12600 0 : std::cout << "SgTypeLongDouble :: ";
12601 0 : std::cout << " p_parent is not in memory pool of ";
12602 0 : std::cout << p_parent->class_name() << std::endl;
12603 : }
12604 : }
12605 : else
12606 : {
12607 0 : std::cout << "SgTypeLongDouble :: " << std::flush;
12608 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
12609 0 : std::cout << " not valid " << std::endl;
12610 : }
12611 : }
12612 :
12613 :
12614 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
12615 :
12616 0 : }
12617 :
12618 :
12619 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
12620 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
12621 : bool
12622 0 : SgTypeLongDouble::isInMemoryPool ()
12623 : {
12624 0 : typedef unsigned char* TestType;
12625 :
12626 0 : bool found = false;
12627 :
12628 0 : ROSE_ASSERT(this != NULL);
12629 :
12630 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
12631 :
12632 0 : TestType tested = (TestType) ( this ) ;
12633 :
12634 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeLongDouble::pools.begin();
12635 :
12636 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
12637 : // while (found == false && block < Memory_Block_List.end())
12638 0 : while ( (found == false) && (block != SgTypeLongDouble::pools.end()) )
12639 : {
12640 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeLongDouble::pool_size * sizeof(SgTypeLongDouble) ) ) ;
12641 0 : ++block;
12642 : }
12643 :
12644 : // Special handling for static data
12645 :
12646 :
12647 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
12648 0 : ROSE_ASSERT(found == true);
12649 :
12650 0 : return found;
12651 : }
12652 : /* #line 12653 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
12653 :
12654 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
12655 :
12656 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
12657 :
12658 : /* #line 12659 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
12659 :
12660 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
12661 :
12662 : void
12663 0 : SgTypeString::checkDataMemberPointersIfInMemoryPool()
12664 : {
12665 : // ------------ checking pointers of SgTypeString -------------------
12666 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
12667 :
12668 0 : if ( p_lengthExpression != NULL )
12669 : {
12670 0 : if ( p_lengthExpression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12671 : {
12672 0 : if ( p_lengthExpression->isInMemoryPool() == false )
12673 : {
12674 0 : std::cout << "SgTypeString :: ";
12675 0 : std::cout << " p_lengthExpression is not in memory pool of ";
12676 0 : std::cout << p_lengthExpression->class_name() << std::endl;
12677 : }
12678 : }
12679 : else
12680 : {
12681 0 : std::cout << "SgTypeString :: " << std::flush;
12682 0 : std::cout << "SgExpression* p_lengthExpression = " << p_lengthExpression << " --> " << std::flush;
12683 0 : std::cout << " not valid " << std::endl;
12684 : }
12685 : }
12686 :
12687 0 : if ( p_ref_to != NULL )
12688 : {
12689 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12690 : {
12691 0 : if ( p_ref_to->isInMemoryPool() == false )
12692 : {
12693 0 : std::cout << "SgTypeString :: ";
12694 0 : std::cout << " p_ref_to is not in memory pool of ";
12695 0 : std::cout << p_ref_to->class_name() << std::endl;
12696 : }
12697 : }
12698 : else
12699 : {
12700 0 : std::cout << "SgTypeString :: " << std::flush;
12701 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
12702 0 : std::cout << " not valid " << std::endl;
12703 : }
12704 : }
12705 :
12706 0 : if ( p_ptr_to != NULL )
12707 : {
12708 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12709 : {
12710 0 : if ( p_ptr_to->isInMemoryPool() == false )
12711 : {
12712 0 : std::cout << "SgTypeString :: ";
12713 0 : std::cout << " p_ptr_to is not in memory pool of ";
12714 0 : std::cout << p_ptr_to->class_name() << std::endl;
12715 : }
12716 : }
12717 : else
12718 : {
12719 0 : std::cout << "SgTypeString :: " << std::flush;
12720 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
12721 0 : std::cout << " not valid " << std::endl;
12722 : }
12723 : }
12724 :
12725 0 : if ( p_modifiers != NULL )
12726 : {
12727 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12728 : {
12729 0 : if ( p_modifiers->isInMemoryPool() == false )
12730 : {
12731 0 : std::cout << "SgTypeString :: ";
12732 0 : std::cout << " p_modifiers is not in memory pool of ";
12733 0 : std::cout << p_modifiers->class_name() << std::endl;
12734 : }
12735 : }
12736 : else
12737 : {
12738 0 : std::cout << "SgTypeString :: " << std::flush;
12739 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
12740 0 : std::cout << " not valid " << std::endl;
12741 : }
12742 : }
12743 :
12744 0 : if ( p_typedefs != NULL )
12745 : {
12746 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12747 : {
12748 0 : if ( p_typedefs->isInMemoryPool() == false )
12749 : {
12750 0 : std::cout << "SgTypeString :: ";
12751 0 : std::cout << " p_typedefs is not in memory pool of ";
12752 0 : std::cout << p_typedefs->class_name() << std::endl;
12753 : }
12754 : }
12755 : else
12756 : {
12757 0 : std::cout << "SgTypeString :: " << std::flush;
12758 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
12759 0 : std::cout << " not valid " << std::endl;
12760 : }
12761 : }
12762 :
12763 0 : if ( p_rvalue_ref_to != NULL )
12764 : {
12765 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12766 : {
12767 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
12768 : {
12769 0 : std::cout << "SgTypeString :: ";
12770 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
12771 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
12772 : }
12773 : }
12774 : else
12775 : {
12776 0 : std::cout << "SgTypeString :: " << std::flush;
12777 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
12778 0 : std::cout << " not valid " << std::endl;
12779 : }
12780 : }
12781 :
12782 0 : if ( p_decltype_ref_to != NULL )
12783 : {
12784 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12785 : {
12786 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
12787 : {
12788 0 : std::cout << "SgTypeString :: ";
12789 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
12790 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
12791 : }
12792 : }
12793 : else
12794 : {
12795 0 : std::cout << "SgTypeString :: " << std::flush;
12796 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
12797 0 : std::cout << " not valid " << std::endl;
12798 : }
12799 : }
12800 :
12801 0 : if ( p_typeof_ref_to != NULL )
12802 : {
12803 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12804 : {
12805 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
12806 : {
12807 0 : std::cout << "SgTypeString :: ";
12808 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
12809 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
12810 : }
12811 : }
12812 : else
12813 : {
12814 0 : std::cout << "SgTypeString :: " << std::flush;
12815 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
12816 0 : std::cout << " not valid " << std::endl;
12817 : }
12818 : }
12819 :
12820 0 : if ( p_type_kind != NULL )
12821 : {
12822 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12823 : {
12824 0 : if ( p_type_kind->isInMemoryPool() == false )
12825 : {
12826 0 : std::cout << "SgTypeString :: ";
12827 0 : std::cout << " p_type_kind is not in memory pool of ";
12828 0 : std::cout << p_type_kind->class_name() << std::endl;
12829 : }
12830 : }
12831 : else
12832 : {
12833 0 : std::cout << "SgTypeString :: " << std::flush;
12834 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
12835 0 : std::cout << " not valid " << std::endl;
12836 : }
12837 : }
12838 :
12839 0 : if ( p_parent != NULL )
12840 : {
12841 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12842 : {
12843 0 : if ( p_parent->isInMemoryPool() == false )
12844 : {
12845 0 : std::cout << "SgTypeString :: ";
12846 0 : std::cout << " p_parent is not in memory pool of ";
12847 0 : std::cout << p_parent->class_name() << std::endl;
12848 : }
12849 : }
12850 : else
12851 : {
12852 0 : std::cout << "SgTypeString :: " << std::flush;
12853 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
12854 0 : std::cout << " not valid " << std::endl;
12855 : }
12856 : }
12857 :
12858 :
12859 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
12860 :
12861 0 : }
12862 :
12863 :
12864 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
12865 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
12866 : bool
12867 0 : SgTypeString::isInMemoryPool ()
12868 : {
12869 0 : typedef unsigned char* TestType;
12870 :
12871 0 : bool found = false;
12872 :
12873 0 : ROSE_ASSERT(this != NULL);
12874 :
12875 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
12876 :
12877 0 : TestType tested = (TestType) ( this ) ;
12878 :
12879 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeString::pools.begin();
12880 :
12881 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
12882 : // while (found == false && block < Memory_Block_List.end())
12883 0 : while ( (found == false) && (block != SgTypeString::pools.end()) )
12884 : {
12885 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeString::pool_size * sizeof(SgTypeString) ) ) ;
12886 0 : ++block;
12887 : }
12888 :
12889 : // Special handling for static data
12890 :
12891 :
12892 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
12893 0 : ROSE_ASSERT(found == true);
12894 :
12895 0 : return found;
12896 : }
12897 : /* #line 12898 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
12898 :
12899 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
12900 :
12901 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
12902 :
12903 : /* #line 12904 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
12904 :
12905 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
12906 :
12907 : void
12908 0 : SgTypeBool::checkDataMemberPointersIfInMemoryPool()
12909 : {
12910 : // ------------ checking pointers of SgTypeBool -------------------
12911 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
12912 :
12913 0 : if ( p_ref_to != NULL )
12914 : {
12915 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12916 : {
12917 0 : if ( p_ref_to->isInMemoryPool() == false )
12918 : {
12919 0 : std::cout << "SgTypeBool :: ";
12920 0 : std::cout << " p_ref_to is not in memory pool of ";
12921 0 : std::cout << p_ref_to->class_name() << std::endl;
12922 : }
12923 : }
12924 : else
12925 : {
12926 0 : std::cout << "SgTypeBool :: " << std::flush;
12927 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
12928 0 : std::cout << " not valid " << std::endl;
12929 : }
12930 : }
12931 :
12932 0 : if ( p_ptr_to != NULL )
12933 : {
12934 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12935 : {
12936 0 : if ( p_ptr_to->isInMemoryPool() == false )
12937 : {
12938 0 : std::cout << "SgTypeBool :: ";
12939 0 : std::cout << " p_ptr_to is not in memory pool of ";
12940 0 : std::cout << p_ptr_to->class_name() << std::endl;
12941 : }
12942 : }
12943 : else
12944 : {
12945 0 : std::cout << "SgTypeBool :: " << std::flush;
12946 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
12947 0 : std::cout << " not valid " << std::endl;
12948 : }
12949 : }
12950 :
12951 0 : if ( p_modifiers != NULL )
12952 : {
12953 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12954 : {
12955 0 : if ( p_modifiers->isInMemoryPool() == false )
12956 : {
12957 0 : std::cout << "SgTypeBool :: ";
12958 0 : std::cout << " p_modifiers is not in memory pool of ";
12959 0 : std::cout << p_modifiers->class_name() << std::endl;
12960 : }
12961 : }
12962 : else
12963 : {
12964 0 : std::cout << "SgTypeBool :: " << std::flush;
12965 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
12966 0 : std::cout << " not valid " << std::endl;
12967 : }
12968 : }
12969 :
12970 0 : if ( p_typedefs != NULL )
12971 : {
12972 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12973 : {
12974 0 : if ( p_typedefs->isInMemoryPool() == false )
12975 : {
12976 0 : std::cout << "SgTypeBool :: ";
12977 0 : std::cout << " p_typedefs is not in memory pool of ";
12978 0 : std::cout << p_typedefs->class_name() << std::endl;
12979 : }
12980 : }
12981 : else
12982 : {
12983 0 : std::cout << "SgTypeBool :: " << std::flush;
12984 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
12985 0 : std::cout << " not valid " << std::endl;
12986 : }
12987 : }
12988 :
12989 0 : if ( p_rvalue_ref_to != NULL )
12990 : {
12991 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
12992 : {
12993 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
12994 : {
12995 0 : std::cout << "SgTypeBool :: ";
12996 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
12997 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
12998 : }
12999 : }
13000 : else
13001 : {
13002 0 : std::cout << "SgTypeBool :: " << std::flush;
13003 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
13004 0 : std::cout << " not valid " << std::endl;
13005 : }
13006 : }
13007 :
13008 0 : if ( p_decltype_ref_to != NULL )
13009 : {
13010 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13011 : {
13012 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
13013 : {
13014 0 : std::cout << "SgTypeBool :: ";
13015 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
13016 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
13017 : }
13018 : }
13019 : else
13020 : {
13021 0 : std::cout << "SgTypeBool :: " << std::flush;
13022 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
13023 0 : std::cout << " not valid " << std::endl;
13024 : }
13025 : }
13026 :
13027 0 : if ( p_typeof_ref_to != NULL )
13028 : {
13029 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13030 : {
13031 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
13032 : {
13033 0 : std::cout << "SgTypeBool :: ";
13034 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
13035 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
13036 : }
13037 : }
13038 : else
13039 : {
13040 0 : std::cout << "SgTypeBool :: " << std::flush;
13041 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
13042 0 : std::cout << " not valid " << std::endl;
13043 : }
13044 : }
13045 :
13046 0 : if ( p_type_kind != NULL )
13047 : {
13048 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13049 : {
13050 0 : if ( p_type_kind->isInMemoryPool() == false )
13051 : {
13052 0 : std::cout << "SgTypeBool :: ";
13053 0 : std::cout << " p_type_kind is not in memory pool of ";
13054 0 : std::cout << p_type_kind->class_name() << std::endl;
13055 : }
13056 : }
13057 : else
13058 : {
13059 0 : std::cout << "SgTypeBool :: " << std::flush;
13060 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
13061 0 : std::cout << " not valid " << std::endl;
13062 : }
13063 : }
13064 :
13065 0 : if ( p_parent != NULL )
13066 : {
13067 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13068 : {
13069 0 : if ( p_parent->isInMemoryPool() == false )
13070 : {
13071 0 : std::cout << "SgTypeBool :: ";
13072 0 : std::cout << " p_parent is not in memory pool of ";
13073 0 : std::cout << p_parent->class_name() << std::endl;
13074 : }
13075 : }
13076 : else
13077 : {
13078 0 : std::cout << "SgTypeBool :: " << std::flush;
13079 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
13080 0 : std::cout << " not valid " << std::endl;
13081 : }
13082 : }
13083 :
13084 :
13085 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
13086 :
13087 0 : }
13088 :
13089 :
13090 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
13091 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
13092 : bool
13093 0 : SgTypeBool::isInMemoryPool ()
13094 : {
13095 0 : typedef unsigned char* TestType;
13096 :
13097 0 : bool found = false;
13098 :
13099 0 : ROSE_ASSERT(this != NULL);
13100 :
13101 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
13102 :
13103 0 : TestType tested = (TestType) ( this ) ;
13104 :
13105 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeBool::pools.begin();
13106 :
13107 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
13108 : // while (found == false && block < Memory_Block_List.end())
13109 0 : while ( (found == false) && (block != SgTypeBool::pools.end()) )
13110 : {
13111 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeBool::pool_size * sizeof(SgTypeBool) ) ) ;
13112 0 : ++block;
13113 : }
13114 :
13115 : // Special handling for static data
13116 :
13117 :
13118 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
13119 0 : ROSE_ASSERT(found == true);
13120 :
13121 0 : return found;
13122 : }
13123 : /* #line 13124 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
13124 :
13125 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
13126 :
13127 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
13128 :
13129 : /* #line 13130 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
13130 :
13131 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
13132 :
13133 : void
13134 0 : SgPointerType::checkDataMemberPointersIfInMemoryPool()
13135 : {
13136 : // ------------ checking pointers of SgPointerType -------------------
13137 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
13138 :
13139 0 : if ( p_base_type != NULL )
13140 : {
13141 0 : if ( p_base_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13142 : {
13143 0 : if ( p_base_type->isInMemoryPool() == false )
13144 : {
13145 0 : std::cout << "SgPointerType :: ";
13146 0 : std::cout << " p_base_type is not in memory pool of ";
13147 0 : std::cout << p_base_type->class_name() << std::endl;
13148 : }
13149 : }
13150 : else
13151 : {
13152 0 : std::cout << "SgPointerType :: " << std::flush;
13153 0 : std::cout << "SgType* p_base_type = " << p_base_type << " --> " << std::flush;
13154 0 : std::cout << " not valid " << std::endl;
13155 : }
13156 : }
13157 :
13158 0 : if ( p_ref_to != NULL )
13159 : {
13160 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13161 : {
13162 0 : if ( p_ref_to->isInMemoryPool() == false )
13163 : {
13164 0 : std::cout << "SgPointerType :: ";
13165 0 : std::cout << " p_ref_to is not in memory pool of ";
13166 0 : std::cout << p_ref_to->class_name() << std::endl;
13167 : }
13168 : }
13169 : else
13170 : {
13171 0 : std::cout << "SgPointerType :: " << std::flush;
13172 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
13173 0 : std::cout << " not valid " << std::endl;
13174 : }
13175 : }
13176 :
13177 0 : if ( p_ptr_to != NULL )
13178 : {
13179 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13180 : {
13181 0 : if ( p_ptr_to->isInMemoryPool() == false )
13182 : {
13183 0 : std::cout << "SgPointerType :: ";
13184 0 : std::cout << " p_ptr_to is not in memory pool of ";
13185 0 : std::cout << p_ptr_to->class_name() << std::endl;
13186 : }
13187 : }
13188 : else
13189 : {
13190 0 : std::cout << "SgPointerType :: " << std::flush;
13191 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
13192 0 : std::cout << " not valid " << std::endl;
13193 : }
13194 : }
13195 :
13196 0 : if ( p_modifiers != NULL )
13197 : {
13198 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13199 : {
13200 0 : if ( p_modifiers->isInMemoryPool() == false )
13201 : {
13202 0 : std::cout << "SgPointerType :: ";
13203 0 : std::cout << " p_modifiers is not in memory pool of ";
13204 0 : std::cout << p_modifiers->class_name() << std::endl;
13205 : }
13206 : }
13207 : else
13208 : {
13209 0 : std::cout << "SgPointerType :: " << std::flush;
13210 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
13211 0 : std::cout << " not valid " << std::endl;
13212 : }
13213 : }
13214 :
13215 0 : if ( p_typedefs != NULL )
13216 : {
13217 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13218 : {
13219 0 : if ( p_typedefs->isInMemoryPool() == false )
13220 : {
13221 0 : std::cout << "SgPointerType :: ";
13222 0 : std::cout << " p_typedefs is not in memory pool of ";
13223 0 : std::cout << p_typedefs->class_name() << std::endl;
13224 : }
13225 : }
13226 : else
13227 : {
13228 0 : std::cout << "SgPointerType :: " << std::flush;
13229 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
13230 0 : std::cout << " not valid " << std::endl;
13231 : }
13232 : }
13233 :
13234 0 : if ( p_rvalue_ref_to != NULL )
13235 : {
13236 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13237 : {
13238 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
13239 : {
13240 0 : std::cout << "SgPointerType :: ";
13241 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
13242 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
13243 : }
13244 : }
13245 : else
13246 : {
13247 0 : std::cout << "SgPointerType :: " << std::flush;
13248 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
13249 0 : std::cout << " not valid " << std::endl;
13250 : }
13251 : }
13252 :
13253 0 : if ( p_decltype_ref_to != NULL )
13254 : {
13255 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13256 : {
13257 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
13258 : {
13259 0 : std::cout << "SgPointerType :: ";
13260 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
13261 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
13262 : }
13263 : }
13264 : else
13265 : {
13266 0 : std::cout << "SgPointerType :: " << std::flush;
13267 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
13268 0 : std::cout << " not valid " << std::endl;
13269 : }
13270 : }
13271 :
13272 0 : if ( p_typeof_ref_to != NULL )
13273 : {
13274 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13275 : {
13276 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
13277 : {
13278 0 : std::cout << "SgPointerType :: ";
13279 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
13280 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
13281 : }
13282 : }
13283 : else
13284 : {
13285 0 : std::cout << "SgPointerType :: " << std::flush;
13286 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
13287 0 : std::cout << " not valid " << std::endl;
13288 : }
13289 : }
13290 :
13291 0 : if ( p_type_kind != NULL )
13292 : {
13293 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13294 : {
13295 0 : if ( p_type_kind->isInMemoryPool() == false )
13296 : {
13297 0 : std::cout << "SgPointerType :: ";
13298 0 : std::cout << " p_type_kind is not in memory pool of ";
13299 0 : std::cout << p_type_kind->class_name() << std::endl;
13300 : }
13301 : }
13302 : else
13303 : {
13304 0 : std::cout << "SgPointerType :: " << std::flush;
13305 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
13306 0 : std::cout << " not valid " << std::endl;
13307 : }
13308 : }
13309 :
13310 0 : if ( p_parent != NULL )
13311 : {
13312 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13313 : {
13314 0 : if ( p_parent->isInMemoryPool() == false )
13315 : {
13316 0 : std::cout << "SgPointerType :: ";
13317 0 : std::cout << " p_parent is not in memory pool of ";
13318 0 : std::cout << p_parent->class_name() << std::endl;
13319 : }
13320 : }
13321 : else
13322 : {
13323 0 : std::cout << "SgPointerType :: " << std::flush;
13324 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
13325 0 : std::cout << " not valid " << std::endl;
13326 : }
13327 : }
13328 :
13329 :
13330 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
13331 :
13332 0 : }
13333 :
13334 :
13335 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
13336 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
13337 : bool
13338 0 : SgPointerType::isInMemoryPool ()
13339 : {
13340 0 : typedef unsigned char* TestType;
13341 :
13342 0 : bool found = false;
13343 :
13344 0 : ROSE_ASSERT(this != NULL);
13345 :
13346 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
13347 :
13348 0 : TestType tested = (TestType) ( this ) ;
13349 :
13350 0 : std::vector < unsigned char* > :: const_iterator block = SgPointerType::pools.begin();
13351 :
13352 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
13353 : // while (found == false && block < Memory_Block_List.end())
13354 0 : while ( (found == false) && (block != SgPointerType::pools.end()) )
13355 : {
13356 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgPointerType::pool_size * sizeof(SgPointerType) ) ) ;
13357 0 : ++block;
13358 : }
13359 :
13360 : // Special handling for static data
13361 :
13362 :
13363 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
13364 0 : ROSE_ASSERT(found == true);
13365 :
13366 0 : return found;
13367 : }
13368 : /* #line 13369 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
13369 :
13370 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
13371 :
13372 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
13373 :
13374 : /* #line 13375 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
13375 :
13376 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
13377 :
13378 : void
13379 0 : SgPointerMemberType::checkDataMemberPointersIfInMemoryPool()
13380 : {
13381 : // ------------ checking pointers of SgPointerMemberType -------------------
13382 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
13383 :
13384 0 : if ( p_class_type != NULL )
13385 : {
13386 0 : if ( p_class_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13387 : {
13388 0 : if ( p_class_type->isInMemoryPool() == false )
13389 : {
13390 0 : std::cout << "SgPointerMemberType :: ";
13391 0 : std::cout << " p_class_type is not in memory pool of ";
13392 0 : std::cout << p_class_type->class_name() << std::endl;
13393 : }
13394 : }
13395 : else
13396 : {
13397 0 : std::cout << "SgPointerMemberType :: " << std::flush;
13398 0 : std::cout << "SgType* p_class_type = " << p_class_type << " --> " << std::flush;
13399 0 : std::cout << " not valid " << std::endl;
13400 : }
13401 : }
13402 :
13403 0 : if ( p_base_type != NULL )
13404 : {
13405 0 : if ( p_base_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13406 : {
13407 0 : if ( p_base_type->isInMemoryPool() == false )
13408 : {
13409 0 : std::cout << "SgPointerMemberType :: ";
13410 0 : std::cout << " p_base_type is not in memory pool of ";
13411 0 : std::cout << p_base_type->class_name() << std::endl;
13412 : }
13413 : }
13414 : else
13415 : {
13416 0 : std::cout << "SgPointerMemberType :: " << std::flush;
13417 0 : std::cout << "SgType* p_base_type = " << p_base_type << " --> " << std::flush;
13418 0 : std::cout << " not valid " << std::endl;
13419 : }
13420 : }
13421 :
13422 0 : if ( p_ref_to != NULL )
13423 : {
13424 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13425 : {
13426 0 : if ( p_ref_to->isInMemoryPool() == false )
13427 : {
13428 0 : std::cout << "SgPointerMemberType :: ";
13429 0 : std::cout << " p_ref_to is not in memory pool of ";
13430 0 : std::cout << p_ref_to->class_name() << std::endl;
13431 : }
13432 : }
13433 : else
13434 : {
13435 0 : std::cout << "SgPointerMemberType :: " << std::flush;
13436 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
13437 0 : std::cout << " not valid " << std::endl;
13438 : }
13439 : }
13440 :
13441 0 : if ( p_ptr_to != NULL )
13442 : {
13443 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13444 : {
13445 0 : if ( p_ptr_to->isInMemoryPool() == false )
13446 : {
13447 0 : std::cout << "SgPointerMemberType :: ";
13448 0 : std::cout << " p_ptr_to is not in memory pool of ";
13449 0 : std::cout << p_ptr_to->class_name() << std::endl;
13450 : }
13451 : }
13452 : else
13453 : {
13454 0 : std::cout << "SgPointerMemberType :: " << std::flush;
13455 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
13456 0 : std::cout << " not valid " << std::endl;
13457 : }
13458 : }
13459 :
13460 0 : if ( p_modifiers != NULL )
13461 : {
13462 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13463 : {
13464 0 : if ( p_modifiers->isInMemoryPool() == false )
13465 : {
13466 0 : std::cout << "SgPointerMemberType :: ";
13467 0 : std::cout << " p_modifiers is not in memory pool of ";
13468 0 : std::cout << p_modifiers->class_name() << std::endl;
13469 : }
13470 : }
13471 : else
13472 : {
13473 0 : std::cout << "SgPointerMemberType :: " << std::flush;
13474 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
13475 0 : std::cout << " not valid " << std::endl;
13476 : }
13477 : }
13478 :
13479 0 : if ( p_typedefs != NULL )
13480 : {
13481 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13482 : {
13483 0 : if ( p_typedefs->isInMemoryPool() == false )
13484 : {
13485 0 : std::cout << "SgPointerMemberType :: ";
13486 0 : std::cout << " p_typedefs is not in memory pool of ";
13487 0 : std::cout << p_typedefs->class_name() << std::endl;
13488 : }
13489 : }
13490 : else
13491 : {
13492 0 : std::cout << "SgPointerMemberType :: " << std::flush;
13493 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
13494 0 : std::cout << " not valid " << std::endl;
13495 : }
13496 : }
13497 :
13498 0 : if ( p_rvalue_ref_to != NULL )
13499 : {
13500 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13501 : {
13502 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
13503 : {
13504 0 : std::cout << "SgPointerMemberType :: ";
13505 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
13506 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
13507 : }
13508 : }
13509 : else
13510 : {
13511 0 : std::cout << "SgPointerMemberType :: " << std::flush;
13512 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
13513 0 : std::cout << " not valid " << std::endl;
13514 : }
13515 : }
13516 :
13517 0 : if ( p_decltype_ref_to != NULL )
13518 : {
13519 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13520 : {
13521 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
13522 : {
13523 0 : std::cout << "SgPointerMemberType :: ";
13524 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
13525 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
13526 : }
13527 : }
13528 : else
13529 : {
13530 0 : std::cout << "SgPointerMemberType :: " << std::flush;
13531 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
13532 0 : std::cout << " not valid " << std::endl;
13533 : }
13534 : }
13535 :
13536 0 : if ( p_typeof_ref_to != NULL )
13537 : {
13538 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13539 : {
13540 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
13541 : {
13542 0 : std::cout << "SgPointerMemberType :: ";
13543 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
13544 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
13545 : }
13546 : }
13547 : else
13548 : {
13549 0 : std::cout << "SgPointerMemberType :: " << std::flush;
13550 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
13551 0 : std::cout << " not valid " << std::endl;
13552 : }
13553 : }
13554 :
13555 0 : if ( p_type_kind != NULL )
13556 : {
13557 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13558 : {
13559 0 : if ( p_type_kind->isInMemoryPool() == false )
13560 : {
13561 0 : std::cout << "SgPointerMemberType :: ";
13562 0 : std::cout << " p_type_kind is not in memory pool of ";
13563 0 : std::cout << p_type_kind->class_name() << std::endl;
13564 : }
13565 : }
13566 : else
13567 : {
13568 0 : std::cout << "SgPointerMemberType :: " << std::flush;
13569 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
13570 0 : std::cout << " not valid " << std::endl;
13571 : }
13572 : }
13573 :
13574 0 : if ( p_parent != NULL )
13575 : {
13576 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13577 : {
13578 0 : if ( p_parent->isInMemoryPool() == false )
13579 : {
13580 0 : std::cout << "SgPointerMemberType :: ";
13581 0 : std::cout << " p_parent is not in memory pool of ";
13582 0 : std::cout << p_parent->class_name() << std::endl;
13583 : }
13584 : }
13585 : else
13586 : {
13587 0 : std::cout << "SgPointerMemberType :: " << std::flush;
13588 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
13589 0 : std::cout << " not valid " << std::endl;
13590 : }
13591 : }
13592 :
13593 :
13594 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
13595 :
13596 0 : }
13597 :
13598 :
13599 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
13600 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
13601 : bool
13602 0 : SgPointerMemberType::isInMemoryPool ()
13603 : {
13604 0 : typedef unsigned char* TestType;
13605 :
13606 0 : bool found = false;
13607 :
13608 0 : ROSE_ASSERT(this != NULL);
13609 :
13610 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
13611 :
13612 0 : TestType tested = (TestType) ( this ) ;
13613 :
13614 0 : std::vector < unsigned char* > :: const_iterator block = SgPointerMemberType::pools.begin();
13615 :
13616 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
13617 : // while (found == false && block < Memory_Block_List.end())
13618 0 : while ( (found == false) && (block != SgPointerMemberType::pools.end()) )
13619 : {
13620 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgPointerMemberType::pool_size * sizeof(SgPointerMemberType) ) ) ;
13621 0 : ++block;
13622 : }
13623 :
13624 : // Special handling for static data
13625 :
13626 :
13627 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
13628 0 : ROSE_ASSERT(found == true);
13629 :
13630 0 : return found;
13631 : }
13632 : /* #line 13633 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
13633 :
13634 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
13635 :
13636 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
13637 :
13638 : /* #line 13639 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
13639 :
13640 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
13641 :
13642 : void
13643 0 : SgReferenceType::checkDataMemberPointersIfInMemoryPool()
13644 : {
13645 : // ------------ checking pointers of SgReferenceType -------------------
13646 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
13647 :
13648 0 : if ( p_base_type != NULL )
13649 : {
13650 0 : if ( p_base_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13651 : {
13652 0 : if ( p_base_type->isInMemoryPool() == false )
13653 : {
13654 0 : std::cout << "SgReferenceType :: ";
13655 0 : std::cout << " p_base_type is not in memory pool of ";
13656 0 : std::cout << p_base_type->class_name() << std::endl;
13657 : }
13658 : }
13659 : else
13660 : {
13661 0 : std::cout << "SgReferenceType :: " << std::flush;
13662 0 : std::cout << "SgType* p_base_type = " << p_base_type << " --> " << std::flush;
13663 0 : std::cout << " not valid " << std::endl;
13664 : }
13665 : }
13666 :
13667 0 : if ( p_ref_to != NULL )
13668 : {
13669 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13670 : {
13671 0 : if ( p_ref_to->isInMemoryPool() == false )
13672 : {
13673 0 : std::cout << "SgReferenceType :: ";
13674 0 : std::cout << " p_ref_to is not in memory pool of ";
13675 0 : std::cout << p_ref_to->class_name() << std::endl;
13676 : }
13677 : }
13678 : else
13679 : {
13680 0 : std::cout << "SgReferenceType :: " << std::flush;
13681 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
13682 0 : std::cout << " not valid " << std::endl;
13683 : }
13684 : }
13685 :
13686 0 : if ( p_ptr_to != NULL )
13687 : {
13688 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13689 : {
13690 0 : if ( p_ptr_to->isInMemoryPool() == false )
13691 : {
13692 0 : std::cout << "SgReferenceType :: ";
13693 0 : std::cout << " p_ptr_to is not in memory pool of ";
13694 0 : std::cout << p_ptr_to->class_name() << std::endl;
13695 : }
13696 : }
13697 : else
13698 : {
13699 0 : std::cout << "SgReferenceType :: " << std::flush;
13700 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
13701 0 : std::cout << " not valid " << std::endl;
13702 : }
13703 : }
13704 :
13705 0 : if ( p_modifiers != NULL )
13706 : {
13707 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13708 : {
13709 0 : if ( p_modifiers->isInMemoryPool() == false )
13710 : {
13711 0 : std::cout << "SgReferenceType :: ";
13712 0 : std::cout << " p_modifiers is not in memory pool of ";
13713 0 : std::cout << p_modifiers->class_name() << std::endl;
13714 : }
13715 : }
13716 : else
13717 : {
13718 0 : std::cout << "SgReferenceType :: " << std::flush;
13719 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
13720 0 : std::cout << " not valid " << std::endl;
13721 : }
13722 : }
13723 :
13724 0 : if ( p_typedefs != NULL )
13725 : {
13726 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13727 : {
13728 0 : if ( p_typedefs->isInMemoryPool() == false )
13729 : {
13730 0 : std::cout << "SgReferenceType :: ";
13731 0 : std::cout << " p_typedefs is not in memory pool of ";
13732 0 : std::cout << p_typedefs->class_name() << std::endl;
13733 : }
13734 : }
13735 : else
13736 : {
13737 0 : std::cout << "SgReferenceType :: " << std::flush;
13738 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
13739 0 : std::cout << " not valid " << std::endl;
13740 : }
13741 : }
13742 :
13743 0 : if ( p_rvalue_ref_to != NULL )
13744 : {
13745 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13746 : {
13747 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
13748 : {
13749 0 : std::cout << "SgReferenceType :: ";
13750 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
13751 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
13752 : }
13753 : }
13754 : else
13755 : {
13756 0 : std::cout << "SgReferenceType :: " << std::flush;
13757 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
13758 0 : std::cout << " not valid " << std::endl;
13759 : }
13760 : }
13761 :
13762 0 : if ( p_decltype_ref_to != NULL )
13763 : {
13764 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13765 : {
13766 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
13767 : {
13768 0 : std::cout << "SgReferenceType :: ";
13769 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
13770 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
13771 : }
13772 : }
13773 : else
13774 : {
13775 0 : std::cout << "SgReferenceType :: " << std::flush;
13776 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
13777 0 : std::cout << " not valid " << std::endl;
13778 : }
13779 : }
13780 :
13781 0 : if ( p_typeof_ref_to != NULL )
13782 : {
13783 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13784 : {
13785 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
13786 : {
13787 0 : std::cout << "SgReferenceType :: ";
13788 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
13789 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
13790 : }
13791 : }
13792 : else
13793 : {
13794 0 : std::cout << "SgReferenceType :: " << std::flush;
13795 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
13796 0 : std::cout << " not valid " << std::endl;
13797 : }
13798 : }
13799 :
13800 0 : if ( p_type_kind != NULL )
13801 : {
13802 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13803 : {
13804 0 : if ( p_type_kind->isInMemoryPool() == false )
13805 : {
13806 0 : std::cout << "SgReferenceType :: ";
13807 0 : std::cout << " p_type_kind is not in memory pool of ";
13808 0 : std::cout << p_type_kind->class_name() << std::endl;
13809 : }
13810 : }
13811 : else
13812 : {
13813 0 : std::cout << "SgReferenceType :: " << std::flush;
13814 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
13815 0 : std::cout << " not valid " << std::endl;
13816 : }
13817 : }
13818 :
13819 0 : if ( p_parent != NULL )
13820 : {
13821 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13822 : {
13823 0 : if ( p_parent->isInMemoryPool() == false )
13824 : {
13825 0 : std::cout << "SgReferenceType :: ";
13826 0 : std::cout << " p_parent is not in memory pool of ";
13827 0 : std::cout << p_parent->class_name() << std::endl;
13828 : }
13829 : }
13830 : else
13831 : {
13832 0 : std::cout << "SgReferenceType :: " << std::flush;
13833 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
13834 0 : std::cout << " not valid " << std::endl;
13835 : }
13836 : }
13837 :
13838 :
13839 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
13840 :
13841 0 : }
13842 :
13843 :
13844 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
13845 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
13846 : bool
13847 0 : SgReferenceType::isInMemoryPool ()
13848 : {
13849 0 : typedef unsigned char* TestType;
13850 :
13851 0 : bool found = false;
13852 :
13853 0 : ROSE_ASSERT(this != NULL);
13854 :
13855 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
13856 :
13857 0 : TestType tested = (TestType) ( this ) ;
13858 :
13859 0 : std::vector < unsigned char* > :: const_iterator block = SgReferenceType::pools.begin();
13860 :
13861 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
13862 : // while (found == false && block < Memory_Block_List.end())
13863 0 : while ( (found == false) && (block != SgReferenceType::pools.end()) )
13864 : {
13865 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgReferenceType::pool_size * sizeof(SgReferenceType) ) ) ;
13866 0 : ++block;
13867 : }
13868 :
13869 : // Special handling for static data
13870 :
13871 :
13872 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
13873 0 : ROSE_ASSERT(found == true);
13874 :
13875 0 : return found;
13876 : }
13877 : /* #line 13878 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
13878 :
13879 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
13880 :
13881 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
13882 :
13883 : /* #line 13884 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
13884 :
13885 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
13886 :
13887 : void
13888 0 : SgNamedType::checkDataMemberPointersIfInMemoryPool()
13889 : {
13890 : // ------------ checking pointers of SgNamedType -------------------
13891 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
13892 :
13893 0 : if ( p_declaration != NULL )
13894 : {
13895 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13896 : {
13897 0 : if ( p_declaration->isInMemoryPool() == false )
13898 : {
13899 0 : std::cout << "SgNamedType :: ";
13900 0 : std::cout << " p_declaration is not in memory pool of ";
13901 0 : std::cout << p_declaration->class_name() << std::endl;
13902 : }
13903 : }
13904 : else
13905 : {
13906 0 : std::cout << "SgNamedType :: " << std::flush;
13907 0 : std::cout << "SgDeclarationStatement* p_declaration = " << p_declaration << " --> " << std::flush;
13908 0 : std::cout << " not valid " << std::endl;
13909 : }
13910 : }
13911 :
13912 0 : if ( p_ref_to != NULL )
13913 : {
13914 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13915 : {
13916 0 : if ( p_ref_to->isInMemoryPool() == false )
13917 : {
13918 0 : std::cout << "SgNamedType :: ";
13919 0 : std::cout << " p_ref_to is not in memory pool of ";
13920 0 : std::cout << p_ref_to->class_name() << std::endl;
13921 : }
13922 : }
13923 : else
13924 : {
13925 0 : std::cout << "SgNamedType :: " << std::flush;
13926 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
13927 0 : std::cout << " not valid " << std::endl;
13928 : }
13929 : }
13930 :
13931 0 : if ( p_ptr_to != NULL )
13932 : {
13933 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13934 : {
13935 0 : if ( p_ptr_to->isInMemoryPool() == false )
13936 : {
13937 0 : std::cout << "SgNamedType :: ";
13938 0 : std::cout << " p_ptr_to is not in memory pool of ";
13939 0 : std::cout << p_ptr_to->class_name() << std::endl;
13940 : }
13941 : }
13942 : else
13943 : {
13944 0 : std::cout << "SgNamedType :: " << std::flush;
13945 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
13946 0 : std::cout << " not valid " << std::endl;
13947 : }
13948 : }
13949 :
13950 0 : if ( p_modifiers != NULL )
13951 : {
13952 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13953 : {
13954 0 : if ( p_modifiers->isInMemoryPool() == false )
13955 : {
13956 0 : std::cout << "SgNamedType :: ";
13957 0 : std::cout << " p_modifiers is not in memory pool of ";
13958 0 : std::cout << p_modifiers->class_name() << std::endl;
13959 : }
13960 : }
13961 : else
13962 : {
13963 0 : std::cout << "SgNamedType :: " << std::flush;
13964 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
13965 0 : std::cout << " not valid " << std::endl;
13966 : }
13967 : }
13968 :
13969 0 : if ( p_typedefs != NULL )
13970 : {
13971 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13972 : {
13973 0 : if ( p_typedefs->isInMemoryPool() == false )
13974 : {
13975 0 : std::cout << "SgNamedType :: ";
13976 0 : std::cout << " p_typedefs is not in memory pool of ";
13977 0 : std::cout << p_typedefs->class_name() << std::endl;
13978 : }
13979 : }
13980 : else
13981 : {
13982 0 : std::cout << "SgNamedType :: " << std::flush;
13983 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
13984 0 : std::cout << " not valid " << std::endl;
13985 : }
13986 : }
13987 :
13988 0 : if ( p_rvalue_ref_to != NULL )
13989 : {
13990 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
13991 : {
13992 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
13993 : {
13994 0 : std::cout << "SgNamedType :: ";
13995 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
13996 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
13997 : }
13998 : }
13999 : else
14000 : {
14001 0 : std::cout << "SgNamedType :: " << std::flush;
14002 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
14003 0 : std::cout << " not valid " << std::endl;
14004 : }
14005 : }
14006 :
14007 0 : if ( p_decltype_ref_to != NULL )
14008 : {
14009 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14010 : {
14011 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
14012 : {
14013 0 : std::cout << "SgNamedType :: ";
14014 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
14015 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
14016 : }
14017 : }
14018 : else
14019 : {
14020 0 : std::cout << "SgNamedType :: " << std::flush;
14021 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
14022 0 : std::cout << " not valid " << std::endl;
14023 : }
14024 : }
14025 :
14026 0 : if ( p_typeof_ref_to != NULL )
14027 : {
14028 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14029 : {
14030 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
14031 : {
14032 0 : std::cout << "SgNamedType :: ";
14033 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
14034 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
14035 : }
14036 : }
14037 : else
14038 : {
14039 0 : std::cout << "SgNamedType :: " << std::flush;
14040 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
14041 0 : std::cout << " not valid " << std::endl;
14042 : }
14043 : }
14044 :
14045 0 : if ( p_type_kind != NULL )
14046 : {
14047 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14048 : {
14049 0 : if ( p_type_kind->isInMemoryPool() == false )
14050 : {
14051 0 : std::cout << "SgNamedType :: ";
14052 0 : std::cout << " p_type_kind is not in memory pool of ";
14053 0 : std::cout << p_type_kind->class_name() << std::endl;
14054 : }
14055 : }
14056 : else
14057 : {
14058 0 : std::cout << "SgNamedType :: " << std::flush;
14059 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
14060 0 : std::cout << " not valid " << std::endl;
14061 : }
14062 : }
14063 :
14064 0 : if ( p_parent != NULL )
14065 : {
14066 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14067 : {
14068 0 : if ( p_parent->isInMemoryPool() == false )
14069 : {
14070 0 : std::cout << "SgNamedType :: ";
14071 0 : std::cout << " p_parent is not in memory pool of ";
14072 0 : std::cout << p_parent->class_name() << std::endl;
14073 : }
14074 : }
14075 : else
14076 : {
14077 0 : std::cout << "SgNamedType :: " << std::flush;
14078 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
14079 0 : std::cout << " not valid " << std::endl;
14080 : }
14081 : }
14082 :
14083 :
14084 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
14085 :
14086 0 : }
14087 :
14088 :
14089 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
14090 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
14091 : bool
14092 0 : SgNamedType::isInMemoryPool ()
14093 : {
14094 0 : typedef unsigned char* TestType;
14095 :
14096 0 : bool found = false;
14097 :
14098 0 : ROSE_ASSERT(this != NULL);
14099 :
14100 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
14101 :
14102 0 : TestType tested = (TestType) ( this ) ;
14103 :
14104 0 : std::vector < unsigned char* > :: const_iterator block = SgNamedType::pools.begin();
14105 :
14106 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
14107 : // while (found == false && block < Memory_Block_List.end())
14108 0 : while ( (found == false) && (block != SgNamedType::pools.end()) )
14109 : {
14110 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNamedType::pool_size * sizeof(SgNamedType) ) ) ;
14111 0 : ++block;
14112 : }
14113 :
14114 : // Special handling for static data
14115 :
14116 :
14117 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
14118 0 : ROSE_ASSERT(found == true);
14119 :
14120 0 : return found;
14121 : }
14122 : /* #line 14123 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
14123 :
14124 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
14125 :
14126 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
14127 :
14128 : /* #line 14129 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
14129 :
14130 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
14131 :
14132 : void
14133 0 : SgClassType::checkDataMemberPointersIfInMemoryPool()
14134 : {
14135 : // ------------ checking pointers of SgClassType -------------------
14136 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
14137 :
14138 0 : if ( p_declaration != NULL )
14139 : {
14140 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14141 : {
14142 0 : if ( p_declaration->isInMemoryPool() == false )
14143 : {
14144 0 : std::cout << "SgClassType :: ";
14145 0 : std::cout << " p_declaration is not in memory pool of ";
14146 0 : std::cout << p_declaration->class_name() << std::endl;
14147 : }
14148 : }
14149 : else
14150 : {
14151 0 : std::cout << "SgClassType :: " << std::flush;
14152 0 : std::cout << "SgDeclarationStatement* p_declaration = " << p_declaration << " --> " << std::flush;
14153 0 : std::cout << " not valid " << std::endl;
14154 : }
14155 : }
14156 :
14157 0 : if ( p_ref_to != NULL )
14158 : {
14159 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14160 : {
14161 0 : if ( p_ref_to->isInMemoryPool() == false )
14162 : {
14163 0 : std::cout << "SgClassType :: ";
14164 0 : std::cout << " p_ref_to is not in memory pool of ";
14165 0 : std::cout << p_ref_to->class_name() << std::endl;
14166 : }
14167 : }
14168 : else
14169 : {
14170 0 : std::cout << "SgClassType :: " << std::flush;
14171 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
14172 0 : std::cout << " not valid " << std::endl;
14173 : }
14174 : }
14175 :
14176 0 : if ( p_ptr_to != NULL )
14177 : {
14178 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14179 : {
14180 0 : if ( p_ptr_to->isInMemoryPool() == false )
14181 : {
14182 0 : std::cout << "SgClassType :: ";
14183 0 : std::cout << " p_ptr_to is not in memory pool of ";
14184 0 : std::cout << p_ptr_to->class_name() << std::endl;
14185 : }
14186 : }
14187 : else
14188 : {
14189 0 : std::cout << "SgClassType :: " << std::flush;
14190 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
14191 0 : std::cout << " not valid " << std::endl;
14192 : }
14193 : }
14194 :
14195 0 : if ( p_modifiers != NULL )
14196 : {
14197 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14198 : {
14199 0 : if ( p_modifiers->isInMemoryPool() == false )
14200 : {
14201 0 : std::cout << "SgClassType :: ";
14202 0 : std::cout << " p_modifiers is not in memory pool of ";
14203 0 : std::cout << p_modifiers->class_name() << std::endl;
14204 : }
14205 : }
14206 : else
14207 : {
14208 0 : std::cout << "SgClassType :: " << std::flush;
14209 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
14210 0 : std::cout << " not valid " << std::endl;
14211 : }
14212 : }
14213 :
14214 0 : if ( p_typedefs != NULL )
14215 : {
14216 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14217 : {
14218 0 : if ( p_typedefs->isInMemoryPool() == false )
14219 : {
14220 0 : std::cout << "SgClassType :: ";
14221 0 : std::cout << " p_typedefs is not in memory pool of ";
14222 0 : std::cout << p_typedefs->class_name() << std::endl;
14223 : }
14224 : }
14225 : else
14226 : {
14227 0 : std::cout << "SgClassType :: " << std::flush;
14228 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
14229 0 : std::cout << " not valid " << std::endl;
14230 : }
14231 : }
14232 :
14233 0 : if ( p_rvalue_ref_to != NULL )
14234 : {
14235 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14236 : {
14237 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
14238 : {
14239 0 : std::cout << "SgClassType :: ";
14240 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
14241 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
14242 : }
14243 : }
14244 : else
14245 : {
14246 0 : std::cout << "SgClassType :: " << std::flush;
14247 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
14248 0 : std::cout << " not valid " << std::endl;
14249 : }
14250 : }
14251 :
14252 0 : if ( p_decltype_ref_to != NULL )
14253 : {
14254 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14255 : {
14256 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
14257 : {
14258 0 : std::cout << "SgClassType :: ";
14259 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
14260 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
14261 : }
14262 : }
14263 : else
14264 : {
14265 0 : std::cout << "SgClassType :: " << std::flush;
14266 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
14267 0 : std::cout << " not valid " << std::endl;
14268 : }
14269 : }
14270 :
14271 0 : if ( p_typeof_ref_to != NULL )
14272 : {
14273 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14274 : {
14275 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
14276 : {
14277 0 : std::cout << "SgClassType :: ";
14278 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
14279 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
14280 : }
14281 : }
14282 : else
14283 : {
14284 0 : std::cout << "SgClassType :: " << std::flush;
14285 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
14286 0 : std::cout << " not valid " << std::endl;
14287 : }
14288 : }
14289 :
14290 0 : if ( p_type_kind != NULL )
14291 : {
14292 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14293 : {
14294 0 : if ( p_type_kind->isInMemoryPool() == false )
14295 : {
14296 0 : std::cout << "SgClassType :: ";
14297 0 : std::cout << " p_type_kind is not in memory pool of ";
14298 0 : std::cout << p_type_kind->class_name() << std::endl;
14299 : }
14300 : }
14301 : else
14302 : {
14303 0 : std::cout << "SgClassType :: " << std::flush;
14304 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
14305 0 : std::cout << " not valid " << std::endl;
14306 : }
14307 : }
14308 :
14309 0 : if ( p_parent != NULL )
14310 : {
14311 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14312 : {
14313 0 : if ( p_parent->isInMemoryPool() == false )
14314 : {
14315 0 : std::cout << "SgClassType :: ";
14316 0 : std::cout << " p_parent is not in memory pool of ";
14317 0 : std::cout << p_parent->class_name() << std::endl;
14318 : }
14319 : }
14320 : else
14321 : {
14322 0 : std::cout << "SgClassType :: " << std::flush;
14323 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
14324 0 : std::cout << " not valid " << std::endl;
14325 : }
14326 : }
14327 :
14328 :
14329 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
14330 :
14331 0 : }
14332 :
14333 :
14334 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
14335 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
14336 : bool
14337 0 : SgClassType::isInMemoryPool ()
14338 : {
14339 0 : typedef unsigned char* TestType;
14340 :
14341 0 : bool found = false;
14342 :
14343 0 : ROSE_ASSERT(this != NULL);
14344 :
14345 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
14346 :
14347 0 : TestType tested = (TestType) ( this ) ;
14348 :
14349 0 : std::vector < unsigned char* > :: const_iterator block = SgClassType::pools.begin();
14350 :
14351 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
14352 : // while (found == false && block < Memory_Block_List.end())
14353 0 : while ( (found == false) && (block != SgClassType::pools.end()) )
14354 : {
14355 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgClassType::pool_size * sizeof(SgClassType) ) ) ;
14356 0 : ++block;
14357 : }
14358 :
14359 : // Special handling for static data
14360 :
14361 :
14362 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
14363 0 : ROSE_ASSERT(found == true);
14364 :
14365 0 : return found;
14366 : }
14367 : /* #line 14368 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
14368 :
14369 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
14370 :
14371 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
14372 :
14373 : /* #line 14374 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
14374 :
14375 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
14376 :
14377 : void
14378 0 : SgEnumType::checkDataMemberPointersIfInMemoryPool()
14379 : {
14380 : // ------------ checking pointers of SgEnumType -------------------
14381 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
14382 :
14383 0 : if ( p_declaration != NULL )
14384 : {
14385 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14386 : {
14387 0 : if ( p_declaration->isInMemoryPool() == false )
14388 : {
14389 0 : std::cout << "SgEnumType :: ";
14390 0 : std::cout << " p_declaration is not in memory pool of ";
14391 0 : std::cout << p_declaration->class_name() << std::endl;
14392 : }
14393 : }
14394 : else
14395 : {
14396 0 : std::cout << "SgEnumType :: " << std::flush;
14397 0 : std::cout << "SgDeclarationStatement* p_declaration = " << p_declaration << " --> " << std::flush;
14398 0 : std::cout << " not valid " << std::endl;
14399 : }
14400 : }
14401 :
14402 0 : if ( p_ref_to != NULL )
14403 : {
14404 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14405 : {
14406 0 : if ( p_ref_to->isInMemoryPool() == false )
14407 : {
14408 0 : std::cout << "SgEnumType :: ";
14409 0 : std::cout << " p_ref_to is not in memory pool of ";
14410 0 : std::cout << p_ref_to->class_name() << std::endl;
14411 : }
14412 : }
14413 : else
14414 : {
14415 0 : std::cout << "SgEnumType :: " << std::flush;
14416 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
14417 0 : std::cout << " not valid " << std::endl;
14418 : }
14419 : }
14420 :
14421 0 : if ( p_ptr_to != NULL )
14422 : {
14423 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14424 : {
14425 0 : if ( p_ptr_to->isInMemoryPool() == false )
14426 : {
14427 0 : std::cout << "SgEnumType :: ";
14428 0 : std::cout << " p_ptr_to is not in memory pool of ";
14429 0 : std::cout << p_ptr_to->class_name() << std::endl;
14430 : }
14431 : }
14432 : else
14433 : {
14434 0 : std::cout << "SgEnumType :: " << std::flush;
14435 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
14436 0 : std::cout << " not valid " << std::endl;
14437 : }
14438 : }
14439 :
14440 0 : if ( p_modifiers != NULL )
14441 : {
14442 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14443 : {
14444 0 : if ( p_modifiers->isInMemoryPool() == false )
14445 : {
14446 0 : std::cout << "SgEnumType :: ";
14447 0 : std::cout << " p_modifiers is not in memory pool of ";
14448 0 : std::cout << p_modifiers->class_name() << std::endl;
14449 : }
14450 : }
14451 : else
14452 : {
14453 0 : std::cout << "SgEnumType :: " << std::flush;
14454 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
14455 0 : std::cout << " not valid " << std::endl;
14456 : }
14457 : }
14458 :
14459 0 : if ( p_typedefs != NULL )
14460 : {
14461 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14462 : {
14463 0 : if ( p_typedefs->isInMemoryPool() == false )
14464 : {
14465 0 : std::cout << "SgEnumType :: ";
14466 0 : std::cout << " p_typedefs is not in memory pool of ";
14467 0 : std::cout << p_typedefs->class_name() << std::endl;
14468 : }
14469 : }
14470 : else
14471 : {
14472 0 : std::cout << "SgEnumType :: " << std::flush;
14473 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
14474 0 : std::cout << " not valid " << std::endl;
14475 : }
14476 : }
14477 :
14478 0 : if ( p_rvalue_ref_to != NULL )
14479 : {
14480 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14481 : {
14482 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
14483 : {
14484 0 : std::cout << "SgEnumType :: ";
14485 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
14486 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
14487 : }
14488 : }
14489 : else
14490 : {
14491 0 : std::cout << "SgEnumType :: " << std::flush;
14492 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
14493 0 : std::cout << " not valid " << std::endl;
14494 : }
14495 : }
14496 :
14497 0 : if ( p_decltype_ref_to != NULL )
14498 : {
14499 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14500 : {
14501 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
14502 : {
14503 0 : std::cout << "SgEnumType :: ";
14504 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
14505 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
14506 : }
14507 : }
14508 : else
14509 : {
14510 0 : std::cout << "SgEnumType :: " << std::flush;
14511 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
14512 0 : std::cout << " not valid " << std::endl;
14513 : }
14514 : }
14515 :
14516 0 : if ( p_typeof_ref_to != NULL )
14517 : {
14518 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14519 : {
14520 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
14521 : {
14522 0 : std::cout << "SgEnumType :: ";
14523 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
14524 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
14525 : }
14526 : }
14527 : else
14528 : {
14529 0 : std::cout << "SgEnumType :: " << std::flush;
14530 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
14531 0 : std::cout << " not valid " << std::endl;
14532 : }
14533 : }
14534 :
14535 0 : if ( p_type_kind != NULL )
14536 : {
14537 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14538 : {
14539 0 : if ( p_type_kind->isInMemoryPool() == false )
14540 : {
14541 0 : std::cout << "SgEnumType :: ";
14542 0 : std::cout << " p_type_kind is not in memory pool of ";
14543 0 : std::cout << p_type_kind->class_name() << std::endl;
14544 : }
14545 : }
14546 : else
14547 : {
14548 0 : std::cout << "SgEnumType :: " << std::flush;
14549 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
14550 0 : std::cout << " not valid " << std::endl;
14551 : }
14552 : }
14553 :
14554 0 : if ( p_parent != NULL )
14555 : {
14556 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14557 : {
14558 0 : if ( p_parent->isInMemoryPool() == false )
14559 : {
14560 0 : std::cout << "SgEnumType :: ";
14561 0 : std::cout << " p_parent is not in memory pool of ";
14562 0 : std::cout << p_parent->class_name() << std::endl;
14563 : }
14564 : }
14565 : else
14566 : {
14567 0 : std::cout << "SgEnumType :: " << std::flush;
14568 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
14569 0 : std::cout << " not valid " << std::endl;
14570 : }
14571 : }
14572 :
14573 :
14574 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
14575 :
14576 0 : }
14577 :
14578 :
14579 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
14580 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
14581 : bool
14582 0 : SgEnumType::isInMemoryPool ()
14583 : {
14584 0 : typedef unsigned char* TestType;
14585 :
14586 0 : bool found = false;
14587 :
14588 0 : ROSE_ASSERT(this != NULL);
14589 :
14590 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
14591 :
14592 0 : TestType tested = (TestType) ( this ) ;
14593 :
14594 0 : std::vector < unsigned char* > :: const_iterator block = SgEnumType::pools.begin();
14595 :
14596 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
14597 : // while (found == false && block < Memory_Block_List.end())
14598 0 : while ( (found == false) && (block != SgEnumType::pools.end()) )
14599 : {
14600 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgEnumType::pool_size * sizeof(SgEnumType) ) ) ;
14601 0 : ++block;
14602 : }
14603 :
14604 : // Special handling for static data
14605 :
14606 :
14607 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
14608 0 : ROSE_ASSERT(found == true);
14609 :
14610 0 : return found;
14611 : }
14612 : /* #line 14613 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
14613 :
14614 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
14615 :
14616 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
14617 :
14618 : /* #line 14619 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
14619 :
14620 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
14621 :
14622 : void
14623 0 : SgTypedefType::checkDataMemberPointersIfInMemoryPool()
14624 : {
14625 : // ------------ checking pointers of SgTypedefType -------------------
14626 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
14627 :
14628 0 : if ( p_parent_scope != NULL )
14629 : {
14630 0 : if ( p_parent_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14631 : {
14632 0 : if ( p_parent_scope->isInMemoryPool() == false )
14633 : {
14634 0 : std::cout << "SgTypedefType :: ";
14635 0 : std::cout << " p_parent_scope is not in memory pool of ";
14636 0 : std::cout << p_parent_scope->class_name() << std::endl;
14637 : }
14638 : }
14639 : else
14640 : {
14641 0 : std::cout << "SgTypedefType :: " << std::flush;
14642 0 : std::cout << "SgSymbol* p_parent_scope = " << p_parent_scope << " --> " << std::flush;
14643 0 : std::cout << " not valid " << std::endl;
14644 : }
14645 : }
14646 :
14647 0 : if ( p_declaration != NULL )
14648 : {
14649 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14650 : {
14651 0 : if ( p_declaration->isInMemoryPool() == false )
14652 : {
14653 0 : std::cout << "SgTypedefType :: ";
14654 0 : std::cout << " p_declaration is not in memory pool of ";
14655 0 : std::cout << p_declaration->class_name() << std::endl;
14656 : }
14657 : }
14658 : else
14659 : {
14660 0 : std::cout << "SgTypedefType :: " << std::flush;
14661 0 : std::cout << "SgDeclarationStatement* p_declaration = " << p_declaration << " --> " << std::flush;
14662 0 : std::cout << " not valid " << std::endl;
14663 : }
14664 : }
14665 :
14666 0 : if ( p_ref_to != NULL )
14667 : {
14668 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14669 : {
14670 0 : if ( p_ref_to->isInMemoryPool() == false )
14671 : {
14672 0 : std::cout << "SgTypedefType :: ";
14673 0 : std::cout << " p_ref_to is not in memory pool of ";
14674 0 : std::cout << p_ref_to->class_name() << std::endl;
14675 : }
14676 : }
14677 : else
14678 : {
14679 0 : std::cout << "SgTypedefType :: " << std::flush;
14680 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
14681 0 : std::cout << " not valid " << std::endl;
14682 : }
14683 : }
14684 :
14685 0 : if ( p_ptr_to != NULL )
14686 : {
14687 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14688 : {
14689 0 : if ( p_ptr_to->isInMemoryPool() == false )
14690 : {
14691 0 : std::cout << "SgTypedefType :: ";
14692 0 : std::cout << " p_ptr_to is not in memory pool of ";
14693 0 : std::cout << p_ptr_to->class_name() << std::endl;
14694 : }
14695 : }
14696 : else
14697 : {
14698 0 : std::cout << "SgTypedefType :: " << std::flush;
14699 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
14700 0 : std::cout << " not valid " << std::endl;
14701 : }
14702 : }
14703 :
14704 0 : if ( p_modifiers != NULL )
14705 : {
14706 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14707 : {
14708 0 : if ( p_modifiers->isInMemoryPool() == false )
14709 : {
14710 0 : std::cout << "SgTypedefType :: ";
14711 0 : std::cout << " p_modifiers is not in memory pool of ";
14712 0 : std::cout << p_modifiers->class_name() << std::endl;
14713 : }
14714 : }
14715 : else
14716 : {
14717 0 : std::cout << "SgTypedefType :: " << std::flush;
14718 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
14719 0 : std::cout << " not valid " << std::endl;
14720 : }
14721 : }
14722 :
14723 0 : if ( p_typedefs != NULL )
14724 : {
14725 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14726 : {
14727 0 : if ( p_typedefs->isInMemoryPool() == false )
14728 : {
14729 0 : std::cout << "SgTypedefType :: ";
14730 0 : std::cout << " p_typedefs is not in memory pool of ";
14731 0 : std::cout << p_typedefs->class_name() << std::endl;
14732 : }
14733 : }
14734 : else
14735 : {
14736 0 : std::cout << "SgTypedefType :: " << std::flush;
14737 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
14738 0 : std::cout << " not valid " << std::endl;
14739 : }
14740 : }
14741 :
14742 0 : if ( p_rvalue_ref_to != NULL )
14743 : {
14744 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14745 : {
14746 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
14747 : {
14748 0 : std::cout << "SgTypedefType :: ";
14749 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
14750 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
14751 : }
14752 : }
14753 : else
14754 : {
14755 0 : std::cout << "SgTypedefType :: " << std::flush;
14756 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
14757 0 : std::cout << " not valid " << std::endl;
14758 : }
14759 : }
14760 :
14761 0 : if ( p_decltype_ref_to != NULL )
14762 : {
14763 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14764 : {
14765 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
14766 : {
14767 0 : std::cout << "SgTypedefType :: ";
14768 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
14769 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
14770 : }
14771 : }
14772 : else
14773 : {
14774 0 : std::cout << "SgTypedefType :: " << std::flush;
14775 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
14776 0 : std::cout << " not valid " << std::endl;
14777 : }
14778 : }
14779 :
14780 0 : if ( p_typeof_ref_to != NULL )
14781 : {
14782 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14783 : {
14784 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
14785 : {
14786 0 : std::cout << "SgTypedefType :: ";
14787 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
14788 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
14789 : }
14790 : }
14791 : else
14792 : {
14793 0 : std::cout << "SgTypedefType :: " << std::flush;
14794 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
14795 0 : std::cout << " not valid " << std::endl;
14796 : }
14797 : }
14798 :
14799 0 : if ( p_type_kind != NULL )
14800 : {
14801 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14802 : {
14803 0 : if ( p_type_kind->isInMemoryPool() == false )
14804 : {
14805 0 : std::cout << "SgTypedefType :: ";
14806 0 : std::cout << " p_type_kind is not in memory pool of ";
14807 0 : std::cout << p_type_kind->class_name() << std::endl;
14808 : }
14809 : }
14810 : else
14811 : {
14812 0 : std::cout << "SgTypedefType :: " << std::flush;
14813 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
14814 0 : std::cout << " not valid " << std::endl;
14815 : }
14816 : }
14817 :
14818 0 : if ( p_parent != NULL )
14819 : {
14820 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14821 : {
14822 0 : if ( p_parent->isInMemoryPool() == false )
14823 : {
14824 0 : std::cout << "SgTypedefType :: ";
14825 0 : std::cout << " p_parent is not in memory pool of ";
14826 0 : std::cout << p_parent->class_name() << std::endl;
14827 : }
14828 : }
14829 : else
14830 : {
14831 0 : std::cout << "SgTypedefType :: " << std::flush;
14832 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
14833 0 : std::cout << " not valid " << std::endl;
14834 : }
14835 : }
14836 :
14837 :
14838 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
14839 :
14840 0 : }
14841 :
14842 :
14843 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
14844 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
14845 : bool
14846 0 : SgTypedefType::isInMemoryPool ()
14847 : {
14848 0 : typedef unsigned char* TestType;
14849 :
14850 0 : bool found = false;
14851 :
14852 0 : ROSE_ASSERT(this != NULL);
14853 :
14854 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
14855 :
14856 0 : TestType tested = (TestType) ( this ) ;
14857 :
14858 0 : std::vector < unsigned char* > :: const_iterator block = SgTypedefType::pools.begin();
14859 :
14860 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
14861 : // while (found == false && block < Memory_Block_List.end())
14862 0 : while ( (found == false) && (block != SgTypedefType::pools.end()) )
14863 : {
14864 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypedefType::pool_size * sizeof(SgTypedefType) ) ) ;
14865 0 : ++block;
14866 : }
14867 :
14868 : // Special handling for static data
14869 :
14870 :
14871 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
14872 0 : ROSE_ASSERT(found == true);
14873 :
14874 0 : return found;
14875 : }
14876 : /* #line 14877 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
14877 :
14878 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
14879 :
14880 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
14881 :
14882 : /* #line 14883 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
14883 :
14884 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
14885 :
14886 : void
14887 0 : SgNonrealType::checkDataMemberPointersIfInMemoryPool()
14888 : {
14889 : // ------------ checking pointers of SgNonrealType -------------------
14890 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
14891 :
14892 0 : if ( p_declaration != NULL )
14893 : {
14894 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14895 : {
14896 0 : if ( p_declaration->isInMemoryPool() == false )
14897 : {
14898 0 : std::cout << "SgNonrealType :: ";
14899 0 : std::cout << " p_declaration is not in memory pool of ";
14900 0 : std::cout << p_declaration->class_name() << std::endl;
14901 : }
14902 : }
14903 : else
14904 : {
14905 0 : std::cout << "SgNonrealType :: " << std::flush;
14906 0 : std::cout << "SgDeclarationStatement* p_declaration = " << p_declaration << " --> " << std::flush;
14907 0 : std::cout << " not valid " << std::endl;
14908 : }
14909 : }
14910 :
14911 0 : if ( p_ref_to != NULL )
14912 : {
14913 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14914 : {
14915 0 : if ( p_ref_to->isInMemoryPool() == false )
14916 : {
14917 0 : std::cout << "SgNonrealType :: ";
14918 0 : std::cout << " p_ref_to is not in memory pool of ";
14919 0 : std::cout << p_ref_to->class_name() << std::endl;
14920 : }
14921 : }
14922 : else
14923 : {
14924 0 : std::cout << "SgNonrealType :: " << std::flush;
14925 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
14926 0 : std::cout << " not valid " << std::endl;
14927 : }
14928 : }
14929 :
14930 0 : if ( p_ptr_to != NULL )
14931 : {
14932 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14933 : {
14934 0 : if ( p_ptr_to->isInMemoryPool() == false )
14935 : {
14936 0 : std::cout << "SgNonrealType :: ";
14937 0 : std::cout << " p_ptr_to is not in memory pool of ";
14938 0 : std::cout << p_ptr_to->class_name() << std::endl;
14939 : }
14940 : }
14941 : else
14942 : {
14943 0 : std::cout << "SgNonrealType :: " << std::flush;
14944 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
14945 0 : std::cout << " not valid " << std::endl;
14946 : }
14947 : }
14948 :
14949 0 : if ( p_modifiers != NULL )
14950 : {
14951 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14952 : {
14953 0 : if ( p_modifiers->isInMemoryPool() == false )
14954 : {
14955 0 : std::cout << "SgNonrealType :: ";
14956 0 : std::cout << " p_modifiers is not in memory pool of ";
14957 0 : std::cout << p_modifiers->class_name() << std::endl;
14958 : }
14959 : }
14960 : else
14961 : {
14962 0 : std::cout << "SgNonrealType :: " << std::flush;
14963 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
14964 0 : std::cout << " not valid " << std::endl;
14965 : }
14966 : }
14967 :
14968 0 : if ( p_typedefs != NULL )
14969 : {
14970 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14971 : {
14972 0 : if ( p_typedefs->isInMemoryPool() == false )
14973 : {
14974 0 : std::cout << "SgNonrealType :: ";
14975 0 : std::cout << " p_typedefs is not in memory pool of ";
14976 0 : std::cout << p_typedefs->class_name() << std::endl;
14977 : }
14978 : }
14979 : else
14980 : {
14981 0 : std::cout << "SgNonrealType :: " << std::flush;
14982 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
14983 0 : std::cout << " not valid " << std::endl;
14984 : }
14985 : }
14986 :
14987 0 : if ( p_rvalue_ref_to != NULL )
14988 : {
14989 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
14990 : {
14991 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
14992 : {
14993 0 : std::cout << "SgNonrealType :: ";
14994 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
14995 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
14996 : }
14997 : }
14998 : else
14999 : {
15000 0 : std::cout << "SgNonrealType :: " << std::flush;
15001 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
15002 0 : std::cout << " not valid " << std::endl;
15003 : }
15004 : }
15005 :
15006 0 : if ( p_decltype_ref_to != NULL )
15007 : {
15008 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15009 : {
15010 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
15011 : {
15012 0 : std::cout << "SgNonrealType :: ";
15013 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
15014 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
15015 : }
15016 : }
15017 : else
15018 : {
15019 0 : std::cout << "SgNonrealType :: " << std::flush;
15020 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
15021 0 : std::cout << " not valid " << std::endl;
15022 : }
15023 : }
15024 :
15025 0 : if ( p_typeof_ref_to != NULL )
15026 : {
15027 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15028 : {
15029 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
15030 : {
15031 0 : std::cout << "SgNonrealType :: ";
15032 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
15033 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
15034 : }
15035 : }
15036 : else
15037 : {
15038 0 : std::cout << "SgNonrealType :: " << std::flush;
15039 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
15040 0 : std::cout << " not valid " << std::endl;
15041 : }
15042 : }
15043 :
15044 0 : if ( p_type_kind != NULL )
15045 : {
15046 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15047 : {
15048 0 : if ( p_type_kind->isInMemoryPool() == false )
15049 : {
15050 0 : std::cout << "SgNonrealType :: ";
15051 0 : std::cout << " p_type_kind is not in memory pool of ";
15052 0 : std::cout << p_type_kind->class_name() << std::endl;
15053 : }
15054 : }
15055 : else
15056 : {
15057 0 : std::cout << "SgNonrealType :: " << std::flush;
15058 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
15059 0 : std::cout << " not valid " << std::endl;
15060 : }
15061 : }
15062 :
15063 0 : if ( p_parent != NULL )
15064 : {
15065 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15066 : {
15067 0 : if ( p_parent->isInMemoryPool() == false )
15068 : {
15069 0 : std::cout << "SgNonrealType :: ";
15070 0 : std::cout << " p_parent is not in memory pool of ";
15071 0 : std::cout << p_parent->class_name() << std::endl;
15072 : }
15073 : }
15074 : else
15075 : {
15076 0 : std::cout << "SgNonrealType :: " << std::flush;
15077 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
15078 0 : std::cout << " not valid " << std::endl;
15079 : }
15080 : }
15081 :
15082 :
15083 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
15084 :
15085 0 : }
15086 :
15087 :
15088 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
15089 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
15090 : bool
15091 0 : SgNonrealType::isInMemoryPool ()
15092 : {
15093 0 : typedef unsigned char* TestType;
15094 :
15095 0 : bool found = false;
15096 :
15097 0 : ROSE_ASSERT(this != NULL);
15098 :
15099 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
15100 :
15101 0 : TestType tested = (TestType) ( this ) ;
15102 :
15103 0 : std::vector < unsigned char* > :: const_iterator block = SgNonrealType::pools.begin();
15104 :
15105 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
15106 : // while (found == false && block < Memory_Block_List.end())
15107 0 : while ( (found == false) && (block != SgNonrealType::pools.end()) )
15108 : {
15109 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNonrealType::pool_size * sizeof(SgNonrealType) ) ) ;
15110 0 : ++block;
15111 : }
15112 :
15113 : // Special handling for static data
15114 :
15115 :
15116 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
15117 0 : ROSE_ASSERT(found == true);
15118 :
15119 0 : return found;
15120 : }
15121 : /* #line 15122 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
15122 :
15123 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
15124 :
15125 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
15126 :
15127 : /* #line 15128 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
15128 :
15129 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
15130 :
15131 : void
15132 0 : SgModifierType::checkDataMemberPointersIfInMemoryPool()
15133 : {
15134 : // ------------ checking pointers of SgModifierType -------------------
15135 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
15136 :
15137 0 : if ( p_base_type != NULL )
15138 : {
15139 0 : if ( p_base_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15140 : {
15141 0 : if ( p_base_type->isInMemoryPool() == false )
15142 : {
15143 0 : std::cout << "SgModifierType :: ";
15144 0 : std::cout << " p_base_type is not in memory pool of ";
15145 0 : std::cout << p_base_type->class_name() << std::endl;
15146 : }
15147 : }
15148 : else
15149 : {
15150 0 : std::cout << "SgModifierType :: " << std::flush;
15151 0 : std::cout << "SgType* p_base_type = " << p_base_type << " --> " << std::flush;
15152 0 : std::cout << " not valid " << std::endl;
15153 : }
15154 : }
15155 :
15156 0 : if ( p_ref_to != NULL )
15157 : {
15158 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15159 : {
15160 0 : if ( p_ref_to->isInMemoryPool() == false )
15161 : {
15162 0 : std::cout << "SgModifierType :: ";
15163 0 : std::cout << " p_ref_to is not in memory pool of ";
15164 0 : std::cout << p_ref_to->class_name() << std::endl;
15165 : }
15166 : }
15167 : else
15168 : {
15169 0 : std::cout << "SgModifierType :: " << std::flush;
15170 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
15171 0 : std::cout << " not valid " << std::endl;
15172 : }
15173 : }
15174 :
15175 0 : if ( p_ptr_to != NULL )
15176 : {
15177 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15178 : {
15179 0 : if ( p_ptr_to->isInMemoryPool() == false )
15180 : {
15181 0 : std::cout << "SgModifierType :: ";
15182 0 : std::cout << " p_ptr_to is not in memory pool of ";
15183 0 : std::cout << p_ptr_to->class_name() << std::endl;
15184 : }
15185 : }
15186 : else
15187 : {
15188 0 : std::cout << "SgModifierType :: " << std::flush;
15189 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
15190 0 : std::cout << " not valid " << std::endl;
15191 : }
15192 : }
15193 :
15194 0 : if ( p_modifiers != NULL )
15195 : {
15196 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15197 : {
15198 0 : if ( p_modifiers->isInMemoryPool() == false )
15199 : {
15200 0 : std::cout << "SgModifierType :: ";
15201 0 : std::cout << " p_modifiers is not in memory pool of ";
15202 0 : std::cout << p_modifiers->class_name() << std::endl;
15203 : }
15204 : }
15205 : else
15206 : {
15207 0 : std::cout << "SgModifierType :: " << std::flush;
15208 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
15209 0 : std::cout << " not valid " << std::endl;
15210 : }
15211 : }
15212 :
15213 0 : if ( p_typedefs != NULL )
15214 : {
15215 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15216 : {
15217 0 : if ( p_typedefs->isInMemoryPool() == false )
15218 : {
15219 0 : std::cout << "SgModifierType :: ";
15220 0 : std::cout << " p_typedefs is not in memory pool of ";
15221 0 : std::cout << p_typedefs->class_name() << std::endl;
15222 : }
15223 : }
15224 : else
15225 : {
15226 0 : std::cout << "SgModifierType :: " << std::flush;
15227 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
15228 0 : std::cout << " not valid " << std::endl;
15229 : }
15230 : }
15231 :
15232 0 : if ( p_rvalue_ref_to != NULL )
15233 : {
15234 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15235 : {
15236 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
15237 : {
15238 0 : std::cout << "SgModifierType :: ";
15239 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
15240 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
15241 : }
15242 : }
15243 : else
15244 : {
15245 0 : std::cout << "SgModifierType :: " << std::flush;
15246 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
15247 0 : std::cout << " not valid " << std::endl;
15248 : }
15249 : }
15250 :
15251 0 : if ( p_decltype_ref_to != NULL )
15252 : {
15253 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15254 : {
15255 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
15256 : {
15257 0 : std::cout << "SgModifierType :: ";
15258 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
15259 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
15260 : }
15261 : }
15262 : else
15263 : {
15264 0 : std::cout << "SgModifierType :: " << std::flush;
15265 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
15266 0 : std::cout << " not valid " << std::endl;
15267 : }
15268 : }
15269 :
15270 0 : if ( p_typeof_ref_to != NULL )
15271 : {
15272 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15273 : {
15274 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
15275 : {
15276 0 : std::cout << "SgModifierType :: ";
15277 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
15278 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
15279 : }
15280 : }
15281 : else
15282 : {
15283 0 : std::cout << "SgModifierType :: " << std::flush;
15284 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
15285 0 : std::cout << " not valid " << std::endl;
15286 : }
15287 : }
15288 :
15289 0 : if ( p_type_kind != NULL )
15290 : {
15291 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15292 : {
15293 0 : if ( p_type_kind->isInMemoryPool() == false )
15294 : {
15295 0 : std::cout << "SgModifierType :: ";
15296 0 : std::cout << " p_type_kind is not in memory pool of ";
15297 0 : std::cout << p_type_kind->class_name() << std::endl;
15298 : }
15299 : }
15300 : else
15301 : {
15302 0 : std::cout << "SgModifierType :: " << std::flush;
15303 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
15304 0 : std::cout << " not valid " << std::endl;
15305 : }
15306 : }
15307 :
15308 0 : if ( p_parent != NULL )
15309 : {
15310 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15311 : {
15312 0 : if ( p_parent->isInMemoryPool() == false )
15313 : {
15314 0 : std::cout << "SgModifierType :: ";
15315 0 : std::cout << " p_parent is not in memory pool of ";
15316 0 : std::cout << p_parent->class_name() << std::endl;
15317 : }
15318 : }
15319 : else
15320 : {
15321 0 : std::cout << "SgModifierType :: " << std::flush;
15322 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
15323 0 : std::cout << " not valid " << std::endl;
15324 : }
15325 : }
15326 :
15327 :
15328 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
15329 :
15330 0 : }
15331 :
15332 :
15333 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
15334 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
15335 : bool
15336 0 : SgModifierType::isInMemoryPool ()
15337 : {
15338 0 : typedef unsigned char* TestType;
15339 :
15340 0 : bool found = false;
15341 :
15342 0 : ROSE_ASSERT(this != NULL);
15343 :
15344 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
15345 :
15346 0 : TestType tested = (TestType) ( this ) ;
15347 :
15348 0 : std::vector < unsigned char* > :: const_iterator block = SgModifierType::pools.begin();
15349 :
15350 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
15351 : // while (found == false && block < Memory_Block_List.end())
15352 0 : while ( (found == false) && (block != SgModifierType::pools.end()) )
15353 : {
15354 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgModifierType::pool_size * sizeof(SgModifierType) ) ) ;
15355 0 : ++block;
15356 : }
15357 :
15358 : // Special handling for static data
15359 :
15360 :
15361 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
15362 0 : ROSE_ASSERT(found == true);
15363 :
15364 0 : return found;
15365 : }
15366 : /* #line 15367 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
15367 :
15368 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
15369 :
15370 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
15371 :
15372 : /* #line 15373 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
15373 :
15374 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
15375 :
15376 : void
15377 0 : SgFunctionType::checkDataMemberPointersIfInMemoryPool()
15378 : {
15379 : // ------------ checking pointers of SgFunctionType -------------------
15380 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
15381 :
15382 0 : if ( p_return_type != NULL )
15383 : {
15384 0 : if ( p_return_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15385 : {
15386 0 : if ( p_return_type->isInMemoryPool() == false )
15387 : {
15388 0 : std::cout << "SgFunctionType :: ";
15389 0 : std::cout << " p_return_type is not in memory pool of ";
15390 0 : std::cout << p_return_type->class_name() << std::endl;
15391 : }
15392 : }
15393 : else
15394 : {
15395 0 : std::cout << "SgFunctionType :: " << std::flush;
15396 0 : std::cout << "SgType* p_return_type = " << p_return_type << " --> " << std::flush;
15397 0 : std::cout << " not valid " << std::endl;
15398 : }
15399 : }
15400 :
15401 0 : if ( p_orig_return_type != NULL )
15402 : {
15403 0 : if ( p_orig_return_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15404 : {
15405 0 : if ( p_orig_return_type->isInMemoryPool() == false )
15406 : {
15407 0 : std::cout << "SgFunctionType :: ";
15408 0 : std::cout << " p_orig_return_type is not in memory pool of ";
15409 0 : std::cout << p_orig_return_type->class_name() << std::endl;
15410 : }
15411 : }
15412 : else
15413 : {
15414 0 : std::cout << "SgFunctionType :: " << std::flush;
15415 0 : std::cout << "SgType* p_orig_return_type = " << p_orig_return_type << " --> " << std::flush;
15416 0 : std::cout << " not valid " << std::endl;
15417 : }
15418 : }
15419 :
15420 0 : if ( p_argument_list != NULL )
15421 : {
15422 0 : if ( p_argument_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15423 : {
15424 0 : if ( p_argument_list->isInMemoryPool() == false )
15425 : {
15426 0 : std::cout << "SgFunctionType :: ";
15427 0 : std::cout << " p_argument_list is not in memory pool of ";
15428 0 : std::cout << p_argument_list->class_name() << std::endl;
15429 : }
15430 : }
15431 : else
15432 : {
15433 0 : std::cout << "SgFunctionType :: " << std::flush;
15434 0 : std::cout << "SgFunctionParameterTypeList* p_argument_list = " << p_argument_list << " --> " << std::flush;
15435 0 : std::cout << " not valid " << std::endl;
15436 : }
15437 : }
15438 :
15439 0 : if ( p_ref_to != NULL )
15440 : {
15441 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15442 : {
15443 0 : if ( p_ref_to->isInMemoryPool() == false )
15444 : {
15445 0 : std::cout << "SgFunctionType :: ";
15446 0 : std::cout << " p_ref_to is not in memory pool of ";
15447 0 : std::cout << p_ref_to->class_name() << std::endl;
15448 : }
15449 : }
15450 : else
15451 : {
15452 0 : std::cout << "SgFunctionType :: " << std::flush;
15453 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
15454 0 : std::cout << " not valid " << std::endl;
15455 : }
15456 : }
15457 :
15458 0 : if ( p_ptr_to != NULL )
15459 : {
15460 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15461 : {
15462 0 : if ( p_ptr_to->isInMemoryPool() == false )
15463 : {
15464 0 : std::cout << "SgFunctionType :: ";
15465 0 : std::cout << " p_ptr_to is not in memory pool of ";
15466 0 : std::cout << p_ptr_to->class_name() << std::endl;
15467 : }
15468 : }
15469 : else
15470 : {
15471 0 : std::cout << "SgFunctionType :: " << std::flush;
15472 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
15473 0 : std::cout << " not valid " << std::endl;
15474 : }
15475 : }
15476 :
15477 0 : if ( p_modifiers != NULL )
15478 : {
15479 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15480 : {
15481 0 : if ( p_modifiers->isInMemoryPool() == false )
15482 : {
15483 0 : std::cout << "SgFunctionType :: ";
15484 0 : std::cout << " p_modifiers is not in memory pool of ";
15485 0 : std::cout << p_modifiers->class_name() << std::endl;
15486 : }
15487 : }
15488 : else
15489 : {
15490 0 : std::cout << "SgFunctionType :: " << std::flush;
15491 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
15492 0 : std::cout << " not valid " << std::endl;
15493 : }
15494 : }
15495 :
15496 0 : if ( p_typedefs != NULL )
15497 : {
15498 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15499 : {
15500 0 : if ( p_typedefs->isInMemoryPool() == false )
15501 : {
15502 0 : std::cout << "SgFunctionType :: ";
15503 0 : std::cout << " p_typedefs is not in memory pool of ";
15504 0 : std::cout << p_typedefs->class_name() << std::endl;
15505 : }
15506 : }
15507 : else
15508 : {
15509 0 : std::cout << "SgFunctionType :: " << std::flush;
15510 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
15511 0 : std::cout << " not valid " << std::endl;
15512 : }
15513 : }
15514 :
15515 0 : if ( p_rvalue_ref_to != NULL )
15516 : {
15517 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15518 : {
15519 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
15520 : {
15521 0 : std::cout << "SgFunctionType :: ";
15522 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
15523 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
15524 : }
15525 : }
15526 : else
15527 : {
15528 0 : std::cout << "SgFunctionType :: " << std::flush;
15529 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
15530 0 : std::cout << " not valid " << std::endl;
15531 : }
15532 : }
15533 :
15534 0 : if ( p_decltype_ref_to != NULL )
15535 : {
15536 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15537 : {
15538 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
15539 : {
15540 0 : std::cout << "SgFunctionType :: ";
15541 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
15542 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
15543 : }
15544 : }
15545 : else
15546 : {
15547 0 : std::cout << "SgFunctionType :: " << std::flush;
15548 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
15549 0 : std::cout << " not valid " << std::endl;
15550 : }
15551 : }
15552 :
15553 0 : if ( p_typeof_ref_to != NULL )
15554 : {
15555 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15556 : {
15557 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
15558 : {
15559 0 : std::cout << "SgFunctionType :: ";
15560 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
15561 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
15562 : }
15563 : }
15564 : else
15565 : {
15566 0 : std::cout << "SgFunctionType :: " << std::flush;
15567 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
15568 0 : std::cout << " not valid " << std::endl;
15569 : }
15570 : }
15571 :
15572 0 : if ( p_type_kind != NULL )
15573 : {
15574 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15575 : {
15576 0 : if ( p_type_kind->isInMemoryPool() == false )
15577 : {
15578 0 : std::cout << "SgFunctionType :: ";
15579 0 : std::cout << " p_type_kind is not in memory pool of ";
15580 0 : std::cout << p_type_kind->class_name() << std::endl;
15581 : }
15582 : }
15583 : else
15584 : {
15585 0 : std::cout << "SgFunctionType :: " << std::flush;
15586 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
15587 0 : std::cout << " not valid " << std::endl;
15588 : }
15589 : }
15590 :
15591 0 : if ( p_parent != NULL )
15592 : {
15593 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15594 : {
15595 0 : if ( p_parent->isInMemoryPool() == false )
15596 : {
15597 0 : std::cout << "SgFunctionType :: ";
15598 0 : std::cout << " p_parent is not in memory pool of ";
15599 0 : std::cout << p_parent->class_name() << std::endl;
15600 : }
15601 : }
15602 : else
15603 : {
15604 0 : std::cout << "SgFunctionType :: " << std::flush;
15605 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
15606 0 : std::cout << " not valid " << std::endl;
15607 : }
15608 : }
15609 :
15610 :
15611 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
15612 :
15613 0 : }
15614 :
15615 :
15616 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
15617 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
15618 : bool
15619 0 : SgFunctionType::isInMemoryPool ()
15620 : {
15621 0 : typedef unsigned char* TestType;
15622 :
15623 0 : bool found = false;
15624 :
15625 0 : ROSE_ASSERT(this != NULL);
15626 :
15627 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
15628 :
15629 0 : TestType tested = (TestType) ( this ) ;
15630 :
15631 0 : std::vector < unsigned char* > :: const_iterator block = SgFunctionType::pools.begin();
15632 :
15633 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
15634 : // while (found == false && block < Memory_Block_List.end())
15635 0 : while ( (found == false) && (block != SgFunctionType::pools.end()) )
15636 : {
15637 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFunctionType::pool_size * sizeof(SgFunctionType) ) ) ;
15638 0 : ++block;
15639 : }
15640 :
15641 : // Special handling for static data
15642 :
15643 :
15644 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
15645 0 : ROSE_ASSERT(found == true);
15646 :
15647 0 : return found;
15648 : }
15649 : /* #line 15650 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
15650 :
15651 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
15652 :
15653 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
15654 :
15655 : /* #line 15656 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
15656 :
15657 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
15658 :
15659 : void
15660 0 : SgMemberFunctionType::checkDataMemberPointersIfInMemoryPool()
15661 : {
15662 : // ------------ checking pointers of SgMemberFunctionType -------------------
15663 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
15664 :
15665 0 : if ( p_class_type != NULL )
15666 : {
15667 0 : if ( p_class_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15668 : {
15669 0 : if ( p_class_type->isInMemoryPool() == false )
15670 : {
15671 0 : std::cout << "SgMemberFunctionType :: ";
15672 0 : std::cout << " p_class_type is not in memory pool of ";
15673 0 : std::cout << p_class_type->class_name() << std::endl;
15674 : }
15675 : }
15676 : else
15677 : {
15678 0 : std::cout << "SgMemberFunctionType :: " << std::flush;
15679 0 : std::cout << "SgType* p_class_type = " << p_class_type << " --> " << std::flush;
15680 0 : std::cout << " not valid " << std::endl;
15681 : }
15682 : }
15683 :
15684 0 : if ( p_return_type != NULL )
15685 : {
15686 0 : if ( p_return_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15687 : {
15688 0 : if ( p_return_type->isInMemoryPool() == false )
15689 : {
15690 0 : std::cout << "SgMemberFunctionType :: ";
15691 0 : std::cout << " p_return_type is not in memory pool of ";
15692 0 : std::cout << p_return_type->class_name() << std::endl;
15693 : }
15694 : }
15695 : else
15696 : {
15697 0 : std::cout << "SgMemberFunctionType :: " << std::flush;
15698 0 : std::cout << "SgType* p_return_type = " << p_return_type << " --> " << std::flush;
15699 0 : std::cout << " not valid " << std::endl;
15700 : }
15701 : }
15702 :
15703 0 : if ( p_orig_return_type != NULL )
15704 : {
15705 0 : if ( p_orig_return_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15706 : {
15707 0 : if ( p_orig_return_type->isInMemoryPool() == false )
15708 : {
15709 0 : std::cout << "SgMemberFunctionType :: ";
15710 0 : std::cout << " p_orig_return_type is not in memory pool of ";
15711 0 : std::cout << p_orig_return_type->class_name() << std::endl;
15712 : }
15713 : }
15714 : else
15715 : {
15716 0 : std::cout << "SgMemberFunctionType :: " << std::flush;
15717 0 : std::cout << "SgType* p_orig_return_type = " << p_orig_return_type << " --> " << std::flush;
15718 0 : std::cout << " not valid " << std::endl;
15719 : }
15720 : }
15721 :
15722 0 : if ( p_argument_list != NULL )
15723 : {
15724 0 : if ( p_argument_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15725 : {
15726 0 : if ( p_argument_list->isInMemoryPool() == false )
15727 : {
15728 0 : std::cout << "SgMemberFunctionType :: ";
15729 0 : std::cout << " p_argument_list is not in memory pool of ";
15730 0 : std::cout << p_argument_list->class_name() << std::endl;
15731 : }
15732 : }
15733 : else
15734 : {
15735 0 : std::cout << "SgMemberFunctionType :: " << std::flush;
15736 0 : std::cout << "SgFunctionParameterTypeList* p_argument_list = " << p_argument_list << " --> " << std::flush;
15737 0 : std::cout << " not valid " << std::endl;
15738 : }
15739 : }
15740 :
15741 0 : if ( p_ref_to != NULL )
15742 : {
15743 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15744 : {
15745 0 : if ( p_ref_to->isInMemoryPool() == false )
15746 : {
15747 0 : std::cout << "SgMemberFunctionType :: ";
15748 0 : std::cout << " p_ref_to is not in memory pool of ";
15749 0 : std::cout << p_ref_to->class_name() << std::endl;
15750 : }
15751 : }
15752 : else
15753 : {
15754 0 : std::cout << "SgMemberFunctionType :: " << std::flush;
15755 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
15756 0 : std::cout << " not valid " << std::endl;
15757 : }
15758 : }
15759 :
15760 0 : if ( p_ptr_to != NULL )
15761 : {
15762 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15763 : {
15764 0 : if ( p_ptr_to->isInMemoryPool() == false )
15765 : {
15766 0 : std::cout << "SgMemberFunctionType :: ";
15767 0 : std::cout << " p_ptr_to is not in memory pool of ";
15768 0 : std::cout << p_ptr_to->class_name() << std::endl;
15769 : }
15770 : }
15771 : else
15772 : {
15773 0 : std::cout << "SgMemberFunctionType :: " << std::flush;
15774 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
15775 0 : std::cout << " not valid " << std::endl;
15776 : }
15777 : }
15778 :
15779 0 : if ( p_modifiers != NULL )
15780 : {
15781 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15782 : {
15783 0 : if ( p_modifiers->isInMemoryPool() == false )
15784 : {
15785 0 : std::cout << "SgMemberFunctionType :: ";
15786 0 : std::cout << " p_modifiers is not in memory pool of ";
15787 0 : std::cout << p_modifiers->class_name() << std::endl;
15788 : }
15789 : }
15790 : else
15791 : {
15792 0 : std::cout << "SgMemberFunctionType :: " << std::flush;
15793 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
15794 0 : std::cout << " not valid " << std::endl;
15795 : }
15796 : }
15797 :
15798 0 : if ( p_typedefs != NULL )
15799 : {
15800 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15801 : {
15802 0 : if ( p_typedefs->isInMemoryPool() == false )
15803 : {
15804 0 : std::cout << "SgMemberFunctionType :: ";
15805 0 : std::cout << " p_typedefs is not in memory pool of ";
15806 0 : std::cout << p_typedefs->class_name() << std::endl;
15807 : }
15808 : }
15809 : else
15810 : {
15811 0 : std::cout << "SgMemberFunctionType :: " << std::flush;
15812 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
15813 0 : std::cout << " not valid " << std::endl;
15814 : }
15815 : }
15816 :
15817 0 : if ( p_rvalue_ref_to != NULL )
15818 : {
15819 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15820 : {
15821 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
15822 : {
15823 0 : std::cout << "SgMemberFunctionType :: ";
15824 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
15825 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
15826 : }
15827 : }
15828 : else
15829 : {
15830 0 : std::cout << "SgMemberFunctionType :: " << std::flush;
15831 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
15832 0 : std::cout << " not valid " << std::endl;
15833 : }
15834 : }
15835 :
15836 0 : if ( p_decltype_ref_to != NULL )
15837 : {
15838 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15839 : {
15840 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
15841 : {
15842 0 : std::cout << "SgMemberFunctionType :: ";
15843 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
15844 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
15845 : }
15846 : }
15847 : else
15848 : {
15849 0 : std::cout << "SgMemberFunctionType :: " << std::flush;
15850 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
15851 0 : std::cout << " not valid " << std::endl;
15852 : }
15853 : }
15854 :
15855 0 : if ( p_typeof_ref_to != NULL )
15856 : {
15857 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15858 : {
15859 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
15860 : {
15861 0 : std::cout << "SgMemberFunctionType :: ";
15862 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
15863 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
15864 : }
15865 : }
15866 : else
15867 : {
15868 0 : std::cout << "SgMemberFunctionType :: " << std::flush;
15869 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
15870 0 : std::cout << " not valid " << std::endl;
15871 : }
15872 : }
15873 :
15874 0 : if ( p_type_kind != NULL )
15875 : {
15876 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15877 : {
15878 0 : if ( p_type_kind->isInMemoryPool() == false )
15879 : {
15880 0 : std::cout << "SgMemberFunctionType :: ";
15881 0 : std::cout << " p_type_kind is not in memory pool of ";
15882 0 : std::cout << p_type_kind->class_name() << std::endl;
15883 : }
15884 : }
15885 : else
15886 : {
15887 0 : std::cout << "SgMemberFunctionType :: " << std::flush;
15888 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
15889 0 : std::cout << " not valid " << std::endl;
15890 : }
15891 : }
15892 :
15893 0 : if ( p_parent != NULL )
15894 : {
15895 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15896 : {
15897 0 : if ( p_parent->isInMemoryPool() == false )
15898 : {
15899 0 : std::cout << "SgMemberFunctionType :: ";
15900 0 : std::cout << " p_parent is not in memory pool of ";
15901 0 : std::cout << p_parent->class_name() << std::endl;
15902 : }
15903 : }
15904 : else
15905 : {
15906 0 : std::cout << "SgMemberFunctionType :: " << std::flush;
15907 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
15908 0 : std::cout << " not valid " << std::endl;
15909 : }
15910 : }
15911 :
15912 :
15913 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
15914 :
15915 0 : }
15916 :
15917 :
15918 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
15919 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
15920 : bool
15921 0 : SgMemberFunctionType::isInMemoryPool ()
15922 : {
15923 0 : typedef unsigned char* TestType;
15924 :
15925 0 : bool found = false;
15926 :
15927 0 : ROSE_ASSERT(this != NULL);
15928 :
15929 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
15930 :
15931 0 : TestType tested = (TestType) ( this ) ;
15932 :
15933 0 : std::vector < unsigned char* > :: const_iterator block = SgMemberFunctionType::pools.begin();
15934 :
15935 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
15936 : // while (found == false && block < Memory_Block_List.end())
15937 0 : while ( (found == false) && (block != SgMemberFunctionType::pools.end()) )
15938 : {
15939 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgMemberFunctionType::pool_size * sizeof(SgMemberFunctionType) ) ) ;
15940 0 : ++block;
15941 : }
15942 :
15943 : // Special handling for static data
15944 :
15945 :
15946 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
15947 0 : ROSE_ASSERT(found == true);
15948 :
15949 0 : return found;
15950 : }
15951 : /* #line 15952 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
15952 :
15953 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
15954 :
15955 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
15956 :
15957 : /* #line 15958 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
15958 :
15959 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
15960 :
15961 : void
15962 0 : SgPartialFunctionType::checkDataMemberPointersIfInMemoryPool()
15963 : {
15964 : // ------------ checking pointers of SgPartialFunctionType -------------------
15965 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
15966 :
15967 0 : if ( p_class_type != NULL )
15968 : {
15969 0 : if ( p_class_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15970 : {
15971 0 : if ( p_class_type->isInMemoryPool() == false )
15972 : {
15973 0 : std::cout << "SgPartialFunctionType :: ";
15974 0 : std::cout << " p_class_type is not in memory pool of ";
15975 0 : std::cout << p_class_type->class_name() << std::endl;
15976 : }
15977 : }
15978 : else
15979 : {
15980 0 : std::cout << "SgPartialFunctionType :: " << std::flush;
15981 0 : std::cout << "SgType* p_class_type = " << p_class_type << " --> " << std::flush;
15982 0 : std::cout << " not valid " << std::endl;
15983 : }
15984 : }
15985 :
15986 0 : if ( p_return_type != NULL )
15987 : {
15988 0 : if ( p_return_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
15989 : {
15990 0 : if ( p_return_type->isInMemoryPool() == false )
15991 : {
15992 0 : std::cout << "SgPartialFunctionType :: ";
15993 0 : std::cout << " p_return_type is not in memory pool of ";
15994 0 : std::cout << p_return_type->class_name() << std::endl;
15995 : }
15996 : }
15997 : else
15998 : {
15999 0 : std::cout << "SgPartialFunctionType :: " << std::flush;
16000 0 : std::cout << "SgType* p_return_type = " << p_return_type << " --> " << std::flush;
16001 0 : std::cout << " not valid " << std::endl;
16002 : }
16003 : }
16004 :
16005 0 : if ( p_orig_return_type != NULL )
16006 : {
16007 0 : if ( p_orig_return_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16008 : {
16009 0 : if ( p_orig_return_type->isInMemoryPool() == false )
16010 : {
16011 0 : std::cout << "SgPartialFunctionType :: ";
16012 0 : std::cout << " p_orig_return_type is not in memory pool of ";
16013 0 : std::cout << p_orig_return_type->class_name() << std::endl;
16014 : }
16015 : }
16016 : else
16017 : {
16018 0 : std::cout << "SgPartialFunctionType :: " << std::flush;
16019 0 : std::cout << "SgType* p_orig_return_type = " << p_orig_return_type << " --> " << std::flush;
16020 0 : std::cout << " not valid " << std::endl;
16021 : }
16022 : }
16023 :
16024 0 : if ( p_argument_list != NULL )
16025 : {
16026 0 : if ( p_argument_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16027 : {
16028 0 : if ( p_argument_list->isInMemoryPool() == false )
16029 : {
16030 0 : std::cout << "SgPartialFunctionType :: ";
16031 0 : std::cout << " p_argument_list is not in memory pool of ";
16032 0 : std::cout << p_argument_list->class_name() << std::endl;
16033 : }
16034 : }
16035 : else
16036 : {
16037 0 : std::cout << "SgPartialFunctionType :: " << std::flush;
16038 0 : std::cout << "SgFunctionParameterTypeList* p_argument_list = " << p_argument_list << " --> " << std::flush;
16039 0 : std::cout << " not valid " << std::endl;
16040 : }
16041 : }
16042 :
16043 0 : if ( p_ref_to != NULL )
16044 : {
16045 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16046 : {
16047 0 : if ( p_ref_to->isInMemoryPool() == false )
16048 : {
16049 0 : std::cout << "SgPartialFunctionType :: ";
16050 0 : std::cout << " p_ref_to is not in memory pool of ";
16051 0 : std::cout << p_ref_to->class_name() << std::endl;
16052 : }
16053 : }
16054 : else
16055 : {
16056 0 : std::cout << "SgPartialFunctionType :: " << std::flush;
16057 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
16058 0 : std::cout << " not valid " << std::endl;
16059 : }
16060 : }
16061 :
16062 0 : if ( p_ptr_to != NULL )
16063 : {
16064 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16065 : {
16066 0 : if ( p_ptr_to->isInMemoryPool() == false )
16067 : {
16068 0 : std::cout << "SgPartialFunctionType :: ";
16069 0 : std::cout << " p_ptr_to is not in memory pool of ";
16070 0 : std::cout << p_ptr_to->class_name() << std::endl;
16071 : }
16072 : }
16073 : else
16074 : {
16075 0 : std::cout << "SgPartialFunctionType :: " << std::flush;
16076 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
16077 0 : std::cout << " not valid " << std::endl;
16078 : }
16079 : }
16080 :
16081 0 : if ( p_modifiers != NULL )
16082 : {
16083 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16084 : {
16085 0 : if ( p_modifiers->isInMemoryPool() == false )
16086 : {
16087 0 : std::cout << "SgPartialFunctionType :: ";
16088 0 : std::cout << " p_modifiers is not in memory pool of ";
16089 0 : std::cout << p_modifiers->class_name() << std::endl;
16090 : }
16091 : }
16092 : else
16093 : {
16094 0 : std::cout << "SgPartialFunctionType :: " << std::flush;
16095 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
16096 0 : std::cout << " not valid " << std::endl;
16097 : }
16098 : }
16099 :
16100 0 : if ( p_typedefs != NULL )
16101 : {
16102 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16103 : {
16104 0 : if ( p_typedefs->isInMemoryPool() == false )
16105 : {
16106 0 : std::cout << "SgPartialFunctionType :: ";
16107 0 : std::cout << " p_typedefs is not in memory pool of ";
16108 0 : std::cout << p_typedefs->class_name() << std::endl;
16109 : }
16110 : }
16111 : else
16112 : {
16113 0 : std::cout << "SgPartialFunctionType :: " << std::flush;
16114 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
16115 0 : std::cout << " not valid " << std::endl;
16116 : }
16117 : }
16118 :
16119 0 : if ( p_rvalue_ref_to != NULL )
16120 : {
16121 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16122 : {
16123 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
16124 : {
16125 0 : std::cout << "SgPartialFunctionType :: ";
16126 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
16127 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
16128 : }
16129 : }
16130 : else
16131 : {
16132 0 : std::cout << "SgPartialFunctionType :: " << std::flush;
16133 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
16134 0 : std::cout << " not valid " << std::endl;
16135 : }
16136 : }
16137 :
16138 0 : if ( p_decltype_ref_to != NULL )
16139 : {
16140 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16141 : {
16142 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
16143 : {
16144 0 : std::cout << "SgPartialFunctionType :: ";
16145 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
16146 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
16147 : }
16148 : }
16149 : else
16150 : {
16151 0 : std::cout << "SgPartialFunctionType :: " << std::flush;
16152 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
16153 0 : std::cout << " not valid " << std::endl;
16154 : }
16155 : }
16156 :
16157 0 : if ( p_typeof_ref_to != NULL )
16158 : {
16159 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16160 : {
16161 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
16162 : {
16163 0 : std::cout << "SgPartialFunctionType :: ";
16164 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
16165 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
16166 : }
16167 : }
16168 : else
16169 : {
16170 0 : std::cout << "SgPartialFunctionType :: " << std::flush;
16171 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
16172 0 : std::cout << " not valid " << std::endl;
16173 : }
16174 : }
16175 :
16176 0 : if ( p_type_kind != NULL )
16177 : {
16178 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16179 : {
16180 0 : if ( p_type_kind->isInMemoryPool() == false )
16181 : {
16182 0 : std::cout << "SgPartialFunctionType :: ";
16183 0 : std::cout << " p_type_kind is not in memory pool of ";
16184 0 : std::cout << p_type_kind->class_name() << std::endl;
16185 : }
16186 : }
16187 : else
16188 : {
16189 0 : std::cout << "SgPartialFunctionType :: " << std::flush;
16190 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
16191 0 : std::cout << " not valid " << std::endl;
16192 : }
16193 : }
16194 :
16195 0 : if ( p_parent != NULL )
16196 : {
16197 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16198 : {
16199 0 : if ( p_parent->isInMemoryPool() == false )
16200 : {
16201 0 : std::cout << "SgPartialFunctionType :: ";
16202 0 : std::cout << " p_parent is not in memory pool of ";
16203 0 : std::cout << p_parent->class_name() << std::endl;
16204 : }
16205 : }
16206 : else
16207 : {
16208 0 : std::cout << "SgPartialFunctionType :: " << std::flush;
16209 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
16210 0 : std::cout << " not valid " << std::endl;
16211 : }
16212 : }
16213 :
16214 :
16215 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
16216 :
16217 0 : }
16218 :
16219 :
16220 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
16221 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
16222 : bool
16223 0 : SgPartialFunctionType::isInMemoryPool ()
16224 : {
16225 0 : typedef unsigned char* TestType;
16226 :
16227 0 : bool found = false;
16228 :
16229 0 : ROSE_ASSERT(this != NULL);
16230 :
16231 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
16232 :
16233 0 : TestType tested = (TestType) ( this ) ;
16234 :
16235 0 : std::vector < unsigned char* > :: const_iterator block = SgPartialFunctionType::pools.begin();
16236 :
16237 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
16238 : // while (found == false && block < Memory_Block_List.end())
16239 0 : while ( (found == false) && (block != SgPartialFunctionType::pools.end()) )
16240 : {
16241 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgPartialFunctionType::pool_size * sizeof(SgPartialFunctionType) ) ) ;
16242 0 : ++block;
16243 : }
16244 :
16245 : // Special handling for static data
16246 :
16247 :
16248 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
16249 0 : ROSE_ASSERT(found == true);
16250 :
16251 0 : return found;
16252 : }
16253 : /* #line 16254 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
16254 :
16255 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
16256 :
16257 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
16258 :
16259 : /* #line 16260 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
16260 :
16261 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
16262 :
16263 : void
16264 0 : SgPartialFunctionModifierType::checkDataMemberPointersIfInMemoryPool()
16265 : {
16266 : // ------------ checking pointers of SgPartialFunctionModifierType -------------------
16267 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
16268 :
16269 0 : if ( p_class_type != NULL )
16270 : {
16271 0 : if ( p_class_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16272 : {
16273 0 : if ( p_class_type->isInMemoryPool() == false )
16274 : {
16275 0 : std::cout << "SgPartialFunctionModifierType :: ";
16276 0 : std::cout << " p_class_type is not in memory pool of ";
16277 0 : std::cout << p_class_type->class_name() << std::endl;
16278 : }
16279 : }
16280 : else
16281 : {
16282 0 : std::cout << "SgPartialFunctionModifierType :: " << std::flush;
16283 0 : std::cout << "SgType* p_class_type = " << p_class_type << " --> " << std::flush;
16284 0 : std::cout << " not valid " << std::endl;
16285 : }
16286 : }
16287 :
16288 0 : if ( p_return_type != NULL )
16289 : {
16290 0 : if ( p_return_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16291 : {
16292 0 : if ( p_return_type->isInMemoryPool() == false )
16293 : {
16294 0 : std::cout << "SgPartialFunctionModifierType :: ";
16295 0 : std::cout << " p_return_type is not in memory pool of ";
16296 0 : std::cout << p_return_type->class_name() << std::endl;
16297 : }
16298 : }
16299 : else
16300 : {
16301 0 : std::cout << "SgPartialFunctionModifierType :: " << std::flush;
16302 0 : std::cout << "SgType* p_return_type = " << p_return_type << " --> " << std::flush;
16303 0 : std::cout << " not valid " << std::endl;
16304 : }
16305 : }
16306 :
16307 0 : if ( p_orig_return_type != NULL )
16308 : {
16309 0 : if ( p_orig_return_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16310 : {
16311 0 : if ( p_orig_return_type->isInMemoryPool() == false )
16312 : {
16313 0 : std::cout << "SgPartialFunctionModifierType :: ";
16314 0 : std::cout << " p_orig_return_type is not in memory pool of ";
16315 0 : std::cout << p_orig_return_type->class_name() << std::endl;
16316 : }
16317 : }
16318 : else
16319 : {
16320 0 : std::cout << "SgPartialFunctionModifierType :: " << std::flush;
16321 0 : std::cout << "SgType* p_orig_return_type = " << p_orig_return_type << " --> " << std::flush;
16322 0 : std::cout << " not valid " << std::endl;
16323 : }
16324 : }
16325 :
16326 0 : if ( p_argument_list != NULL )
16327 : {
16328 0 : if ( p_argument_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16329 : {
16330 0 : if ( p_argument_list->isInMemoryPool() == false )
16331 : {
16332 0 : std::cout << "SgPartialFunctionModifierType :: ";
16333 0 : std::cout << " p_argument_list is not in memory pool of ";
16334 0 : std::cout << p_argument_list->class_name() << std::endl;
16335 : }
16336 : }
16337 : else
16338 : {
16339 0 : std::cout << "SgPartialFunctionModifierType :: " << std::flush;
16340 0 : std::cout << "SgFunctionParameterTypeList* p_argument_list = " << p_argument_list << " --> " << std::flush;
16341 0 : std::cout << " not valid " << std::endl;
16342 : }
16343 : }
16344 :
16345 0 : if ( p_ref_to != NULL )
16346 : {
16347 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16348 : {
16349 0 : if ( p_ref_to->isInMemoryPool() == false )
16350 : {
16351 0 : std::cout << "SgPartialFunctionModifierType :: ";
16352 0 : std::cout << " p_ref_to is not in memory pool of ";
16353 0 : std::cout << p_ref_to->class_name() << std::endl;
16354 : }
16355 : }
16356 : else
16357 : {
16358 0 : std::cout << "SgPartialFunctionModifierType :: " << std::flush;
16359 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
16360 0 : std::cout << " not valid " << std::endl;
16361 : }
16362 : }
16363 :
16364 0 : if ( p_ptr_to != NULL )
16365 : {
16366 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16367 : {
16368 0 : if ( p_ptr_to->isInMemoryPool() == false )
16369 : {
16370 0 : std::cout << "SgPartialFunctionModifierType :: ";
16371 0 : std::cout << " p_ptr_to is not in memory pool of ";
16372 0 : std::cout << p_ptr_to->class_name() << std::endl;
16373 : }
16374 : }
16375 : else
16376 : {
16377 0 : std::cout << "SgPartialFunctionModifierType :: " << std::flush;
16378 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
16379 0 : std::cout << " not valid " << std::endl;
16380 : }
16381 : }
16382 :
16383 0 : if ( p_modifiers != NULL )
16384 : {
16385 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16386 : {
16387 0 : if ( p_modifiers->isInMemoryPool() == false )
16388 : {
16389 0 : std::cout << "SgPartialFunctionModifierType :: ";
16390 0 : std::cout << " p_modifiers is not in memory pool of ";
16391 0 : std::cout << p_modifiers->class_name() << std::endl;
16392 : }
16393 : }
16394 : else
16395 : {
16396 0 : std::cout << "SgPartialFunctionModifierType :: " << std::flush;
16397 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
16398 0 : std::cout << " not valid " << std::endl;
16399 : }
16400 : }
16401 :
16402 0 : if ( p_typedefs != NULL )
16403 : {
16404 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16405 : {
16406 0 : if ( p_typedefs->isInMemoryPool() == false )
16407 : {
16408 0 : std::cout << "SgPartialFunctionModifierType :: ";
16409 0 : std::cout << " p_typedefs is not in memory pool of ";
16410 0 : std::cout << p_typedefs->class_name() << std::endl;
16411 : }
16412 : }
16413 : else
16414 : {
16415 0 : std::cout << "SgPartialFunctionModifierType :: " << std::flush;
16416 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
16417 0 : std::cout << " not valid " << std::endl;
16418 : }
16419 : }
16420 :
16421 0 : if ( p_rvalue_ref_to != NULL )
16422 : {
16423 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16424 : {
16425 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
16426 : {
16427 0 : std::cout << "SgPartialFunctionModifierType :: ";
16428 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
16429 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
16430 : }
16431 : }
16432 : else
16433 : {
16434 0 : std::cout << "SgPartialFunctionModifierType :: " << std::flush;
16435 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
16436 0 : std::cout << " not valid " << std::endl;
16437 : }
16438 : }
16439 :
16440 0 : if ( p_decltype_ref_to != NULL )
16441 : {
16442 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16443 : {
16444 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
16445 : {
16446 0 : std::cout << "SgPartialFunctionModifierType :: ";
16447 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
16448 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
16449 : }
16450 : }
16451 : else
16452 : {
16453 0 : std::cout << "SgPartialFunctionModifierType :: " << std::flush;
16454 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
16455 0 : std::cout << " not valid " << std::endl;
16456 : }
16457 : }
16458 :
16459 0 : if ( p_typeof_ref_to != NULL )
16460 : {
16461 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16462 : {
16463 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
16464 : {
16465 0 : std::cout << "SgPartialFunctionModifierType :: ";
16466 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
16467 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
16468 : }
16469 : }
16470 : else
16471 : {
16472 0 : std::cout << "SgPartialFunctionModifierType :: " << std::flush;
16473 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
16474 0 : std::cout << " not valid " << std::endl;
16475 : }
16476 : }
16477 :
16478 0 : if ( p_type_kind != NULL )
16479 : {
16480 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16481 : {
16482 0 : if ( p_type_kind->isInMemoryPool() == false )
16483 : {
16484 0 : std::cout << "SgPartialFunctionModifierType :: ";
16485 0 : std::cout << " p_type_kind is not in memory pool of ";
16486 0 : std::cout << p_type_kind->class_name() << std::endl;
16487 : }
16488 : }
16489 : else
16490 : {
16491 0 : std::cout << "SgPartialFunctionModifierType :: " << std::flush;
16492 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
16493 0 : std::cout << " not valid " << std::endl;
16494 : }
16495 : }
16496 :
16497 0 : if ( p_parent != NULL )
16498 : {
16499 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16500 : {
16501 0 : if ( p_parent->isInMemoryPool() == false )
16502 : {
16503 0 : std::cout << "SgPartialFunctionModifierType :: ";
16504 0 : std::cout << " p_parent is not in memory pool of ";
16505 0 : std::cout << p_parent->class_name() << std::endl;
16506 : }
16507 : }
16508 : else
16509 : {
16510 0 : std::cout << "SgPartialFunctionModifierType :: " << std::flush;
16511 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
16512 0 : std::cout << " not valid " << std::endl;
16513 : }
16514 : }
16515 :
16516 :
16517 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
16518 :
16519 0 : }
16520 :
16521 :
16522 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
16523 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
16524 : bool
16525 0 : SgPartialFunctionModifierType::isInMemoryPool ()
16526 : {
16527 0 : typedef unsigned char* TestType;
16528 :
16529 0 : bool found = false;
16530 :
16531 0 : ROSE_ASSERT(this != NULL);
16532 :
16533 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
16534 :
16535 0 : TestType tested = (TestType) ( this ) ;
16536 :
16537 0 : std::vector < unsigned char* > :: const_iterator block = SgPartialFunctionModifierType::pools.begin();
16538 :
16539 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
16540 : // while (found == false && block < Memory_Block_List.end())
16541 0 : while ( (found == false) && (block != SgPartialFunctionModifierType::pools.end()) )
16542 : {
16543 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgPartialFunctionModifierType::pool_size * sizeof(SgPartialFunctionModifierType) ) ) ;
16544 0 : ++block;
16545 : }
16546 :
16547 : // Special handling for static data
16548 :
16549 :
16550 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
16551 0 : ROSE_ASSERT(found == true);
16552 :
16553 0 : return found;
16554 : }
16555 : /* #line 16556 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
16556 :
16557 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
16558 :
16559 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
16560 :
16561 : /* #line 16562 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
16562 :
16563 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
16564 :
16565 : void
16566 0 : SgArrayType::checkDataMemberPointersIfInMemoryPool()
16567 : {
16568 : // ------------ checking pointers of SgArrayType -------------------
16569 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
16570 :
16571 0 : if ( p_base_type != NULL )
16572 : {
16573 0 : if ( p_base_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16574 : {
16575 0 : if ( p_base_type->isInMemoryPool() == false )
16576 : {
16577 0 : std::cout << "SgArrayType :: ";
16578 0 : std::cout << " p_base_type is not in memory pool of ";
16579 0 : std::cout << p_base_type->class_name() << std::endl;
16580 : }
16581 : }
16582 : else
16583 : {
16584 0 : std::cout << "SgArrayType :: " << std::flush;
16585 0 : std::cout << "SgType* p_base_type = " << p_base_type << " --> " << std::flush;
16586 0 : std::cout << " not valid " << std::endl;
16587 : }
16588 : }
16589 :
16590 0 : if ( p_index != NULL )
16591 : {
16592 0 : if ( p_index->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16593 : {
16594 0 : if ( p_index->isInMemoryPool() == false )
16595 : {
16596 0 : std::cout << "SgArrayType :: ";
16597 0 : std::cout << " p_index is not in memory pool of ";
16598 0 : std::cout << p_index->class_name() << std::endl;
16599 : }
16600 : }
16601 : else
16602 : {
16603 0 : std::cout << "SgArrayType :: " << std::flush;
16604 0 : std::cout << "SgExpression* p_index = " << p_index << " --> " << std::flush;
16605 0 : std::cout << " not valid " << std::endl;
16606 : }
16607 : }
16608 :
16609 0 : if ( p_dim_info != NULL )
16610 : {
16611 0 : if ( p_dim_info->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16612 : {
16613 0 : if ( p_dim_info->isInMemoryPool() == false )
16614 : {
16615 0 : std::cout << "SgArrayType :: ";
16616 0 : std::cout << " p_dim_info is not in memory pool of ";
16617 0 : std::cout << p_dim_info->class_name() << std::endl;
16618 : }
16619 : }
16620 : else
16621 : {
16622 0 : std::cout << "SgArrayType :: " << std::flush;
16623 0 : std::cout << "SgExprListExp* p_dim_info = " << p_dim_info << " --> " << std::flush;
16624 0 : std::cout << " not valid " << std::endl;
16625 : }
16626 : }
16627 :
16628 0 : if ( p_ref_to != NULL )
16629 : {
16630 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16631 : {
16632 0 : if ( p_ref_to->isInMemoryPool() == false )
16633 : {
16634 0 : std::cout << "SgArrayType :: ";
16635 0 : std::cout << " p_ref_to is not in memory pool of ";
16636 0 : std::cout << p_ref_to->class_name() << std::endl;
16637 : }
16638 : }
16639 : else
16640 : {
16641 0 : std::cout << "SgArrayType :: " << std::flush;
16642 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
16643 0 : std::cout << " not valid " << std::endl;
16644 : }
16645 : }
16646 :
16647 0 : if ( p_ptr_to != NULL )
16648 : {
16649 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16650 : {
16651 0 : if ( p_ptr_to->isInMemoryPool() == false )
16652 : {
16653 0 : std::cout << "SgArrayType :: ";
16654 0 : std::cout << " p_ptr_to is not in memory pool of ";
16655 0 : std::cout << p_ptr_to->class_name() << std::endl;
16656 : }
16657 : }
16658 : else
16659 : {
16660 0 : std::cout << "SgArrayType :: " << std::flush;
16661 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
16662 0 : std::cout << " not valid " << std::endl;
16663 : }
16664 : }
16665 :
16666 0 : if ( p_modifiers != NULL )
16667 : {
16668 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16669 : {
16670 0 : if ( p_modifiers->isInMemoryPool() == false )
16671 : {
16672 0 : std::cout << "SgArrayType :: ";
16673 0 : std::cout << " p_modifiers is not in memory pool of ";
16674 0 : std::cout << p_modifiers->class_name() << std::endl;
16675 : }
16676 : }
16677 : else
16678 : {
16679 0 : std::cout << "SgArrayType :: " << std::flush;
16680 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
16681 0 : std::cout << " not valid " << std::endl;
16682 : }
16683 : }
16684 :
16685 0 : if ( p_typedefs != NULL )
16686 : {
16687 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16688 : {
16689 0 : if ( p_typedefs->isInMemoryPool() == false )
16690 : {
16691 0 : std::cout << "SgArrayType :: ";
16692 0 : std::cout << " p_typedefs is not in memory pool of ";
16693 0 : std::cout << p_typedefs->class_name() << std::endl;
16694 : }
16695 : }
16696 : else
16697 : {
16698 0 : std::cout << "SgArrayType :: " << std::flush;
16699 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
16700 0 : std::cout << " not valid " << std::endl;
16701 : }
16702 : }
16703 :
16704 0 : if ( p_rvalue_ref_to != NULL )
16705 : {
16706 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16707 : {
16708 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
16709 : {
16710 0 : std::cout << "SgArrayType :: ";
16711 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
16712 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
16713 : }
16714 : }
16715 : else
16716 : {
16717 0 : std::cout << "SgArrayType :: " << std::flush;
16718 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
16719 0 : std::cout << " not valid " << std::endl;
16720 : }
16721 : }
16722 :
16723 0 : if ( p_decltype_ref_to != NULL )
16724 : {
16725 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16726 : {
16727 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
16728 : {
16729 0 : std::cout << "SgArrayType :: ";
16730 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
16731 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
16732 : }
16733 : }
16734 : else
16735 : {
16736 0 : std::cout << "SgArrayType :: " << std::flush;
16737 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
16738 0 : std::cout << " not valid " << std::endl;
16739 : }
16740 : }
16741 :
16742 0 : if ( p_typeof_ref_to != NULL )
16743 : {
16744 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16745 : {
16746 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
16747 : {
16748 0 : std::cout << "SgArrayType :: ";
16749 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
16750 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
16751 : }
16752 : }
16753 : else
16754 : {
16755 0 : std::cout << "SgArrayType :: " << std::flush;
16756 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
16757 0 : std::cout << " not valid " << std::endl;
16758 : }
16759 : }
16760 :
16761 0 : if ( p_type_kind != NULL )
16762 : {
16763 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16764 : {
16765 0 : if ( p_type_kind->isInMemoryPool() == false )
16766 : {
16767 0 : std::cout << "SgArrayType :: ";
16768 0 : std::cout << " p_type_kind is not in memory pool of ";
16769 0 : std::cout << p_type_kind->class_name() << std::endl;
16770 : }
16771 : }
16772 : else
16773 : {
16774 0 : std::cout << "SgArrayType :: " << std::flush;
16775 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
16776 0 : std::cout << " not valid " << std::endl;
16777 : }
16778 : }
16779 :
16780 0 : if ( p_parent != NULL )
16781 : {
16782 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16783 : {
16784 0 : if ( p_parent->isInMemoryPool() == false )
16785 : {
16786 0 : std::cout << "SgArrayType :: ";
16787 0 : std::cout << " p_parent is not in memory pool of ";
16788 0 : std::cout << p_parent->class_name() << std::endl;
16789 : }
16790 : }
16791 : else
16792 : {
16793 0 : std::cout << "SgArrayType :: " << std::flush;
16794 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
16795 0 : std::cout << " not valid " << std::endl;
16796 : }
16797 : }
16798 :
16799 :
16800 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
16801 :
16802 0 : }
16803 :
16804 :
16805 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
16806 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
16807 : bool
16808 0 : SgArrayType::isInMemoryPool ()
16809 : {
16810 0 : typedef unsigned char* TestType;
16811 :
16812 0 : bool found = false;
16813 :
16814 0 : ROSE_ASSERT(this != NULL);
16815 :
16816 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
16817 :
16818 0 : TestType tested = (TestType) ( this ) ;
16819 :
16820 0 : std::vector < unsigned char* > :: const_iterator block = SgArrayType::pools.begin();
16821 :
16822 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
16823 : // while (found == false && block < Memory_Block_List.end())
16824 0 : while ( (found == false) && (block != SgArrayType::pools.end()) )
16825 : {
16826 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgArrayType::pool_size * sizeof(SgArrayType) ) ) ;
16827 0 : ++block;
16828 : }
16829 :
16830 : // Special handling for static data
16831 :
16832 :
16833 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
16834 0 : ROSE_ASSERT(found == true);
16835 :
16836 0 : return found;
16837 : }
16838 : /* #line 16839 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
16839 :
16840 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
16841 :
16842 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
16843 :
16844 : /* #line 16845 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
16845 :
16846 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
16847 :
16848 : void
16849 0 : SgTypeEllipse::checkDataMemberPointersIfInMemoryPool()
16850 : {
16851 : // ------------ checking pointers of SgTypeEllipse -------------------
16852 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
16853 :
16854 0 : if ( p_ref_to != NULL )
16855 : {
16856 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16857 : {
16858 0 : if ( p_ref_to->isInMemoryPool() == false )
16859 : {
16860 0 : std::cout << "SgTypeEllipse :: ";
16861 0 : std::cout << " p_ref_to is not in memory pool of ";
16862 0 : std::cout << p_ref_to->class_name() << std::endl;
16863 : }
16864 : }
16865 : else
16866 : {
16867 0 : std::cout << "SgTypeEllipse :: " << std::flush;
16868 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
16869 0 : std::cout << " not valid " << std::endl;
16870 : }
16871 : }
16872 :
16873 0 : if ( p_ptr_to != NULL )
16874 : {
16875 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16876 : {
16877 0 : if ( p_ptr_to->isInMemoryPool() == false )
16878 : {
16879 0 : std::cout << "SgTypeEllipse :: ";
16880 0 : std::cout << " p_ptr_to is not in memory pool of ";
16881 0 : std::cout << p_ptr_to->class_name() << std::endl;
16882 : }
16883 : }
16884 : else
16885 : {
16886 0 : std::cout << "SgTypeEllipse :: " << std::flush;
16887 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
16888 0 : std::cout << " not valid " << std::endl;
16889 : }
16890 : }
16891 :
16892 0 : if ( p_modifiers != NULL )
16893 : {
16894 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16895 : {
16896 0 : if ( p_modifiers->isInMemoryPool() == false )
16897 : {
16898 0 : std::cout << "SgTypeEllipse :: ";
16899 0 : std::cout << " p_modifiers is not in memory pool of ";
16900 0 : std::cout << p_modifiers->class_name() << std::endl;
16901 : }
16902 : }
16903 : else
16904 : {
16905 0 : std::cout << "SgTypeEllipse :: " << std::flush;
16906 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
16907 0 : std::cout << " not valid " << std::endl;
16908 : }
16909 : }
16910 :
16911 0 : if ( p_typedefs != NULL )
16912 : {
16913 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16914 : {
16915 0 : if ( p_typedefs->isInMemoryPool() == false )
16916 : {
16917 0 : std::cout << "SgTypeEllipse :: ";
16918 0 : std::cout << " p_typedefs is not in memory pool of ";
16919 0 : std::cout << p_typedefs->class_name() << std::endl;
16920 : }
16921 : }
16922 : else
16923 : {
16924 0 : std::cout << "SgTypeEllipse :: " << std::flush;
16925 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
16926 0 : std::cout << " not valid " << std::endl;
16927 : }
16928 : }
16929 :
16930 0 : if ( p_rvalue_ref_to != NULL )
16931 : {
16932 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16933 : {
16934 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
16935 : {
16936 0 : std::cout << "SgTypeEllipse :: ";
16937 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
16938 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
16939 : }
16940 : }
16941 : else
16942 : {
16943 0 : std::cout << "SgTypeEllipse :: " << std::flush;
16944 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
16945 0 : std::cout << " not valid " << std::endl;
16946 : }
16947 : }
16948 :
16949 0 : if ( p_decltype_ref_to != NULL )
16950 : {
16951 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16952 : {
16953 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
16954 : {
16955 0 : std::cout << "SgTypeEllipse :: ";
16956 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
16957 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
16958 : }
16959 : }
16960 : else
16961 : {
16962 0 : std::cout << "SgTypeEllipse :: " << std::flush;
16963 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
16964 0 : std::cout << " not valid " << std::endl;
16965 : }
16966 : }
16967 :
16968 0 : if ( p_typeof_ref_to != NULL )
16969 : {
16970 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16971 : {
16972 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
16973 : {
16974 0 : std::cout << "SgTypeEllipse :: ";
16975 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
16976 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
16977 : }
16978 : }
16979 : else
16980 : {
16981 0 : std::cout << "SgTypeEllipse :: " << std::flush;
16982 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
16983 0 : std::cout << " not valid " << std::endl;
16984 : }
16985 : }
16986 :
16987 0 : if ( p_type_kind != NULL )
16988 : {
16989 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
16990 : {
16991 0 : if ( p_type_kind->isInMemoryPool() == false )
16992 : {
16993 0 : std::cout << "SgTypeEllipse :: ";
16994 0 : std::cout << " p_type_kind is not in memory pool of ";
16995 0 : std::cout << p_type_kind->class_name() << std::endl;
16996 : }
16997 : }
16998 : else
16999 : {
17000 0 : std::cout << "SgTypeEllipse :: " << std::flush;
17001 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
17002 0 : std::cout << " not valid " << std::endl;
17003 : }
17004 : }
17005 :
17006 0 : if ( p_parent != NULL )
17007 : {
17008 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17009 : {
17010 0 : if ( p_parent->isInMemoryPool() == false )
17011 : {
17012 0 : std::cout << "SgTypeEllipse :: ";
17013 0 : std::cout << " p_parent is not in memory pool of ";
17014 0 : std::cout << p_parent->class_name() << std::endl;
17015 : }
17016 : }
17017 : else
17018 : {
17019 0 : std::cout << "SgTypeEllipse :: " << std::flush;
17020 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
17021 0 : std::cout << " not valid " << std::endl;
17022 : }
17023 : }
17024 :
17025 :
17026 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
17027 :
17028 0 : }
17029 :
17030 :
17031 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
17032 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
17033 : bool
17034 0 : SgTypeEllipse::isInMemoryPool ()
17035 : {
17036 0 : typedef unsigned char* TestType;
17037 :
17038 0 : bool found = false;
17039 :
17040 0 : ROSE_ASSERT(this != NULL);
17041 :
17042 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
17043 :
17044 0 : TestType tested = (TestType) ( this ) ;
17045 :
17046 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeEllipse::pools.begin();
17047 :
17048 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
17049 : // while (found == false && block < Memory_Block_List.end())
17050 0 : while ( (found == false) && (block != SgTypeEllipse::pools.end()) )
17051 : {
17052 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeEllipse::pool_size * sizeof(SgTypeEllipse) ) ) ;
17053 0 : ++block;
17054 : }
17055 :
17056 : // Special handling for static data
17057 :
17058 :
17059 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
17060 0 : ROSE_ASSERT(found == true);
17061 :
17062 0 : return found;
17063 : }
17064 : /* #line 17065 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
17065 :
17066 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
17067 :
17068 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
17069 :
17070 : /* #line 17071 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
17071 :
17072 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
17073 :
17074 : void
17075 0 : SgTemplateType::checkDataMemberPointersIfInMemoryPool()
17076 : {
17077 : // ------------ checking pointers of SgTemplateType -------------------
17078 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
17079 :
17080 0 : if ( p_class_type != NULL )
17081 : {
17082 0 : if ( p_class_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17083 : {
17084 0 : if ( p_class_type->isInMemoryPool() == false )
17085 : {
17086 0 : std::cout << "SgTemplateType :: ";
17087 0 : std::cout << " p_class_type is not in memory pool of ";
17088 0 : std::cout << p_class_type->class_name() << std::endl;
17089 : }
17090 : }
17091 : else
17092 : {
17093 0 : std::cout << "SgTemplateType :: " << std::flush;
17094 0 : std::cout << "SgType * p_class_type = " << p_class_type << " --> " << std::flush;
17095 0 : std::cout << " not valid " << std::endl;
17096 : }
17097 : }
17098 :
17099 0 : if ( p_parent_class_type != NULL )
17100 : {
17101 0 : if ( p_parent_class_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17102 : {
17103 0 : if ( p_parent_class_type->isInMemoryPool() == false )
17104 : {
17105 0 : std::cout << "SgTemplateType :: ";
17106 0 : std::cout << " p_parent_class_type is not in memory pool of ";
17107 0 : std::cout << p_parent_class_type->class_name() << std::endl;
17108 : }
17109 : }
17110 : else
17111 : {
17112 0 : std::cout << "SgTemplateType :: " << std::flush;
17113 0 : std::cout << "SgType * p_parent_class_type = " << p_parent_class_type << " --> " << std::flush;
17114 0 : std::cout << " not valid " << std::endl;
17115 : }
17116 : }
17117 :
17118 0 : if ( p_template_parameter != NULL )
17119 : {
17120 0 : if ( p_template_parameter->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17121 : {
17122 0 : if ( p_template_parameter->isInMemoryPool() == false )
17123 : {
17124 0 : std::cout << "SgTemplateType :: ";
17125 0 : std::cout << " p_template_parameter is not in memory pool of ";
17126 0 : std::cout << p_template_parameter->class_name() << std::endl;
17127 : }
17128 : }
17129 : else
17130 : {
17131 0 : std::cout << "SgTemplateType :: " << std::flush;
17132 0 : std::cout << "SgTemplateParameter * p_template_parameter = " << p_template_parameter << " --> " << std::flush;
17133 0 : std::cout << " not valid " << std::endl;
17134 : }
17135 : }
17136 :
17137 0 : SgTemplateArgumentPtrList::iterator i_tpl_args = p_tpl_args.begin() ;
17138 0 : for ( ; i_tpl_args != p_tpl_args.end(); ++i_tpl_args )
17139 : {
17140 0 : if ( (*i_tpl_args) != NULL )
17141 : {
17142 0 : if ( (*i_tpl_args)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17143 : {
17144 0 : if ( (*i_tpl_args)->isInMemoryPool() == false )
17145 : {
17146 0 : std::cout << "SgTemplateType :: ";
17147 0 : std::cout << " p_tpl_args ( list of poitners to IR nodes ), entry is not in memory pool of ";
17148 0 : std::cout << (*i_tpl_args)->class_name() << std::endl;
17149 : }
17150 : }
17151 : else
17152 : {
17153 0 : std::cout << "SgTemplateType :: " << std::flush;
17154 0 : std::cout << "SgTemplateArgumentPtrList p_tpl_args --> " << std::flush;
17155 0 : std::cout << " entry not valid " << std::endl;
17156 : }
17157 : }
17158 : else
17159 : {
17160 0 : std::cout << "SgTemplateArgumentPtrList p_tpl_args --> NULL " << std::endl;
17161 : }
17162 : }
17163 :
17164 0 : SgTemplateArgumentPtrList::iterator i_part_spec_tpl_args = p_part_spec_tpl_args.begin() ;
17165 0 : for ( ; i_part_spec_tpl_args != p_part_spec_tpl_args.end(); ++i_part_spec_tpl_args )
17166 : {
17167 0 : if ( (*i_part_spec_tpl_args) != NULL )
17168 : {
17169 0 : if ( (*i_part_spec_tpl_args)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17170 : {
17171 0 : if ( (*i_part_spec_tpl_args)->isInMemoryPool() == false )
17172 : {
17173 0 : std::cout << "SgTemplateType :: ";
17174 0 : std::cout << " p_part_spec_tpl_args ( list of poitners to IR nodes ), entry is not in memory pool of ";
17175 0 : std::cout << (*i_part_spec_tpl_args)->class_name() << std::endl;
17176 : }
17177 : }
17178 : else
17179 : {
17180 0 : std::cout << "SgTemplateType :: " << std::flush;
17181 0 : std::cout << "SgTemplateArgumentPtrList p_part_spec_tpl_args --> " << std::flush;
17182 0 : std::cout << " entry not valid " << std::endl;
17183 : }
17184 : }
17185 : else
17186 : {
17187 0 : std::cout << "SgTemplateArgumentPtrList p_part_spec_tpl_args --> NULL " << std::endl;
17188 : }
17189 : }
17190 :
17191 0 : if ( p_ref_to != NULL )
17192 : {
17193 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17194 : {
17195 0 : if ( p_ref_to->isInMemoryPool() == false )
17196 : {
17197 0 : std::cout << "SgTemplateType :: ";
17198 0 : std::cout << " p_ref_to is not in memory pool of ";
17199 0 : std::cout << p_ref_to->class_name() << std::endl;
17200 : }
17201 : }
17202 : else
17203 : {
17204 0 : std::cout << "SgTemplateType :: " << std::flush;
17205 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
17206 0 : std::cout << " not valid " << std::endl;
17207 : }
17208 : }
17209 :
17210 0 : if ( p_ptr_to != NULL )
17211 : {
17212 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17213 : {
17214 0 : if ( p_ptr_to->isInMemoryPool() == false )
17215 : {
17216 0 : std::cout << "SgTemplateType :: ";
17217 0 : std::cout << " p_ptr_to is not in memory pool of ";
17218 0 : std::cout << p_ptr_to->class_name() << std::endl;
17219 : }
17220 : }
17221 : else
17222 : {
17223 0 : std::cout << "SgTemplateType :: " << std::flush;
17224 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
17225 0 : std::cout << " not valid " << std::endl;
17226 : }
17227 : }
17228 :
17229 0 : if ( p_modifiers != NULL )
17230 : {
17231 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17232 : {
17233 0 : if ( p_modifiers->isInMemoryPool() == false )
17234 : {
17235 0 : std::cout << "SgTemplateType :: ";
17236 0 : std::cout << " p_modifiers is not in memory pool of ";
17237 0 : std::cout << p_modifiers->class_name() << std::endl;
17238 : }
17239 : }
17240 : else
17241 : {
17242 0 : std::cout << "SgTemplateType :: " << std::flush;
17243 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
17244 0 : std::cout << " not valid " << std::endl;
17245 : }
17246 : }
17247 :
17248 0 : if ( p_typedefs != NULL )
17249 : {
17250 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17251 : {
17252 0 : if ( p_typedefs->isInMemoryPool() == false )
17253 : {
17254 0 : std::cout << "SgTemplateType :: ";
17255 0 : std::cout << " p_typedefs is not in memory pool of ";
17256 0 : std::cout << p_typedefs->class_name() << std::endl;
17257 : }
17258 : }
17259 : else
17260 : {
17261 0 : std::cout << "SgTemplateType :: " << std::flush;
17262 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
17263 0 : std::cout << " not valid " << std::endl;
17264 : }
17265 : }
17266 :
17267 0 : if ( p_rvalue_ref_to != NULL )
17268 : {
17269 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17270 : {
17271 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
17272 : {
17273 0 : std::cout << "SgTemplateType :: ";
17274 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
17275 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
17276 : }
17277 : }
17278 : else
17279 : {
17280 0 : std::cout << "SgTemplateType :: " << std::flush;
17281 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
17282 0 : std::cout << " not valid " << std::endl;
17283 : }
17284 : }
17285 :
17286 0 : if ( p_decltype_ref_to != NULL )
17287 : {
17288 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17289 : {
17290 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
17291 : {
17292 0 : std::cout << "SgTemplateType :: ";
17293 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
17294 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
17295 : }
17296 : }
17297 : else
17298 : {
17299 0 : std::cout << "SgTemplateType :: " << std::flush;
17300 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
17301 0 : std::cout << " not valid " << std::endl;
17302 : }
17303 : }
17304 :
17305 0 : if ( p_typeof_ref_to != NULL )
17306 : {
17307 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17308 : {
17309 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
17310 : {
17311 0 : std::cout << "SgTemplateType :: ";
17312 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
17313 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
17314 : }
17315 : }
17316 : else
17317 : {
17318 0 : std::cout << "SgTemplateType :: " << std::flush;
17319 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
17320 0 : std::cout << " not valid " << std::endl;
17321 : }
17322 : }
17323 :
17324 0 : if ( p_type_kind != NULL )
17325 : {
17326 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17327 : {
17328 0 : if ( p_type_kind->isInMemoryPool() == false )
17329 : {
17330 0 : std::cout << "SgTemplateType :: ";
17331 0 : std::cout << " p_type_kind is not in memory pool of ";
17332 0 : std::cout << p_type_kind->class_name() << std::endl;
17333 : }
17334 : }
17335 : else
17336 : {
17337 0 : std::cout << "SgTemplateType :: " << std::flush;
17338 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
17339 0 : std::cout << " not valid " << std::endl;
17340 : }
17341 : }
17342 :
17343 0 : if ( p_parent != NULL )
17344 : {
17345 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17346 : {
17347 0 : if ( p_parent->isInMemoryPool() == false )
17348 : {
17349 0 : std::cout << "SgTemplateType :: ";
17350 0 : std::cout << " p_parent is not in memory pool of ";
17351 0 : std::cout << p_parent->class_name() << std::endl;
17352 : }
17353 : }
17354 : else
17355 : {
17356 0 : std::cout << "SgTemplateType :: " << std::flush;
17357 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
17358 0 : std::cout << " not valid " << std::endl;
17359 : }
17360 : }
17361 :
17362 :
17363 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
17364 :
17365 0 : }
17366 :
17367 :
17368 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
17369 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
17370 : bool
17371 0 : SgTemplateType::isInMemoryPool ()
17372 : {
17373 0 : typedef unsigned char* TestType;
17374 :
17375 0 : bool found = false;
17376 :
17377 0 : ROSE_ASSERT(this != NULL);
17378 :
17379 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
17380 :
17381 0 : TestType tested = (TestType) ( this ) ;
17382 :
17383 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateType::pools.begin();
17384 :
17385 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
17386 : // while (found == false && block < Memory_Block_List.end())
17387 0 : while ( (found == false) && (block != SgTemplateType::pools.end()) )
17388 : {
17389 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateType::pool_size * sizeof(SgTemplateType) ) ) ;
17390 0 : ++block;
17391 : }
17392 :
17393 : // Special handling for static data
17394 :
17395 :
17396 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
17397 0 : ROSE_ASSERT(found == true);
17398 :
17399 0 : return found;
17400 : }
17401 : /* #line 17402 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
17402 :
17403 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
17404 :
17405 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
17406 :
17407 : /* #line 17408 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
17408 :
17409 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
17410 :
17411 : void
17412 0 : SgQualifiedNameType::checkDataMemberPointersIfInMemoryPool()
17413 : {
17414 : // ------------ checking pointers of SgQualifiedNameType -------------------
17415 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
17416 :
17417 0 : if ( p_base_type != NULL )
17418 : {
17419 0 : if ( p_base_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17420 : {
17421 0 : if ( p_base_type->isInMemoryPool() == false )
17422 : {
17423 0 : std::cout << "SgQualifiedNameType :: ";
17424 0 : std::cout << " p_base_type is not in memory pool of ";
17425 0 : std::cout << p_base_type->class_name() << std::endl;
17426 : }
17427 : }
17428 : else
17429 : {
17430 0 : std::cout << "SgQualifiedNameType :: " << std::flush;
17431 0 : std::cout << "SgType* p_base_type = " << p_base_type << " --> " << std::flush;
17432 0 : std::cout << " not valid " << std::endl;
17433 : }
17434 : }
17435 :
17436 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
17437 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
17438 : {
17439 0 : if ( (*i_qualifiedNameList) != NULL )
17440 : {
17441 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17442 : {
17443 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
17444 : {
17445 0 : std::cout << "SgQualifiedNameType :: ";
17446 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
17447 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
17448 : }
17449 : }
17450 : else
17451 : {
17452 0 : std::cout << "SgQualifiedNameType :: " << std::flush;
17453 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
17454 0 : std::cout << " entry not valid " << std::endl;
17455 : }
17456 : }
17457 : else
17458 : {
17459 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
17460 : }
17461 : }
17462 :
17463 0 : if ( p_ref_to != NULL )
17464 : {
17465 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17466 : {
17467 0 : if ( p_ref_to->isInMemoryPool() == false )
17468 : {
17469 0 : std::cout << "SgQualifiedNameType :: ";
17470 0 : std::cout << " p_ref_to is not in memory pool of ";
17471 0 : std::cout << p_ref_to->class_name() << std::endl;
17472 : }
17473 : }
17474 : else
17475 : {
17476 0 : std::cout << "SgQualifiedNameType :: " << std::flush;
17477 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
17478 0 : std::cout << " not valid " << std::endl;
17479 : }
17480 : }
17481 :
17482 0 : if ( p_ptr_to != NULL )
17483 : {
17484 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17485 : {
17486 0 : if ( p_ptr_to->isInMemoryPool() == false )
17487 : {
17488 0 : std::cout << "SgQualifiedNameType :: ";
17489 0 : std::cout << " p_ptr_to is not in memory pool of ";
17490 0 : std::cout << p_ptr_to->class_name() << std::endl;
17491 : }
17492 : }
17493 : else
17494 : {
17495 0 : std::cout << "SgQualifiedNameType :: " << std::flush;
17496 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
17497 0 : std::cout << " not valid " << std::endl;
17498 : }
17499 : }
17500 :
17501 0 : if ( p_modifiers != NULL )
17502 : {
17503 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17504 : {
17505 0 : if ( p_modifiers->isInMemoryPool() == false )
17506 : {
17507 0 : std::cout << "SgQualifiedNameType :: ";
17508 0 : std::cout << " p_modifiers is not in memory pool of ";
17509 0 : std::cout << p_modifiers->class_name() << std::endl;
17510 : }
17511 : }
17512 : else
17513 : {
17514 0 : std::cout << "SgQualifiedNameType :: " << std::flush;
17515 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
17516 0 : std::cout << " not valid " << std::endl;
17517 : }
17518 : }
17519 :
17520 0 : if ( p_typedefs != NULL )
17521 : {
17522 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17523 : {
17524 0 : if ( p_typedefs->isInMemoryPool() == false )
17525 : {
17526 0 : std::cout << "SgQualifiedNameType :: ";
17527 0 : std::cout << " p_typedefs is not in memory pool of ";
17528 0 : std::cout << p_typedefs->class_name() << std::endl;
17529 : }
17530 : }
17531 : else
17532 : {
17533 0 : std::cout << "SgQualifiedNameType :: " << std::flush;
17534 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
17535 0 : std::cout << " not valid " << std::endl;
17536 : }
17537 : }
17538 :
17539 0 : if ( p_rvalue_ref_to != NULL )
17540 : {
17541 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17542 : {
17543 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
17544 : {
17545 0 : std::cout << "SgQualifiedNameType :: ";
17546 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
17547 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
17548 : }
17549 : }
17550 : else
17551 : {
17552 0 : std::cout << "SgQualifiedNameType :: " << std::flush;
17553 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
17554 0 : std::cout << " not valid " << std::endl;
17555 : }
17556 : }
17557 :
17558 0 : if ( p_decltype_ref_to != NULL )
17559 : {
17560 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17561 : {
17562 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
17563 : {
17564 0 : std::cout << "SgQualifiedNameType :: ";
17565 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
17566 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
17567 : }
17568 : }
17569 : else
17570 : {
17571 0 : std::cout << "SgQualifiedNameType :: " << std::flush;
17572 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
17573 0 : std::cout << " not valid " << std::endl;
17574 : }
17575 : }
17576 :
17577 0 : if ( p_typeof_ref_to != NULL )
17578 : {
17579 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17580 : {
17581 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
17582 : {
17583 0 : std::cout << "SgQualifiedNameType :: ";
17584 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
17585 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
17586 : }
17587 : }
17588 : else
17589 : {
17590 0 : std::cout << "SgQualifiedNameType :: " << std::flush;
17591 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
17592 0 : std::cout << " not valid " << std::endl;
17593 : }
17594 : }
17595 :
17596 0 : if ( p_type_kind != NULL )
17597 : {
17598 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17599 : {
17600 0 : if ( p_type_kind->isInMemoryPool() == false )
17601 : {
17602 0 : std::cout << "SgQualifiedNameType :: ";
17603 0 : std::cout << " p_type_kind is not in memory pool of ";
17604 0 : std::cout << p_type_kind->class_name() << std::endl;
17605 : }
17606 : }
17607 : else
17608 : {
17609 0 : std::cout << "SgQualifiedNameType :: " << std::flush;
17610 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
17611 0 : std::cout << " not valid " << std::endl;
17612 : }
17613 : }
17614 :
17615 0 : if ( p_parent != NULL )
17616 : {
17617 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17618 : {
17619 0 : if ( p_parent->isInMemoryPool() == false )
17620 : {
17621 0 : std::cout << "SgQualifiedNameType :: ";
17622 0 : std::cout << " p_parent is not in memory pool of ";
17623 0 : std::cout << p_parent->class_name() << std::endl;
17624 : }
17625 : }
17626 : else
17627 : {
17628 0 : std::cout << "SgQualifiedNameType :: " << std::flush;
17629 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
17630 0 : std::cout << " not valid " << std::endl;
17631 : }
17632 : }
17633 :
17634 :
17635 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
17636 :
17637 0 : }
17638 :
17639 :
17640 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
17641 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
17642 : bool
17643 0 : SgQualifiedNameType::isInMemoryPool ()
17644 : {
17645 0 : typedef unsigned char* TestType;
17646 :
17647 0 : bool found = false;
17648 :
17649 0 : ROSE_ASSERT(this != NULL);
17650 :
17651 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
17652 :
17653 0 : TestType tested = (TestType) ( this ) ;
17654 :
17655 0 : std::vector < unsigned char* > :: const_iterator block = SgQualifiedNameType::pools.begin();
17656 :
17657 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
17658 : // while (found == false && block < Memory_Block_List.end())
17659 0 : while ( (found == false) && (block != SgQualifiedNameType::pools.end()) )
17660 : {
17661 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgQualifiedNameType::pool_size * sizeof(SgQualifiedNameType) ) ) ;
17662 0 : ++block;
17663 : }
17664 :
17665 : // Special handling for static data
17666 :
17667 :
17668 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
17669 0 : ROSE_ASSERT(found == true);
17670 :
17671 0 : return found;
17672 : }
17673 : /* #line 17674 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
17674 :
17675 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
17676 :
17677 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
17678 :
17679 : /* #line 17680 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
17680 :
17681 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
17682 :
17683 : void
17684 0 : SgTypeComplex::checkDataMemberPointersIfInMemoryPool()
17685 : {
17686 : // ------------ checking pointers of SgTypeComplex -------------------
17687 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
17688 :
17689 0 : if ( p_base_type != NULL )
17690 : {
17691 0 : if ( p_base_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17692 : {
17693 0 : if ( p_base_type->isInMemoryPool() == false )
17694 : {
17695 0 : std::cout << "SgTypeComplex :: ";
17696 0 : std::cout << " p_base_type is not in memory pool of ";
17697 0 : std::cout << p_base_type->class_name() << std::endl;
17698 : }
17699 : }
17700 : else
17701 : {
17702 0 : std::cout << "SgTypeComplex :: " << std::flush;
17703 0 : std::cout << "SgType* p_base_type = " << p_base_type << " --> " << std::flush;
17704 0 : std::cout << " not valid " << std::endl;
17705 : }
17706 : }
17707 :
17708 0 : if ( p_ref_to != NULL )
17709 : {
17710 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17711 : {
17712 0 : if ( p_ref_to->isInMemoryPool() == false )
17713 : {
17714 0 : std::cout << "SgTypeComplex :: ";
17715 0 : std::cout << " p_ref_to is not in memory pool of ";
17716 0 : std::cout << p_ref_to->class_name() << std::endl;
17717 : }
17718 : }
17719 : else
17720 : {
17721 0 : std::cout << "SgTypeComplex :: " << std::flush;
17722 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
17723 0 : std::cout << " not valid " << std::endl;
17724 : }
17725 : }
17726 :
17727 0 : if ( p_ptr_to != NULL )
17728 : {
17729 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17730 : {
17731 0 : if ( p_ptr_to->isInMemoryPool() == false )
17732 : {
17733 0 : std::cout << "SgTypeComplex :: ";
17734 0 : std::cout << " p_ptr_to is not in memory pool of ";
17735 0 : std::cout << p_ptr_to->class_name() << std::endl;
17736 : }
17737 : }
17738 : else
17739 : {
17740 0 : std::cout << "SgTypeComplex :: " << std::flush;
17741 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
17742 0 : std::cout << " not valid " << std::endl;
17743 : }
17744 : }
17745 :
17746 0 : if ( p_modifiers != NULL )
17747 : {
17748 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17749 : {
17750 0 : if ( p_modifiers->isInMemoryPool() == false )
17751 : {
17752 0 : std::cout << "SgTypeComplex :: ";
17753 0 : std::cout << " p_modifiers is not in memory pool of ";
17754 0 : std::cout << p_modifiers->class_name() << std::endl;
17755 : }
17756 : }
17757 : else
17758 : {
17759 0 : std::cout << "SgTypeComplex :: " << std::flush;
17760 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
17761 0 : std::cout << " not valid " << std::endl;
17762 : }
17763 : }
17764 :
17765 0 : if ( p_typedefs != NULL )
17766 : {
17767 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17768 : {
17769 0 : if ( p_typedefs->isInMemoryPool() == false )
17770 : {
17771 0 : std::cout << "SgTypeComplex :: ";
17772 0 : std::cout << " p_typedefs is not in memory pool of ";
17773 0 : std::cout << p_typedefs->class_name() << std::endl;
17774 : }
17775 : }
17776 : else
17777 : {
17778 0 : std::cout << "SgTypeComplex :: " << std::flush;
17779 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
17780 0 : std::cout << " not valid " << std::endl;
17781 : }
17782 : }
17783 :
17784 0 : if ( p_rvalue_ref_to != NULL )
17785 : {
17786 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17787 : {
17788 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
17789 : {
17790 0 : std::cout << "SgTypeComplex :: ";
17791 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
17792 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
17793 : }
17794 : }
17795 : else
17796 : {
17797 0 : std::cout << "SgTypeComplex :: " << std::flush;
17798 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
17799 0 : std::cout << " not valid " << std::endl;
17800 : }
17801 : }
17802 :
17803 0 : if ( p_decltype_ref_to != NULL )
17804 : {
17805 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17806 : {
17807 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
17808 : {
17809 0 : std::cout << "SgTypeComplex :: ";
17810 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
17811 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
17812 : }
17813 : }
17814 : else
17815 : {
17816 0 : std::cout << "SgTypeComplex :: " << std::flush;
17817 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
17818 0 : std::cout << " not valid " << std::endl;
17819 : }
17820 : }
17821 :
17822 0 : if ( p_typeof_ref_to != NULL )
17823 : {
17824 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17825 : {
17826 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
17827 : {
17828 0 : std::cout << "SgTypeComplex :: ";
17829 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
17830 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
17831 : }
17832 : }
17833 : else
17834 : {
17835 0 : std::cout << "SgTypeComplex :: " << std::flush;
17836 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
17837 0 : std::cout << " not valid " << std::endl;
17838 : }
17839 : }
17840 :
17841 0 : if ( p_type_kind != NULL )
17842 : {
17843 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17844 : {
17845 0 : if ( p_type_kind->isInMemoryPool() == false )
17846 : {
17847 0 : std::cout << "SgTypeComplex :: ";
17848 0 : std::cout << " p_type_kind is not in memory pool of ";
17849 0 : std::cout << p_type_kind->class_name() << std::endl;
17850 : }
17851 : }
17852 : else
17853 : {
17854 0 : std::cout << "SgTypeComplex :: " << std::flush;
17855 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
17856 0 : std::cout << " not valid " << std::endl;
17857 : }
17858 : }
17859 :
17860 0 : if ( p_parent != NULL )
17861 : {
17862 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17863 : {
17864 0 : if ( p_parent->isInMemoryPool() == false )
17865 : {
17866 0 : std::cout << "SgTypeComplex :: ";
17867 0 : std::cout << " p_parent is not in memory pool of ";
17868 0 : std::cout << p_parent->class_name() << std::endl;
17869 : }
17870 : }
17871 : else
17872 : {
17873 0 : std::cout << "SgTypeComplex :: " << std::flush;
17874 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
17875 0 : std::cout << " not valid " << std::endl;
17876 : }
17877 : }
17878 :
17879 :
17880 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
17881 :
17882 0 : }
17883 :
17884 :
17885 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
17886 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
17887 : bool
17888 0 : SgTypeComplex::isInMemoryPool ()
17889 : {
17890 0 : typedef unsigned char* TestType;
17891 :
17892 0 : bool found = false;
17893 :
17894 0 : ROSE_ASSERT(this != NULL);
17895 :
17896 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
17897 :
17898 0 : TestType tested = (TestType) ( this ) ;
17899 :
17900 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeComplex::pools.begin();
17901 :
17902 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
17903 : // while (found == false && block < Memory_Block_List.end())
17904 0 : while ( (found == false) && (block != SgTypeComplex::pools.end()) )
17905 : {
17906 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeComplex::pool_size * sizeof(SgTypeComplex) ) ) ;
17907 0 : ++block;
17908 : }
17909 :
17910 : // Special handling for static data
17911 :
17912 :
17913 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
17914 0 : ROSE_ASSERT(found == true);
17915 :
17916 0 : return found;
17917 : }
17918 : /* #line 17919 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
17919 :
17920 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
17921 :
17922 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
17923 :
17924 : /* #line 17925 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
17925 :
17926 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
17927 :
17928 : void
17929 0 : SgTypeImaginary::checkDataMemberPointersIfInMemoryPool()
17930 : {
17931 : // ------------ checking pointers of SgTypeImaginary -------------------
17932 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
17933 :
17934 0 : if ( p_base_type != NULL )
17935 : {
17936 0 : if ( p_base_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17937 : {
17938 0 : if ( p_base_type->isInMemoryPool() == false )
17939 : {
17940 0 : std::cout << "SgTypeImaginary :: ";
17941 0 : std::cout << " p_base_type is not in memory pool of ";
17942 0 : std::cout << p_base_type->class_name() << std::endl;
17943 : }
17944 : }
17945 : else
17946 : {
17947 0 : std::cout << "SgTypeImaginary :: " << std::flush;
17948 0 : std::cout << "SgType* p_base_type = " << p_base_type << " --> " << std::flush;
17949 0 : std::cout << " not valid " << std::endl;
17950 : }
17951 : }
17952 :
17953 0 : if ( p_ref_to != NULL )
17954 : {
17955 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17956 : {
17957 0 : if ( p_ref_to->isInMemoryPool() == false )
17958 : {
17959 0 : std::cout << "SgTypeImaginary :: ";
17960 0 : std::cout << " p_ref_to is not in memory pool of ";
17961 0 : std::cout << p_ref_to->class_name() << std::endl;
17962 : }
17963 : }
17964 : else
17965 : {
17966 0 : std::cout << "SgTypeImaginary :: " << std::flush;
17967 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
17968 0 : std::cout << " not valid " << std::endl;
17969 : }
17970 : }
17971 :
17972 0 : if ( p_ptr_to != NULL )
17973 : {
17974 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17975 : {
17976 0 : if ( p_ptr_to->isInMemoryPool() == false )
17977 : {
17978 0 : std::cout << "SgTypeImaginary :: ";
17979 0 : std::cout << " p_ptr_to is not in memory pool of ";
17980 0 : std::cout << p_ptr_to->class_name() << std::endl;
17981 : }
17982 : }
17983 : else
17984 : {
17985 0 : std::cout << "SgTypeImaginary :: " << std::flush;
17986 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
17987 0 : std::cout << " not valid " << std::endl;
17988 : }
17989 : }
17990 :
17991 0 : if ( p_modifiers != NULL )
17992 : {
17993 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
17994 : {
17995 0 : if ( p_modifiers->isInMemoryPool() == false )
17996 : {
17997 0 : std::cout << "SgTypeImaginary :: ";
17998 0 : std::cout << " p_modifiers is not in memory pool of ";
17999 0 : std::cout << p_modifiers->class_name() << std::endl;
18000 : }
18001 : }
18002 : else
18003 : {
18004 0 : std::cout << "SgTypeImaginary :: " << std::flush;
18005 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
18006 0 : std::cout << " not valid " << std::endl;
18007 : }
18008 : }
18009 :
18010 0 : if ( p_typedefs != NULL )
18011 : {
18012 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18013 : {
18014 0 : if ( p_typedefs->isInMemoryPool() == false )
18015 : {
18016 0 : std::cout << "SgTypeImaginary :: ";
18017 0 : std::cout << " p_typedefs is not in memory pool of ";
18018 0 : std::cout << p_typedefs->class_name() << std::endl;
18019 : }
18020 : }
18021 : else
18022 : {
18023 0 : std::cout << "SgTypeImaginary :: " << std::flush;
18024 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
18025 0 : std::cout << " not valid " << std::endl;
18026 : }
18027 : }
18028 :
18029 0 : if ( p_rvalue_ref_to != NULL )
18030 : {
18031 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18032 : {
18033 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
18034 : {
18035 0 : std::cout << "SgTypeImaginary :: ";
18036 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
18037 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
18038 : }
18039 : }
18040 : else
18041 : {
18042 0 : std::cout << "SgTypeImaginary :: " << std::flush;
18043 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
18044 0 : std::cout << " not valid " << std::endl;
18045 : }
18046 : }
18047 :
18048 0 : if ( p_decltype_ref_to != NULL )
18049 : {
18050 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18051 : {
18052 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
18053 : {
18054 0 : std::cout << "SgTypeImaginary :: ";
18055 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
18056 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
18057 : }
18058 : }
18059 : else
18060 : {
18061 0 : std::cout << "SgTypeImaginary :: " << std::flush;
18062 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
18063 0 : std::cout << " not valid " << std::endl;
18064 : }
18065 : }
18066 :
18067 0 : if ( p_typeof_ref_to != NULL )
18068 : {
18069 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18070 : {
18071 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
18072 : {
18073 0 : std::cout << "SgTypeImaginary :: ";
18074 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
18075 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
18076 : }
18077 : }
18078 : else
18079 : {
18080 0 : std::cout << "SgTypeImaginary :: " << std::flush;
18081 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
18082 0 : std::cout << " not valid " << std::endl;
18083 : }
18084 : }
18085 :
18086 0 : if ( p_type_kind != NULL )
18087 : {
18088 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18089 : {
18090 0 : if ( p_type_kind->isInMemoryPool() == false )
18091 : {
18092 0 : std::cout << "SgTypeImaginary :: ";
18093 0 : std::cout << " p_type_kind is not in memory pool of ";
18094 0 : std::cout << p_type_kind->class_name() << std::endl;
18095 : }
18096 : }
18097 : else
18098 : {
18099 0 : std::cout << "SgTypeImaginary :: " << std::flush;
18100 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
18101 0 : std::cout << " not valid " << std::endl;
18102 : }
18103 : }
18104 :
18105 0 : if ( p_parent != NULL )
18106 : {
18107 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18108 : {
18109 0 : if ( p_parent->isInMemoryPool() == false )
18110 : {
18111 0 : std::cout << "SgTypeImaginary :: ";
18112 0 : std::cout << " p_parent is not in memory pool of ";
18113 0 : std::cout << p_parent->class_name() << std::endl;
18114 : }
18115 : }
18116 : else
18117 : {
18118 0 : std::cout << "SgTypeImaginary :: " << std::flush;
18119 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
18120 0 : std::cout << " not valid " << std::endl;
18121 : }
18122 : }
18123 :
18124 :
18125 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
18126 :
18127 0 : }
18128 :
18129 :
18130 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
18131 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
18132 : bool
18133 0 : SgTypeImaginary::isInMemoryPool ()
18134 : {
18135 0 : typedef unsigned char* TestType;
18136 :
18137 0 : bool found = false;
18138 :
18139 0 : ROSE_ASSERT(this != NULL);
18140 :
18141 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
18142 :
18143 0 : TestType tested = (TestType) ( this ) ;
18144 :
18145 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeImaginary::pools.begin();
18146 :
18147 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
18148 : // while (found == false && block < Memory_Block_List.end())
18149 0 : while ( (found == false) && (block != SgTypeImaginary::pools.end()) )
18150 : {
18151 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeImaginary::pool_size * sizeof(SgTypeImaginary) ) ) ;
18152 0 : ++block;
18153 : }
18154 :
18155 : // Special handling for static data
18156 :
18157 :
18158 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
18159 0 : ROSE_ASSERT(found == true);
18160 :
18161 0 : return found;
18162 : }
18163 : /* #line 18164 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
18164 :
18165 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
18166 :
18167 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
18168 :
18169 : /* #line 18170 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
18170 :
18171 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
18172 :
18173 : void
18174 0 : SgTypeDefault::checkDataMemberPointersIfInMemoryPool()
18175 : {
18176 : // ------------ checking pointers of SgTypeDefault -------------------
18177 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
18178 :
18179 0 : if ( p_ref_to != NULL )
18180 : {
18181 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18182 : {
18183 0 : if ( p_ref_to->isInMemoryPool() == false )
18184 : {
18185 0 : std::cout << "SgTypeDefault :: ";
18186 0 : std::cout << " p_ref_to is not in memory pool of ";
18187 0 : std::cout << p_ref_to->class_name() << std::endl;
18188 : }
18189 : }
18190 : else
18191 : {
18192 0 : std::cout << "SgTypeDefault :: " << std::flush;
18193 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
18194 0 : std::cout << " not valid " << std::endl;
18195 : }
18196 : }
18197 :
18198 0 : if ( p_ptr_to != NULL )
18199 : {
18200 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18201 : {
18202 0 : if ( p_ptr_to->isInMemoryPool() == false )
18203 : {
18204 0 : std::cout << "SgTypeDefault :: ";
18205 0 : std::cout << " p_ptr_to is not in memory pool of ";
18206 0 : std::cout << p_ptr_to->class_name() << std::endl;
18207 : }
18208 : }
18209 : else
18210 : {
18211 0 : std::cout << "SgTypeDefault :: " << std::flush;
18212 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
18213 0 : std::cout << " not valid " << std::endl;
18214 : }
18215 : }
18216 :
18217 0 : if ( p_modifiers != NULL )
18218 : {
18219 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18220 : {
18221 0 : if ( p_modifiers->isInMemoryPool() == false )
18222 : {
18223 0 : std::cout << "SgTypeDefault :: ";
18224 0 : std::cout << " p_modifiers is not in memory pool of ";
18225 0 : std::cout << p_modifiers->class_name() << std::endl;
18226 : }
18227 : }
18228 : else
18229 : {
18230 0 : std::cout << "SgTypeDefault :: " << std::flush;
18231 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
18232 0 : std::cout << " not valid " << std::endl;
18233 : }
18234 : }
18235 :
18236 0 : if ( p_typedefs != NULL )
18237 : {
18238 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18239 : {
18240 0 : if ( p_typedefs->isInMemoryPool() == false )
18241 : {
18242 0 : std::cout << "SgTypeDefault :: ";
18243 0 : std::cout << " p_typedefs is not in memory pool of ";
18244 0 : std::cout << p_typedefs->class_name() << std::endl;
18245 : }
18246 : }
18247 : else
18248 : {
18249 0 : std::cout << "SgTypeDefault :: " << std::flush;
18250 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
18251 0 : std::cout << " not valid " << std::endl;
18252 : }
18253 : }
18254 :
18255 0 : if ( p_rvalue_ref_to != NULL )
18256 : {
18257 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18258 : {
18259 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
18260 : {
18261 0 : std::cout << "SgTypeDefault :: ";
18262 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
18263 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
18264 : }
18265 : }
18266 : else
18267 : {
18268 0 : std::cout << "SgTypeDefault :: " << std::flush;
18269 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
18270 0 : std::cout << " not valid " << std::endl;
18271 : }
18272 : }
18273 :
18274 0 : if ( p_decltype_ref_to != NULL )
18275 : {
18276 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18277 : {
18278 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
18279 : {
18280 0 : std::cout << "SgTypeDefault :: ";
18281 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
18282 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
18283 : }
18284 : }
18285 : else
18286 : {
18287 0 : std::cout << "SgTypeDefault :: " << std::flush;
18288 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
18289 0 : std::cout << " not valid " << std::endl;
18290 : }
18291 : }
18292 :
18293 0 : if ( p_typeof_ref_to != NULL )
18294 : {
18295 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18296 : {
18297 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
18298 : {
18299 0 : std::cout << "SgTypeDefault :: ";
18300 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
18301 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
18302 : }
18303 : }
18304 : else
18305 : {
18306 0 : std::cout << "SgTypeDefault :: " << std::flush;
18307 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
18308 0 : std::cout << " not valid " << std::endl;
18309 : }
18310 : }
18311 :
18312 0 : if ( p_type_kind != NULL )
18313 : {
18314 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18315 : {
18316 0 : if ( p_type_kind->isInMemoryPool() == false )
18317 : {
18318 0 : std::cout << "SgTypeDefault :: ";
18319 0 : std::cout << " p_type_kind is not in memory pool of ";
18320 0 : std::cout << p_type_kind->class_name() << std::endl;
18321 : }
18322 : }
18323 : else
18324 : {
18325 0 : std::cout << "SgTypeDefault :: " << std::flush;
18326 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
18327 0 : std::cout << " not valid " << std::endl;
18328 : }
18329 : }
18330 :
18331 0 : if ( p_parent != NULL )
18332 : {
18333 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18334 : {
18335 0 : if ( p_parent->isInMemoryPool() == false )
18336 : {
18337 0 : std::cout << "SgTypeDefault :: ";
18338 0 : std::cout << " p_parent is not in memory pool of ";
18339 0 : std::cout << p_parent->class_name() << std::endl;
18340 : }
18341 : }
18342 : else
18343 : {
18344 0 : std::cout << "SgTypeDefault :: " << std::flush;
18345 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
18346 0 : std::cout << " not valid " << std::endl;
18347 : }
18348 : }
18349 :
18350 :
18351 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
18352 :
18353 0 : }
18354 :
18355 :
18356 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
18357 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
18358 : bool
18359 0 : SgTypeDefault::isInMemoryPool ()
18360 : {
18361 0 : typedef unsigned char* TestType;
18362 :
18363 0 : bool found = false;
18364 :
18365 0 : ROSE_ASSERT(this != NULL);
18366 :
18367 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
18368 :
18369 0 : TestType tested = (TestType) ( this ) ;
18370 :
18371 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeDefault::pools.begin();
18372 :
18373 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
18374 : // while (found == false && block < Memory_Block_List.end())
18375 0 : while ( (found == false) && (block != SgTypeDefault::pools.end()) )
18376 : {
18377 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeDefault::pool_size * sizeof(SgTypeDefault) ) ) ;
18378 0 : ++block;
18379 : }
18380 :
18381 : // Special handling for static data
18382 :
18383 :
18384 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
18385 0 : ROSE_ASSERT(found == true);
18386 :
18387 0 : return found;
18388 : }
18389 : /* #line 18390 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
18390 :
18391 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
18392 :
18393 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
18394 :
18395 : /* #line 18396 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
18396 :
18397 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
18398 :
18399 : void
18400 0 : SgTypeCAFTeam::checkDataMemberPointersIfInMemoryPool()
18401 : {
18402 : // ------------ checking pointers of SgTypeCAFTeam -------------------
18403 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
18404 :
18405 0 : if ( p_ref_to != NULL )
18406 : {
18407 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18408 : {
18409 0 : if ( p_ref_to->isInMemoryPool() == false )
18410 : {
18411 0 : std::cout << "SgTypeCAFTeam :: ";
18412 0 : std::cout << " p_ref_to is not in memory pool of ";
18413 0 : std::cout << p_ref_to->class_name() << std::endl;
18414 : }
18415 : }
18416 : else
18417 : {
18418 0 : std::cout << "SgTypeCAFTeam :: " << std::flush;
18419 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
18420 0 : std::cout << " not valid " << std::endl;
18421 : }
18422 : }
18423 :
18424 0 : if ( p_ptr_to != NULL )
18425 : {
18426 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18427 : {
18428 0 : if ( p_ptr_to->isInMemoryPool() == false )
18429 : {
18430 0 : std::cout << "SgTypeCAFTeam :: ";
18431 0 : std::cout << " p_ptr_to is not in memory pool of ";
18432 0 : std::cout << p_ptr_to->class_name() << std::endl;
18433 : }
18434 : }
18435 : else
18436 : {
18437 0 : std::cout << "SgTypeCAFTeam :: " << std::flush;
18438 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
18439 0 : std::cout << " not valid " << std::endl;
18440 : }
18441 : }
18442 :
18443 0 : if ( p_modifiers != NULL )
18444 : {
18445 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18446 : {
18447 0 : if ( p_modifiers->isInMemoryPool() == false )
18448 : {
18449 0 : std::cout << "SgTypeCAFTeam :: ";
18450 0 : std::cout << " p_modifiers is not in memory pool of ";
18451 0 : std::cout << p_modifiers->class_name() << std::endl;
18452 : }
18453 : }
18454 : else
18455 : {
18456 0 : std::cout << "SgTypeCAFTeam :: " << std::flush;
18457 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
18458 0 : std::cout << " not valid " << std::endl;
18459 : }
18460 : }
18461 :
18462 0 : if ( p_typedefs != NULL )
18463 : {
18464 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18465 : {
18466 0 : if ( p_typedefs->isInMemoryPool() == false )
18467 : {
18468 0 : std::cout << "SgTypeCAFTeam :: ";
18469 0 : std::cout << " p_typedefs is not in memory pool of ";
18470 0 : std::cout << p_typedefs->class_name() << std::endl;
18471 : }
18472 : }
18473 : else
18474 : {
18475 0 : std::cout << "SgTypeCAFTeam :: " << std::flush;
18476 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
18477 0 : std::cout << " not valid " << std::endl;
18478 : }
18479 : }
18480 :
18481 0 : if ( p_rvalue_ref_to != NULL )
18482 : {
18483 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18484 : {
18485 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
18486 : {
18487 0 : std::cout << "SgTypeCAFTeam :: ";
18488 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
18489 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
18490 : }
18491 : }
18492 : else
18493 : {
18494 0 : std::cout << "SgTypeCAFTeam :: " << std::flush;
18495 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
18496 0 : std::cout << " not valid " << std::endl;
18497 : }
18498 : }
18499 :
18500 0 : if ( p_decltype_ref_to != NULL )
18501 : {
18502 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18503 : {
18504 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
18505 : {
18506 0 : std::cout << "SgTypeCAFTeam :: ";
18507 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
18508 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
18509 : }
18510 : }
18511 : else
18512 : {
18513 0 : std::cout << "SgTypeCAFTeam :: " << std::flush;
18514 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
18515 0 : std::cout << " not valid " << std::endl;
18516 : }
18517 : }
18518 :
18519 0 : if ( p_typeof_ref_to != NULL )
18520 : {
18521 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18522 : {
18523 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
18524 : {
18525 0 : std::cout << "SgTypeCAFTeam :: ";
18526 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
18527 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
18528 : }
18529 : }
18530 : else
18531 : {
18532 0 : std::cout << "SgTypeCAFTeam :: " << std::flush;
18533 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
18534 0 : std::cout << " not valid " << std::endl;
18535 : }
18536 : }
18537 :
18538 0 : if ( p_type_kind != NULL )
18539 : {
18540 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18541 : {
18542 0 : if ( p_type_kind->isInMemoryPool() == false )
18543 : {
18544 0 : std::cout << "SgTypeCAFTeam :: ";
18545 0 : std::cout << " p_type_kind is not in memory pool of ";
18546 0 : std::cout << p_type_kind->class_name() << std::endl;
18547 : }
18548 : }
18549 : else
18550 : {
18551 0 : std::cout << "SgTypeCAFTeam :: " << std::flush;
18552 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
18553 0 : std::cout << " not valid " << std::endl;
18554 : }
18555 : }
18556 :
18557 0 : if ( p_parent != NULL )
18558 : {
18559 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18560 : {
18561 0 : if ( p_parent->isInMemoryPool() == false )
18562 : {
18563 0 : std::cout << "SgTypeCAFTeam :: ";
18564 0 : std::cout << " p_parent is not in memory pool of ";
18565 0 : std::cout << p_parent->class_name() << std::endl;
18566 : }
18567 : }
18568 : else
18569 : {
18570 0 : std::cout << "SgTypeCAFTeam :: " << std::flush;
18571 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
18572 0 : std::cout << " not valid " << std::endl;
18573 : }
18574 : }
18575 :
18576 :
18577 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
18578 :
18579 0 : }
18580 :
18581 :
18582 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
18583 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
18584 : bool
18585 0 : SgTypeCAFTeam::isInMemoryPool ()
18586 : {
18587 0 : typedef unsigned char* TestType;
18588 :
18589 0 : bool found = false;
18590 :
18591 0 : ROSE_ASSERT(this != NULL);
18592 :
18593 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
18594 :
18595 0 : TestType tested = (TestType) ( this ) ;
18596 :
18597 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeCAFTeam::pools.begin();
18598 :
18599 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
18600 : // while (found == false && block < Memory_Block_List.end())
18601 0 : while ( (found == false) && (block != SgTypeCAFTeam::pools.end()) )
18602 : {
18603 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeCAFTeam::pool_size * sizeof(SgTypeCAFTeam) ) ) ;
18604 0 : ++block;
18605 : }
18606 :
18607 : // Special handling for static data
18608 :
18609 :
18610 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
18611 0 : ROSE_ASSERT(found == true);
18612 :
18613 0 : return found;
18614 : }
18615 : /* #line 18616 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
18616 :
18617 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
18618 :
18619 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
18620 :
18621 : /* #line 18622 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
18622 :
18623 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
18624 :
18625 : void
18626 0 : SgTypeCrayPointer::checkDataMemberPointersIfInMemoryPool()
18627 : {
18628 : // ------------ checking pointers of SgTypeCrayPointer -------------------
18629 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
18630 :
18631 0 : if ( p_ref_to != NULL )
18632 : {
18633 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18634 : {
18635 0 : if ( p_ref_to->isInMemoryPool() == false )
18636 : {
18637 0 : std::cout << "SgTypeCrayPointer :: ";
18638 0 : std::cout << " p_ref_to is not in memory pool of ";
18639 0 : std::cout << p_ref_to->class_name() << std::endl;
18640 : }
18641 : }
18642 : else
18643 : {
18644 0 : std::cout << "SgTypeCrayPointer :: " << std::flush;
18645 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
18646 0 : std::cout << " not valid " << std::endl;
18647 : }
18648 : }
18649 :
18650 0 : if ( p_ptr_to != NULL )
18651 : {
18652 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18653 : {
18654 0 : if ( p_ptr_to->isInMemoryPool() == false )
18655 : {
18656 0 : std::cout << "SgTypeCrayPointer :: ";
18657 0 : std::cout << " p_ptr_to is not in memory pool of ";
18658 0 : std::cout << p_ptr_to->class_name() << std::endl;
18659 : }
18660 : }
18661 : else
18662 : {
18663 0 : std::cout << "SgTypeCrayPointer :: " << std::flush;
18664 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
18665 0 : std::cout << " not valid " << std::endl;
18666 : }
18667 : }
18668 :
18669 0 : if ( p_modifiers != NULL )
18670 : {
18671 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18672 : {
18673 0 : if ( p_modifiers->isInMemoryPool() == false )
18674 : {
18675 0 : std::cout << "SgTypeCrayPointer :: ";
18676 0 : std::cout << " p_modifiers is not in memory pool of ";
18677 0 : std::cout << p_modifiers->class_name() << std::endl;
18678 : }
18679 : }
18680 : else
18681 : {
18682 0 : std::cout << "SgTypeCrayPointer :: " << std::flush;
18683 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
18684 0 : std::cout << " not valid " << std::endl;
18685 : }
18686 : }
18687 :
18688 0 : if ( p_typedefs != NULL )
18689 : {
18690 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18691 : {
18692 0 : if ( p_typedefs->isInMemoryPool() == false )
18693 : {
18694 0 : std::cout << "SgTypeCrayPointer :: ";
18695 0 : std::cout << " p_typedefs is not in memory pool of ";
18696 0 : std::cout << p_typedefs->class_name() << std::endl;
18697 : }
18698 : }
18699 : else
18700 : {
18701 0 : std::cout << "SgTypeCrayPointer :: " << std::flush;
18702 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
18703 0 : std::cout << " not valid " << std::endl;
18704 : }
18705 : }
18706 :
18707 0 : if ( p_rvalue_ref_to != NULL )
18708 : {
18709 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18710 : {
18711 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
18712 : {
18713 0 : std::cout << "SgTypeCrayPointer :: ";
18714 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
18715 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
18716 : }
18717 : }
18718 : else
18719 : {
18720 0 : std::cout << "SgTypeCrayPointer :: " << std::flush;
18721 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
18722 0 : std::cout << " not valid " << std::endl;
18723 : }
18724 : }
18725 :
18726 0 : if ( p_decltype_ref_to != NULL )
18727 : {
18728 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18729 : {
18730 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
18731 : {
18732 0 : std::cout << "SgTypeCrayPointer :: ";
18733 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
18734 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
18735 : }
18736 : }
18737 : else
18738 : {
18739 0 : std::cout << "SgTypeCrayPointer :: " << std::flush;
18740 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
18741 0 : std::cout << " not valid " << std::endl;
18742 : }
18743 : }
18744 :
18745 0 : if ( p_typeof_ref_to != NULL )
18746 : {
18747 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18748 : {
18749 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
18750 : {
18751 0 : std::cout << "SgTypeCrayPointer :: ";
18752 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
18753 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
18754 : }
18755 : }
18756 : else
18757 : {
18758 0 : std::cout << "SgTypeCrayPointer :: " << std::flush;
18759 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
18760 0 : std::cout << " not valid " << std::endl;
18761 : }
18762 : }
18763 :
18764 0 : if ( p_type_kind != NULL )
18765 : {
18766 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18767 : {
18768 0 : if ( p_type_kind->isInMemoryPool() == false )
18769 : {
18770 0 : std::cout << "SgTypeCrayPointer :: ";
18771 0 : std::cout << " p_type_kind is not in memory pool of ";
18772 0 : std::cout << p_type_kind->class_name() << std::endl;
18773 : }
18774 : }
18775 : else
18776 : {
18777 0 : std::cout << "SgTypeCrayPointer :: " << std::flush;
18778 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
18779 0 : std::cout << " not valid " << std::endl;
18780 : }
18781 : }
18782 :
18783 0 : if ( p_parent != NULL )
18784 : {
18785 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18786 : {
18787 0 : if ( p_parent->isInMemoryPool() == false )
18788 : {
18789 0 : std::cout << "SgTypeCrayPointer :: ";
18790 0 : std::cout << " p_parent is not in memory pool of ";
18791 0 : std::cout << p_parent->class_name() << std::endl;
18792 : }
18793 : }
18794 : else
18795 : {
18796 0 : std::cout << "SgTypeCrayPointer :: " << std::flush;
18797 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
18798 0 : std::cout << " not valid " << std::endl;
18799 : }
18800 : }
18801 :
18802 :
18803 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
18804 :
18805 0 : }
18806 :
18807 :
18808 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
18809 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
18810 : bool
18811 0 : SgTypeCrayPointer::isInMemoryPool ()
18812 : {
18813 0 : typedef unsigned char* TestType;
18814 :
18815 0 : bool found = false;
18816 :
18817 0 : ROSE_ASSERT(this != NULL);
18818 :
18819 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
18820 :
18821 0 : TestType tested = (TestType) ( this ) ;
18822 :
18823 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeCrayPointer::pools.begin();
18824 :
18825 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
18826 : // while (found == false && block < Memory_Block_List.end())
18827 0 : while ( (found == false) && (block != SgTypeCrayPointer::pools.end()) )
18828 : {
18829 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeCrayPointer::pool_size * sizeof(SgTypeCrayPointer) ) ) ;
18830 0 : ++block;
18831 : }
18832 :
18833 : // Special handling for static data
18834 :
18835 :
18836 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
18837 0 : ROSE_ASSERT(found == true);
18838 :
18839 0 : return found;
18840 : }
18841 : /* #line 18842 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
18842 :
18843 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
18844 :
18845 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
18846 :
18847 : /* #line 18848 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
18848 :
18849 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
18850 :
18851 : void
18852 0 : SgTypeLabel::checkDataMemberPointersIfInMemoryPool()
18853 : {
18854 : // ------------ checking pointers of SgTypeLabel -------------------
18855 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
18856 :
18857 0 : if ( p_ref_to != NULL )
18858 : {
18859 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18860 : {
18861 0 : if ( p_ref_to->isInMemoryPool() == false )
18862 : {
18863 0 : std::cout << "SgTypeLabel :: ";
18864 0 : std::cout << " p_ref_to is not in memory pool of ";
18865 0 : std::cout << p_ref_to->class_name() << std::endl;
18866 : }
18867 : }
18868 : else
18869 : {
18870 0 : std::cout << "SgTypeLabel :: " << std::flush;
18871 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
18872 0 : std::cout << " not valid " << std::endl;
18873 : }
18874 : }
18875 :
18876 0 : if ( p_ptr_to != NULL )
18877 : {
18878 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18879 : {
18880 0 : if ( p_ptr_to->isInMemoryPool() == false )
18881 : {
18882 0 : std::cout << "SgTypeLabel :: ";
18883 0 : std::cout << " p_ptr_to is not in memory pool of ";
18884 0 : std::cout << p_ptr_to->class_name() << std::endl;
18885 : }
18886 : }
18887 : else
18888 : {
18889 0 : std::cout << "SgTypeLabel :: " << std::flush;
18890 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
18891 0 : std::cout << " not valid " << std::endl;
18892 : }
18893 : }
18894 :
18895 0 : if ( p_modifiers != NULL )
18896 : {
18897 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18898 : {
18899 0 : if ( p_modifiers->isInMemoryPool() == false )
18900 : {
18901 0 : std::cout << "SgTypeLabel :: ";
18902 0 : std::cout << " p_modifiers is not in memory pool of ";
18903 0 : std::cout << p_modifiers->class_name() << std::endl;
18904 : }
18905 : }
18906 : else
18907 : {
18908 0 : std::cout << "SgTypeLabel :: " << std::flush;
18909 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
18910 0 : std::cout << " not valid " << std::endl;
18911 : }
18912 : }
18913 :
18914 0 : if ( p_typedefs != NULL )
18915 : {
18916 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18917 : {
18918 0 : if ( p_typedefs->isInMemoryPool() == false )
18919 : {
18920 0 : std::cout << "SgTypeLabel :: ";
18921 0 : std::cout << " p_typedefs is not in memory pool of ";
18922 0 : std::cout << p_typedefs->class_name() << std::endl;
18923 : }
18924 : }
18925 : else
18926 : {
18927 0 : std::cout << "SgTypeLabel :: " << std::flush;
18928 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
18929 0 : std::cout << " not valid " << std::endl;
18930 : }
18931 : }
18932 :
18933 0 : if ( p_rvalue_ref_to != NULL )
18934 : {
18935 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18936 : {
18937 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
18938 : {
18939 0 : std::cout << "SgTypeLabel :: ";
18940 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
18941 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
18942 : }
18943 : }
18944 : else
18945 : {
18946 0 : std::cout << "SgTypeLabel :: " << std::flush;
18947 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
18948 0 : std::cout << " not valid " << std::endl;
18949 : }
18950 : }
18951 :
18952 0 : if ( p_decltype_ref_to != NULL )
18953 : {
18954 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18955 : {
18956 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
18957 : {
18958 0 : std::cout << "SgTypeLabel :: ";
18959 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
18960 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
18961 : }
18962 : }
18963 : else
18964 : {
18965 0 : std::cout << "SgTypeLabel :: " << std::flush;
18966 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
18967 0 : std::cout << " not valid " << std::endl;
18968 : }
18969 : }
18970 :
18971 0 : if ( p_typeof_ref_to != NULL )
18972 : {
18973 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18974 : {
18975 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
18976 : {
18977 0 : std::cout << "SgTypeLabel :: ";
18978 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
18979 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
18980 : }
18981 : }
18982 : else
18983 : {
18984 0 : std::cout << "SgTypeLabel :: " << std::flush;
18985 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
18986 0 : std::cout << " not valid " << std::endl;
18987 : }
18988 : }
18989 :
18990 0 : if ( p_type_kind != NULL )
18991 : {
18992 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
18993 : {
18994 0 : if ( p_type_kind->isInMemoryPool() == false )
18995 : {
18996 0 : std::cout << "SgTypeLabel :: ";
18997 0 : std::cout << " p_type_kind is not in memory pool of ";
18998 0 : std::cout << p_type_kind->class_name() << std::endl;
18999 : }
19000 : }
19001 : else
19002 : {
19003 0 : std::cout << "SgTypeLabel :: " << std::flush;
19004 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
19005 0 : std::cout << " not valid " << std::endl;
19006 : }
19007 : }
19008 :
19009 0 : if ( p_parent != NULL )
19010 : {
19011 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19012 : {
19013 0 : if ( p_parent->isInMemoryPool() == false )
19014 : {
19015 0 : std::cout << "SgTypeLabel :: ";
19016 0 : std::cout << " p_parent is not in memory pool of ";
19017 0 : std::cout << p_parent->class_name() << std::endl;
19018 : }
19019 : }
19020 : else
19021 : {
19022 0 : std::cout << "SgTypeLabel :: " << std::flush;
19023 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
19024 0 : std::cout << " not valid " << std::endl;
19025 : }
19026 : }
19027 :
19028 :
19029 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
19030 :
19031 0 : }
19032 :
19033 :
19034 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
19035 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
19036 : bool
19037 0 : SgTypeLabel::isInMemoryPool ()
19038 : {
19039 0 : typedef unsigned char* TestType;
19040 :
19041 0 : bool found = false;
19042 :
19043 0 : ROSE_ASSERT(this != NULL);
19044 :
19045 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
19046 :
19047 0 : TestType tested = (TestType) ( this ) ;
19048 :
19049 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeLabel::pools.begin();
19050 :
19051 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
19052 : // while (found == false && block < Memory_Block_List.end())
19053 0 : while ( (found == false) && (block != SgTypeLabel::pools.end()) )
19054 : {
19055 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeLabel::pool_size * sizeof(SgTypeLabel) ) ) ;
19056 0 : ++block;
19057 : }
19058 :
19059 : // Special handling for static data
19060 :
19061 :
19062 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
19063 0 : ROSE_ASSERT(found == true);
19064 :
19065 0 : return found;
19066 : }
19067 : /* #line 19068 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
19068 :
19069 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
19070 :
19071 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
19072 :
19073 : /* #line 19074 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
19074 :
19075 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
19076 :
19077 : void
19078 0 : SgRvalueReferenceType::checkDataMemberPointersIfInMemoryPool()
19079 : {
19080 : // ------------ checking pointers of SgRvalueReferenceType -------------------
19081 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
19082 :
19083 0 : if ( p_base_type != NULL )
19084 : {
19085 0 : if ( p_base_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19086 : {
19087 0 : if ( p_base_type->isInMemoryPool() == false )
19088 : {
19089 0 : std::cout << "SgRvalueReferenceType :: ";
19090 0 : std::cout << " p_base_type is not in memory pool of ";
19091 0 : std::cout << p_base_type->class_name() << std::endl;
19092 : }
19093 : }
19094 : else
19095 : {
19096 0 : std::cout << "SgRvalueReferenceType :: " << std::flush;
19097 0 : std::cout << "SgType* p_base_type = " << p_base_type << " --> " << std::flush;
19098 0 : std::cout << " not valid " << std::endl;
19099 : }
19100 : }
19101 :
19102 0 : if ( p_ref_to != NULL )
19103 : {
19104 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19105 : {
19106 0 : if ( p_ref_to->isInMemoryPool() == false )
19107 : {
19108 0 : std::cout << "SgRvalueReferenceType :: ";
19109 0 : std::cout << " p_ref_to is not in memory pool of ";
19110 0 : std::cout << p_ref_to->class_name() << std::endl;
19111 : }
19112 : }
19113 : else
19114 : {
19115 0 : std::cout << "SgRvalueReferenceType :: " << std::flush;
19116 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
19117 0 : std::cout << " not valid " << std::endl;
19118 : }
19119 : }
19120 :
19121 0 : if ( p_ptr_to != NULL )
19122 : {
19123 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19124 : {
19125 0 : if ( p_ptr_to->isInMemoryPool() == false )
19126 : {
19127 0 : std::cout << "SgRvalueReferenceType :: ";
19128 0 : std::cout << " p_ptr_to is not in memory pool of ";
19129 0 : std::cout << p_ptr_to->class_name() << std::endl;
19130 : }
19131 : }
19132 : else
19133 : {
19134 0 : std::cout << "SgRvalueReferenceType :: " << std::flush;
19135 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
19136 0 : std::cout << " not valid " << std::endl;
19137 : }
19138 : }
19139 :
19140 0 : if ( p_modifiers != NULL )
19141 : {
19142 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19143 : {
19144 0 : if ( p_modifiers->isInMemoryPool() == false )
19145 : {
19146 0 : std::cout << "SgRvalueReferenceType :: ";
19147 0 : std::cout << " p_modifiers is not in memory pool of ";
19148 0 : std::cout << p_modifiers->class_name() << std::endl;
19149 : }
19150 : }
19151 : else
19152 : {
19153 0 : std::cout << "SgRvalueReferenceType :: " << std::flush;
19154 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
19155 0 : std::cout << " not valid " << std::endl;
19156 : }
19157 : }
19158 :
19159 0 : if ( p_typedefs != NULL )
19160 : {
19161 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19162 : {
19163 0 : if ( p_typedefs->isInMemoryPool() == false )
19164 : {
19165 0 : std::cout << "SgRvalueReferenceType :: ";
19166 0 : std::cout << " p_typedefs is not in memory pool of ";
19167 0 : std::cout << p_typedefs->class_name() << std::endl;
19168 : }
19169 : }
19170 : else
19171 : {
19172 0 : std::cout << "SgRvalueReferenceType :: " << std::flush;
19173 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
19174 0 : std::cout << " not valid " << std::endl;
19175 : }
19176 : }
19177 :
19178 0 : if ( p_rvalue_ref_to != NULL )
19179 : {
19180 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19181 : {
19182 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
19183 : {
19184 0 : std::cout << "SgRvalueReferenceType :: ";
19185 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
19186 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
19187 : }
19188 : }
19189 : else
19190 : {
19191 0 : std::cout << "SgRvalueReferenceType :: " << std::flush;
19192 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
19193 0 : std::cout << " not valid " << std::endl;
19194 : }
19195 : }
19196 :
19197 0 : if ( p_decltype_ref_to != NULL )
19198 : {
19199 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19200 : {
19201 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
19202 : {
19203 0 : std::cout << "SgRvalueReferenceType :: ";
19204 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
19205 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
19206 : }
19207 : }
19208 : else
19209 : {
19210 0 : std::cout << "SgRvalueReferenceType :: " << std::flush;
19211 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
19212 0 : std::cout << " not valid " << std::endl;
19213 : }
19214 : }
19215 :
19216 0 : if ( p_typeof_ref_to != NULL )
19217 : {
19218 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19219 : {
19220 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
19221 : {
19222 0 : std::cout << "SgRvalueReferenceType :: ";
19223 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
19224 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
19225 : }
19226 : }
19227 : else
19228 : {
19229 0 : std::cout << "SgRvalueReferenceType :: " << std::flush;
19230 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
19231 0 : std::cout << " not valid " << std::endl;
19232 : }
19233 : }
19234 :
19235 0 : if ( p_type_kind != NULL )
19236 : {
19237 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19238 : {
19239 0 : if ( p_type_kind->isInMemoryPool() == false )
19240 : {
19241 0 : std::cout << "SgRvalueReferenceType :: ";
19242 0 : std::cout << " p_type_kind is not in memory pool of ";
19243 0 : std::cout << p_type_kind->class_name() << std::endl;
19244 : }
19245 : }
19246 : else
19247 : {
19248 0 : std::cout << "SgRvalueReferenceType :: " << std::flush;
19249 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
19250 0 : std::cout << " not valid " << std::endl;
19251 : }
19252 : }
19253 :
19254 0 : if ( p_parent != NULL )
19255 : {
19256 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19257 : {
19258 0 : if ( p_parent->isInMemoryPool() == false )
19259 : {
19260 0 : std::cout << "SgRvalueReferenceType :: ";
19261 0 : std::cout << " p_parent is not in memory pool of ";
19262 0 : std::cout << p_parent->class_name() << std::endl;
19263 : }
19264 : }
19265 : else
19266 : {
19267 0 : std::cout << "SgRvalueReferenceType :: " << std::flush;
19268 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
19269 0 : std::cout << " not valid " << std::endl;
19270 : }
19271 : }
19272 :
19273 :
19274 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
19275 :
19276 0 : }
19277 :
19278 :
19279 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
19280 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
19281 : bool
19282 0 : SgRvalueReferenceType::isInMemoryPool ()
19283 : {
19284 0 : typedef unsigned char* TestType;
19285 :
19286 0 : bool found = false;
19287 :
19288 0 : ROSE_ASSERT(this != NULL);
19289 :
19290 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
19291 :
19292 0 : TestType tested = (TestType) ( this ) ;
19293 :
19294 0 : std::vector < unsigned char* > :: const_iterator block = SgRvalueReferenceType::pools.begin();
19295 :
19296 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
19297 : // while (found == false && block < Memory_Block_List.end())
19298 0 : while ( (found == false) && (block != SgRvalueReferenceType::pools.end()) )
19299 : {
19300 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgRvalueReferenceType::pool_size * sizeof(SgRvalueReferenceType) ) ) ;
19301 0 : ++block;
19302 : }
19303 :
19304 : // Special handling for static data
19305 :
19306 :
19307 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
19308 0 : ROSE_ASSERT(found == true);
19309 :
19310 0 : return found;
19311 : }
19312 : /* #line 19313 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
19313 :
19314 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
19315 :
19316 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
19317 :
19318 : /* #line 19319 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
19319 :
19320 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
19321 :
19322 : void
19323 0 : SgTypeNullptr::checkDataMemberPointersIfInMemoryPool()
19324 : {
19325 : // ------------ checking pointers of SgTypeNullptr -------------------
19326 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
19327 :
19328 0 : if ( p_ref_to != NULL )
19329 : {
19330 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19331 : {
19332 0 : if ( p_ref_to->isInMemoryPool() == false )
19333 : {
19334 0 : std::cout << "SgTypeNullptr :: ";
19335 0 : std::cout << " p_ref_to is not in memory pool of ";
19336 0 : std::cout << p_ref_to->class_name() << std::endl;
19337 : }
19338 : }
19339 : else
19340 : {
19341 0 : std::cout << "SgTypeNullptr :: " << std::flush;
19342 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
19343 0 : std::cout << " not valid " << std::endl;
19344 : }
19345 : }
19346 :
19347 0 : if ( p_ptr_to != NULL )
19348 : {
19349 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19350 : {
19351 0 : if ( p_ptr_to->isInMemoryPool() == false )
19352 : {
19353 0 : std::cout << "SgTypeNullptr :: ";
19354 0 : std::cout << " p_ptr_to is not in memory pool of ";
19355 0 : std::cout << p_ptr_to->class_name() << std::endl;
19356 : }
19357 : }
19358 : else
19359 : {
19360 0 : std::cout << "SgTypeNullptr :: " << std::flush;
19361 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
19362 0 : std::cout << " not valid " << std::endl;
19363 : }
19364 : }
19365 :
19366 0 : if ( p_modifiers != NULL )
19367 : {
19368 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19369 : {
19370 0 : if ( p_modifiers->isInMemoryPool() == false )
19371 : {
19372 0 : std::cout << "SgTypeNullptr :: ";
19373 0 : std::cout << " p_modifiers is not in memory pool of ";
19374 0 : std::cout << p_modifiers->class_name() << std::endl;
19375 : }
19376 : }
19377 : else
19378 : {
19379 0 : std::cout << "SgTypeNullptr :: " << std::flush;
19380 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
19381 0 : std::cout << " not valid " << std::endl;
19382 : }
19383 : }
19384 :
19385 0 : if ( p_typedefs != NULL )
19386 : {
19387 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19388 : {
19389 0 : if ( p_typedefs->isInMemoryPool() == false )
19390 : {
19391 0 : std::cout << "SgTypeNullptr :: ";
19392 0 : std::cout << " p_typedefs is not in memory pool of ";
19393 0 : std::cout << p_typedefs->class_name() << std::endl;
19394 : }
19395 : }
19396 : else
19397 : {
19398 0 : std::cout << "SgTypeNullptr :: " << std::flush;
19399 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
19400 0 : std::cout << " not valid " << std::endl;
19401 : }
19402 : }
19403 :
19404 0 : if ( p_rvalue_ref_to != NULL )
19405 : {
19406 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19407 : {
19408 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
19409 : {
19410 0 : std::cout << "SgTypeNullptr :: ";
19411 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
19412 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
19413 : }
19414 : }
19415 : else
19416 : {
19417 0 : std::cout << "SgTypeNullptr :: " << std::flush;
19418 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
19419 0 : std::cout << " not valid " << std::endl;
19420 : }
19421 : }
19422 :
19423 0 : if ( p_decltype_ref_to != NULL )
19424 : {
19425 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19426 : {
19427 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
19428 : {
19429 0 : std::cout << "SgTypeNullptr :: ";
19430 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
19431 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
19432 : }
19433 : }
19434 : else
19435 : {
19436 0 : std::cout << "SgTypeNullptr :: " << std::flush;
19437 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
19438 0 : std::cout << " not valid " << std::endl;
19439 : }
19440 : }
19441 :
19442 0 : if ( p_typeof_ref_to != NULL )
19443 : {
19444 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19445 : {
19446 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
19447 : {
19448 0 : std::cout << "SgTypeNullptr :: ";
19449 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
19450 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
19451 : }
19452 : }
19453 : else
19454 : {
19455 0 : std::cout << "SgTypeNullptr :: " << std::flush;
19456 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
19457 0 : std::cout << " not valid " << std::endl;
19458 : }
19459 : }
19460 :
19461 0 : if ( p_type_kind != NULL )
19462 : {
19463 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19464 : {
19465 0 : if ( p_type_kind->isInMemoryPool() == false )
19466 : {
19467 0 : std::cout << "SgTypeNullptr :: ";
19468 0 : std::cout << " p_type_kind is not in memory pool of ";
19469 0 : std::cout << p_type_kind->class_name() << std::endl;
19470 : }
19471 : }
19472 : else
19473 : {
19474 0 : std::cout << "SgTypeNullptr :: " << std::flush;
19475 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
19476 0 : std::cout << " not valid " << std::endl;
19477 : }
19478 : }
19479 :
19480 0 : if ( p_parent != NULL )
19481 : {
19482 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19483 : {
19484 0 : if ( p_parent->isInMemoryPool() == false )
19485 : {
19486 0 : std::cout << "SgTypeNullptr :: ";
19487 0 : std::cout << " p_parent is not in memory pool of ";
19488 0 : std::cout << p_parent->class_name() << std::endl;
19489 : }
19490 : }
19491 : else
19492 : {
19493 0 : std::cout << "SgTypeNullptr :: " << std::flush;
19494 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
19495 0 : std::cout << " not valid " << std::endl;
19496 : }
19497 : }
19498 :
19499 :
19500 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
19501 :
19502 0 : }
19503 :
19504 :
19505 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
19506 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
19507 : bool
19508 0 : SgTypeNullptr::isInMemoryPool ()
19509 : {
19510 0 : typedef unsigned char* TestType;
19511 :
19512 0 : bool found = false;
19513 :
19514 0 : ROSE_ASSERT(this != NULL);
19515 :
19516 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
19517 :
19518 0 : TestType tested = (TestType) ( this ) ;
19519 :
19520 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeNullptr::pools.begin();
19521 :
19522 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
19523 : // while (found == false && block < Memory_Block_List.end())
19524 0 : while ( (found == false) && (block != SgTypeNullptr::pools.end()) )
19525 : {
19526 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeNullptr::pool_size * sizeof(SgTypeNullptr) ) ) ;
19527 0 : ++block;
19528 : }
19529 :
19530 : // Special handling for static data
19531 :
19532 :
19533 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
19534 0 : ROSE_ASSERT(found == true);
19535 :
19536 0 : return found;
19537 : }
19538 : /* #line 19539 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
19539 :
19540 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
19541 :
19542 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
19543 :
19544 : /* #line 19545 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
19545 :
19546 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
19547 :
19548 : void
19549 0 : SgDeclType::checkDataMemberPointersIfInMemoryPool()
19550 : {
19551 : // ------------ checking pointers of SgDeclType -------------------
19552 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
19553 :
19554 0 : if ( p_base_expression != NULL )
19555 : {
19556 0 : if ( p_base_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19557 : {
19558 0 : if ( p_base_expression->isInMemoryPool() == false )
19559 : {
19560 0 : std::cout << "SgDeclType :: ";
19561 0 : std::cout << " p_base_expression is not in memory pool of ";
19562 0 : std::cout << p_base_expression->class_name() << std::endl;
19563 : }
19564 : }
19565 : else
19566 : {
19567 0 : std::cout << "SgDeclType :: " << std::flush;
19568 0 : std::cout << "SgExpression* p_base_expression = " << p_base_expression << " --> " << std::flush;
19569 0 : std::cout << " not valid " << std::endl;
19570 : }
19571 : }
19572 :
19573 0 : if ( p_base_type != NULL )
19574 : {
19575 0 : if ( p_base_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19576 : {
19577 0 : if ( p_base_type->isInMemoryPool() == false )
19578 : {
19579 0 : std::cout << "SgDeclType :: ";
19580 0 : std::cout << " p_base_type is not in memory pool of ";
19581 0 : std::cout << p_base_type->class_name() << std::endl;
19582 : }
19583 : }
19584 : else
19585 : {
19586 0 : std::cout << "SgDeclType :: " << std::flush;
19587 0 : std::cout << "SgType* p_base_type = " << p_base_type << " --> " << std::flush;
19588 0 : std::cout << " not valid " << std::endl;
19589 : }
19590 : }
19591 :
19592 0 : if ( p_ref_to != NULL )
19593 : {
19594 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19595 : {
19596 0 : if ( p_ref_to->isInMemoryPool() == false )
19597 : {
19598 0 : std::cout << "SgDeclType :: ";
19599 0 : std::cout << " p_ref_to is not in memory pool of ";
19600 0 : std::cout << p_ref_to->class_name() << std::endl;
19601 : }
19602 : }
19603 : else
19604 : {
19605 0 : std::cout << "SgDeclType :: " << std::flush;
19606 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
19607 0 : std::cout << " not valid " << std::endl;
19608 : }
19609 : }
19610 :
19611 0 : if ( p_ptr_to != NULL )
19612 : {
19613 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19614 : {
19615 0 : if ( p_ptr_to->isInMemoryPool() == false )
19616 : {
19617 0 : std::cout << "SgDeclType :: ";
19618 0 : std::cout << " p_ptr_to is not in memory pool of ";
19619 0 : std::cout << p_ptr_to->class_name() << std::endl;
19620 : }
19621 : }
19622 : else
19623 : {
19624 0 : std::cout << "SgDeclType :: " << std::flush;
19625 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
19626 0 : std::cout << " not valid " << std::endl;
19627 : }
19628 : }
19629 :
19630 0 : if ( p_modifiers != NULL )
19631 : {
19632 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19633 : {
19634 0 : if ( p_modifiers->isInMemoryPool() == false )
19635 : {
19636 0 : std::cout << "SgDeclType :: ";
19637 0 : std::cout << " p_modifiers is not in memory pool of ";
19638 0 : std::cout << p_modifiers->class_name() << std::endl;
19639 : }
19640 : }
19641 : else
19642 : {
19643 0 : std::cout << "SgDeclType :: " << std::flush;
19644 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
19645 0 : std::cout << " not valid " << std::endl;
19646 : }
19647 : }
19648 :
19649 0 : if ( p_typedefs != NULL )
19650 : {
19651 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19652 : {
19653 0 : if ( p_typedefs->isInMemoryPool() == false )
19654 : {
19655 0 : std::cout << "SgDeclType :: ";
19656 0 : std::cout << " p_typedefs is not in memory pool of ";
19657 0 : std::cout << p_typedefs->class_name() << std::endl;
19658 : }
19659 : }
19660 : else
19661 : {
19662 0 : std::cout << "SgDeclType :: " << std::flush;
19663 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
19664 0 : std::cout << " not valid " << std::endl;
19665 : }
19666 : }
19667 :
19668 0 : if ( p_rvalue_ref_to != NULL )
19669 : {
19670 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19671 : {
19672 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
19673 : {
19674 0 : std::cout << "SgDeclType :: ";
19675 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
19676 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
19677 : }
19678 : }
19679 : else
19680 : {
19681 0 : std::cout << "SgDeclType :: " << std::flush;
19682 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
19683 0 : std::cout << " not valid " << std::endl;
19684 : }
19685 : }
19686 :
19687 0 : if ( p_decltype_ref_to != NULL )
19688 : {
19689 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19690 : {
19691 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
19692 : {
19693 0 : std::cout << "SgDeclType :: ";
19694 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
19695 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
19696 : }
19697 : }
19698 : else
19699 : {
19700 0 : std::cout << "SgDeclType :: " << std::flush;
19701 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
19702 0 : std::cout << " not valid " << std::endl;
19703 : }
19704 : }
19705 :
19706 0 : if ( p_typeof_ref_to != NULL )
19707 : {
19708 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19709 : {
19710 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
19711 : {
19712 0 : std::cout << "SgDeclType :: ";
19713 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
19714 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
19715 : }
19716 : }
19717 : else
19718 : {
19719 0 : std::cout << "SgDeclType :: " << std::flush;
19720 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
19721 0 : std::cout << " not valid " << std::endl;
19722 : }
19723 : }
19724 :
19725 0 : if ( p_type_kind != NULL )
19726 : {
19727 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19728 : {
19729 0 : if ( p_type_kind->isInMemoryPool() == false )
19730 : {
19731 0 : std::cout << "SgDeclType :: ";
19732 0 : std::cout << " p_type_kind is not in memory pool of ";
19733 0 : std::cout << p_type_kind->class_name() << std::endl;
19734 : }
19735 : }
19736 : else
19737 : {
19738 0 : std::cout << "SgDeclType :: " << std::flush;
19739 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
19740 0 : std::cout << " not valid " << std::endl;
19741 : }
19742 : }
19743 :
19744 0 : if ( p_parent != NULL )
19745 : {
19746 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19747 : {
19748 0 : if ( p_parent->isInMemoryPool() == false )
19749 : {
19750 0 : std::cout << "SgDeclType :: ";
19751 0 : std::cout << " p_parent is not in memory pool of ";
19752 0 : std::cout << p_parent->class_name() << std::endl;
19753 : }
19754 : }
19755 : else
19756 : {
19757 0 : std::cout << "SgDeclType :: " << std::flush;
19758 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
19759 0 : std::cout << " not valid " << std::endl;
19760 : }
19761 : }
19762 :
19763 :
19764 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
19765 :
19766 0 : }
19767 :
19768 :
19769 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
19770 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
19771 : bool
19772 0 : SgDeclType::isInMemoryPool ()
19773 : {
19774 0 : typedef unsigned char* TestType;
19775 :
19776 0 : bool found = false;
19777 :
19778 0 : ROSE_ASSERT(this != NULL);
19779 :
19780 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
19781 :
19782 0 : TestType tested = (TestType) ( this ) ;
19783 :
19784 0 : std::vector < unsigned char* > :: const_iterator block = SgDeclType::pools.begin();
19785 :
19786 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
19787 : // while (found == false && block < Memory_Block_List.end())
19788 0 : while ( (found == false) && (block != SgDeclType::pools.end()) )
19789 : {
19790 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDeclType::pool_size * sizeof(SgDeclType) ) ) ;
19791 0 : ++block;
19792 : }
19793 :
19794 : // Special handling for static data
19795 :
19796 :
19797 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
19798 0 : ROSE_ASSERT(found == true);
19799 :
19800 0 : return found;
19801 : }
19802 : /* #line 19803 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
19803 :
19804 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
19805 :
19806 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
19807 :
19808 : /* #line 19809 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
19809 :
19810 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
19811 :
19812 : void
19813 0 : SgTypeOfType::checkDataMemberPointersIfInMemoryPool()
19814 : {
19815 : // ------------ checking pointers of SgTypeOfType -------------------
19816 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
19817 :
19818 0 : if ( p_base_expression != NULL )
19819 : {
19820 0 : if ( p_base_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19821 : {
19822 0 : if ( p_base_expression->isInMemoryPool() == false )
19823 : {
19824 0 : std::cout << "SgTypeOfType :: ";
19825 0 : std::cout << " p_base_expression is not in memory pool of ";
19826 0 : std::cout << p_base_expression->class_name() << std::endl;
19827 : }
19828 : }
19829 : else
19830 : {
19831 0 : std::cout << "SgTypeOfType :: " << std::flush;
19832 0 : std::cout << "SgExpression* p_base_expression = " << p_base_expression << " --> " << std::flush;
19833 0 : std::cout << " not valid " << std::endl;
19834 : }
19835 : }
19836 :
19837 0 : if ( p_base_type != NULL )
19838 : {
19839 0 : if ( p_base_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19840 : {
19841 0 : if ( p_base_type->isInMemoryPool() == false )
19842 : {
19843 0 : std::cout << "SgTypeOfType :: ";
19844 0 : std::cout << " p_base_type is not in memory pool of ";
19845 0 : std::cout << p_base_type->class_name() << std::endl;
19846 : }
19847 : }
19848 : else
19849 : {
19850 0 : std::cout << "SgTypeOfType :: " << std::flush;
19851 0 : std::cout << "SgType* p_base_type = " << p_base_type << " --> " << std::flush;
19852 0 : std::cout << " not valid " << std::endl;
19853 : }
19854 : }
19855 :
19856 0 : if ( p_ref_to != NULL )
19857 : {
19858 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19859 : {
19860 0 : if ( p_ref_to->isInMemoryPool() == false )
19861 : {
19862 0 : std::cout << "SgTypeOfType :: ";
19863 0 : std::cout << " p_ref_to is not in memory pool of ";
19864 0 : std::cout << p_ref_to->class_name() << std::endl;
19865 : }
19866 : }
19867 : else
19868 : {
19869 0 : std::cout << "SgTypeOfType :: " << std::flush;
19870 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
19871 0 : std::cout << " not valid " << std::endl;
19872 : }
19873 : }
19874 :
19875 0 : if ( p_ptr_to != NULL )
19876 : {
19877 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19878 : {
19879 0 : if ( p_ptr_to->isInMemoryPool() == false )
19880 : {
19881 0 : std::cout << "SgTypeOfType :: ";
19882 0 : std::cout << " p_ptr_to is not in memory pool of ";
19883 0 : std::cout << p_ptr_to->class_name() << std::endl;
19884 : }
19885 : }
19886 : else
19887 : {
19888 0 : std::cout << "SgTypeOfType :: " << std::flush;
19889 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
19890 0 : std::cout << " not valid " << std::endl;
19891 : }
19892 : }
19893 :
19894 0 : if ( p_modifiers != NULL )
19895 : {
19896 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19897 : {
19898 0 : if ( p_modifiers->isInMemoryPool() == false )
19899 : {
19900 0 : std::cout << "SgTypeOfType :: ";
19901 0 : std::cout << " p_modifiers is not in memory pool of ";
19902 0 : std::cout << p_modifiers->class_name() << std::endl;
19903 : }
19904 : }
19905 : else
19906 : {
19907 0 : std::cout << "SgTypeOfType :: " << std::flush;
19908 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
19909 0 : std::cout << " not valid " << std::endl;
19910 : }
19911 : }
19912 :
19913 0 : if ( p_typedefs != NULL )
19914 : {
19915 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19916 : {
19917 0 : if ( p_typedefs->isInMemoryPool() == false )
19918 : {
19919 0 : std::cout << "SgTypeOfType :: ";
19920 0 : std::cout << " p_typedefs is not in memory pool of ";
19921 0 : std::cout << p_typedefs->class_name() << std::endl;
19922 : }
19923 : }
19924 : else
19925 : {
19926 0 : std::cout << "SgTypeOfType :: " << std::flush;
19927 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
19928 0 : std::cout << " not valid " << std::endl;
19929 : }
19930 : }
19931 :
19932 0 : if ( p_rvalue_ref_to != NULL )
19933 : {
19934 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19935 : {
19936 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
19937 : {
19938 0 : std::cout << "SgTypeOfType :: ";
19939 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
19940 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
19941 : }
19942 : }
19943 : else
19944 : {
19945 0 : std::cout << "SgTypeOfType :: " << std::flush;
19946 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
19947 0 : std::cout << " not valid " << std::endl;
19948 : }
19949 : }
19950 :
19951 0 : if ( p_decltype_ref_to != NULL )
19952 : {
19953 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19954 : {
19955 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
19956 : {
19957 0 : std::cout << "SgTypeOfType :: ";
19958 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
19959 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
19960 : }
19961 : }
19962 : else
19963 : {
19964 0 : std::cout << "SgTypeOfType :: " << std::flush;
19965 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
19966 0 : std::cout << " not valid " << std::endl;
19967 : }
19968 : }
19969 :
19970 0 : if ( p_typeof_ref_to != NULL )
19971 : {
19972 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19973 : {
19974 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
19975 : {
19976 0 : std::cout << "SgTypeOfType :: ";
19977 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
19978 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
19979 : }
19980 : }
19981 : else
19982 : {
19983 0 : std::cout << "SgTypeOfType :: " << std::flush;
19984 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
19985 0 : std::cout << " not valid " << std::endl;
19986 : }
19987 : }
19988 :
19989 0 : if ( p_type_kind != NULL )
19990 : {
19991 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
19992 : {
19993 0 : if ( p_type_kind->isInMemoryPool() == false )
19994 : {
19995 0 : std::cout << "SgTypeOfType :: ";
19996 0 : std::cout << " p_type_kind is not in memory pool of ";
19997 0 : std::cout << p_type_kind->class_name() << std::endl;
19998 : }
19999 : }
20000 : else
20001 : {
20002 0 : std::cout << "SgTypeOfType :: " << std::flush;
20003 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
20004 0 : std::cout << " not valid " << std::endl;
20005 : }
20006 : }
20007 :
20008 0 : if ( p_parent != NULL )
20009 : {
20010 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20011 : {
20012 0 : if ( p_parent->isInMemoryPool() == false )
20013 : {
20014 0 : std::cout << "SgTypeOfType :: ";
20015 0 : std::cout << " p_parent is not in memory pool of ";
20016 0 : std::cout << p_parent->class_name() << std::endl;
20017 : }
20018 : }
20019 : else
20020 : {
20021 0 : std::cout << "SgTypeOfType :: " << std::flush;
20022 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
20023 0 : std::cout << " not valid " << std::endl;
20024 : }
20025 : }
20026 :
20027 :
20028 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
20029 :
20030 0 : }
20031 :
20032 :
20033 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
20034 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
20035 : bool
20036 0 : SgTypeOfType::isInMemoryPool ()
20037 : {
20038 0 : typedef unsigned char* TestType;
20039 :
20040 0 : bool found = false;
20041 :
20042 0 : ROSE_ASSERT(this != NULL);
20043 :
20044 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
20045 :
20046 0 : TestType tested = (TestType) ( this ) ;
20047 :
20048 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeOfType::pools.begin();
20049 :
20050 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
20051 : // while (found == false && block < Memory_Block_List.end())
20052 0 : while ( (found == false) && (block != SgTypeOfType::pools.end()) )
20053 : {
20054 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeOfType::pool_size * sizeof(SgTypeOfType) ) ) ;
20055 0 : ++block;
20056 : }
20057 :
20058 : // Special handling for static data
20059 :
20060 :
20061 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
20062 0 : ROSE_ASSERT(found == true);
20063 :
20064 0 : return found;
20065 : }
20066 : /* #line 20067 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
20067 :
20068 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
20069 :
20070 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
20071 :
20072 : /* #line 20073 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
20073 :
20074 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
20075 :
20076 : void
20077 0 : SgTypeMatrix::checkDataMemberPointersIfInMemoryPool()
20078 : {
20079 : // ------------ checking pointers of SgTypeMatrix -------------------
20080 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
20081 :
20082 0 : if ( p_base_type != NULL )
20083 : {
20084 0 : if ( p_base_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20085 : {
20086 0 : if ( p_base_type->isInMemoryPool() == false )
20087 : {
20088 0 : std::cout << "SgTypeMatrix :: ";
20089 0 : std::cout << " p_base_type is not in memory pool of ";
20090 0 : std::cout << p_base_type->class_name() << std::endl;
20091 : }
20092 : }
20093 : else
20094 : {
20095 0 : std::cout << "SgTypeMatrix :: " << std::flush;
20096 0 : std::cout << "SgType* p_base_type = " << p_base_type << " --> " << std::flush;
20097 0 : std::cout << " not valid " << std::endl;
20098 : }
20099 : }
20100 :
20101 0 : if ( p_ref_to != NULL )
20102 : {
20103 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20104 : {
20105 0 : if ( p_ref_to->isInMemoryPool() == false )
20106 : {
20107 0 : std::cout << "SgTypeMatrix :: ";
20108 0 : std::cout << " p_ref_to is not in memory pool of ";
20109 0 : std::cout << p_ref_to->class_name() << std::endl;
20110 : }
20111 : }
20112 : else
20113 : {
20114 0 : std::cout << "SgTypeMatrix :: " << std::flush;
20115 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
20116 0 : std::cout << " not valid " << std::endl;
20117 : }
20118 : }
20119 :
20120 0 : if ( p_ptr_to != NULL )
20121 : {
20122 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20123 : {
20124 0 : if ( p_ptr_to->isInMemoryPool() == false )
20125 : {
20126 0 : std::cout << "SgTypeMatrix :: ";
20127 0 : std::cout << " p_ptr_to is not in memory pool of ";
20128 0 : std::cout << p_ptr_to->class_name() << std::endl;
20129 : }
20130 : }
20131 : else
20132 : {
20133 0 : std::cout << "SgTypeMatrix :: " << std::flush;
20134 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
20135 0 : std::cout << " not valid " << std::endl;
20136 : }
20137 : }
20138 :
20139 0 : if ( p_modifiers != NULL )
20140 : {
20141 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20142 : {
20143 0 : if ( p_modifiers->isInMemoryPool() == false )
20144 : {
20145 0 : std::cout << "SgTypeMatrix :: ";
20146 0 : std::cout << " p_modifiers is not in memory pool of ";
20147 0 : std::cout << p_modifiers->class_name() << std::endl;
20148 : }
20149 : }
20150 : else
20151 : {
20152 0 : std::cout << "SgTypeMatrix :: " << std::flush;
20153 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
20154 0 : std::cout << " not valid " << std::endl;
20155 : }
20156 : }
20157 :
20158 0 : if ( p_typedefs != NULL )
20159 : {
20160 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20161 : {
20162 0 : if ( p_typedefs->isInMemoryPool() == false )
20163 : {
20164 0 : std::cout << "SgTypeMatrix :: ";
20165 0 : std::cout << " p_typedefs is not in memory pool of ";
20166 0 : std::cout << p_typedefs->class_name() << std::endl;
20167 : }
20168 : }
20169 : else
20170 : {
20171 0 : std::cout << "SgTypeMatrix :: " << std::flush;
20172 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
20173 0 : std::cout << " not valid " << std::endl;
20174 : }
20175 : }
20176 :
20177 0 : if ( p_rvalue_ref_to != NULL )
20178 : {
20179 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20180 : {
20181 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
20182 : {
20183 0 : std::cout << "SgTypeMatrix :: ";
20184 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
20185 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
20186 : }
20187 : }
20188 : else
20189 : {
20190 0 : std::cout << "SgTypeMatrix :: " << std::flush;
20191 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
20192 0 : std::cout << " not valid " << std::endl;
20193 : }
20194 : }
20195 :
20196 0 : if ( p_decltype_ref_to != NULL )
20197 : {
20198 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20199 : {
20200 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
20201 : {
20202 0 : std::cout << "SgTypeMatrix :: ";
20203 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
20204 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
20205 : }
20206 : }
20207 : else
20208 : {
20209 0 : std::cout << "SgTypeMatrix :: " << std::flush;
20210 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
20211 0 : std::cout << " not valid " << std::endl;
20212 : }
20213 : }
20214 :
20215 0 : if ( p_typeof_ref_to != NULL )
20216 : {
20217 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20218 : {
20219 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
20220 : {
20221 0 : std::cout << "SgTypeMatrix :: ";
20222 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
20223 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
20224 : }
20225 : }
20226 : else
20227 : {
20228 0 : std::cout << "SgTypeMatrix :: " << std::flush;
20229 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
20230 0 : std::cout << " not valid " << std::endl;
20231 : }
20232 : }
20233 :
20234 0 : if ( p_type_kind != NULL )
20235 : {
20236 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20237 : {
20238 0 : if ( p_type_kind->isInMemoryPool() == false )
20239 : {
20240 0 : std::cout << "SgTypeMatrix :: ";
20241 0 : std::cout << " p_type_kind is not in memory pool of ";
20242 0 : std::cout << p_type_kind->class_name() << std::endl;
20243 : }
20244 : }
20245 : else
20246 : {
20247 0 : std::cout << "SgTypeMatrix :: " << std::flush;
20248 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
20249 0 : std::cout << " not valid " << std::endl;
20250 : }
20251 : }
20252 :
20253 0 : if ( p_parent != NULL )
20254 : {
20255 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20256 : {
20257 0 : if ( p_parent->isInMemoryPool() == false )
20258 : {
20259 0 : std::cout << "SgTypeMatrix :: ";
20260 0 : std::cout << " p_parent is not in memory pool of ";
20261 0 : std::cout << p_parent->class_name() << std::endl;
20262 : }
20263 : }
20264 : else
20265 : {
20266 0 : std::cout << "SgTypeMatrix :: " << std::flush;
20267 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
20268 0 : std::cout << " not valid " << std::endl;
20269 : }
20270 : }
20271 :
20272 :
20273 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
20274 :
20275 0 : }
20276 :
20277 :
20278 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
20279 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
20280 : bool
20281 0 : SgTypeMatrix::isInMemoryPool ()
20282 : {
20283 0 : typedef unsigned char* TestType;
20284 :
20285 0 : bool found = false;
20286 :
20287 0 : ROSE_ASSERT(this != NULL);
20288 :
20289 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
20290 :
20291 0 : TestType tested = (TestType) ( this ) ;
20292 :
20293 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeMatrix::pools.begin();
20294 :
20295 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
20296 : // while (found == false && block < Memory_Block_List.end())
20297 0 : while ( (found == false) && (block != SgTypeMatrix::pools.end()) )
20298 : {
20299 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeMatrix::pool_size * sizeof(SgTypeMatrix) ) ) ;
20300 0 : ++block;
20301 : }
20302 :
20303 : // Special handling for static data
20304 :
20305 :
20306 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
20307 0 : ROSE_ASSERT(found == true);
20308 :
20309 0 : return found;
20310 : }
20311 : /* #line 20312 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
20312 :
20313 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
20314 :
20315 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
20316 :
20317 : /* #line 20318 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
20318 :
20319 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
20320 :
20321 : void
20322 0 : SgTypeTuple::checkDataMemberPointersIfInMemoryPool()
20323 : {
20324 : // ------------ checking pointers of SgTypeTuple -------------------
20325 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
20326 :
20327 0 : SgTypePtrList::iterator i_types = p_types.begin() ;
20328 0 : for ( ; i_types != p_types.end(); ++i_types )
20329 : {
20330 0 : if ( (*i_types) != NULL )
20331 : {
20332 0 : if ( (*i_types)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20333 : {
20334 0 : if ( (*i_types)->isInMemoryPool() == false )
20335 : {
20336 0 : std::cout << "SgTypeTuple :: ";
20337 0 : std::cout << " p_types ( list of poitners to IR nodes ), entry is not in memory pool of ";
20338 0 : std::cout << (*i_types)->class_name() << std::endl;
20339 : }
20340 : }
20341 : else
20342 : {
20343 0 : std::cout << "SgTypeTuple :: " << std::flush;
20344 0 : std::cout << "SgTypePtrList p_types --> " << std::flush;
20345 0 : std::cout << " entry not valid " << std::endl;
20346 : }
20347 : }
20348 : else
20349 : {
20350 0 : std::cout << "SgTypePtrList p_types --> NULL " << std::endl;
20351 : }
20352 : }
20353 :
20354 0 : if ( p_ref_to != NULL )
20355 : {
20356 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20357 : {
20358 0 : if ( p_ref_to->isInMemoryPool() == false )
20359 : {
20360 0 : std::cout << "SgTypeTuple :: ";
20361 0 : std::cout << " p_ref_to is not in memory pool of ";
20362 0 : std::cout << p_ref_to->class_name() << std::endl;
20363 : }
20364 : }
20365 : else
20366 : {
20367 0 : std::cout << "SgTypeTuple :: " << std::flush;
20368 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
20369 0 : std::cout << " not valid " << std::endl;
20370 : }
20371 : }
20372 :
20373 0 : if ( p_ptr_to != NULL )
20374 : {
20375 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20376 : {
20377 0 : if ( p_ptr_to->isInMemoryPool() == false )
20378 : {
20379 0 : std::cout << "SgTypeTuple :: ";
20380 0 : std::cout << " p_ptr_to is not in memory pool of ";
20381 0 : std::cout << p_ptr_to->class_name() << std::endl;
20382 : }
20383 : }
20384 : else
20385 : {
20386 0 : std::cout << "SgTypeTuple :: " << std::flush;
20387 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
20388 0 : std::cout << " not valid " << std::endl;
20389 : }
20390 : }
20391 :
20392 0 : if ( p_modifiers != NULL )
20393 : {
20394 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20395 : {
20396 0 : if ( p_modifiers->isInMemoryPool() == false )
20397 : {
20398 0 : std::cout << "SgTypeTuple :: ";
20399 0 : std::cout << " p_modifiers is not in memory pool of ";
20400 0 : std::cout << p_modifiers->class_name() << std::endl;
20401 : }
20402 : }
20403 : else
20404 : {
20405 0 : std::cout << "SgTypeTuple :: " << std::flush;
20406 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
20407 0 : std::cout << " not valid " << std::endl;
20408 : }
20409 : }
20410 :
20411 0 : if ( p_typedefs != NULL )
20412 : {
20413 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20414 : {
20415 0 : if ( p_typedefs->isInMemoryPool() == false )
20416 : {
20417 0 : std::cout << "SgTypeTuple :: ";
20418 0 : std::cout << " p_typedefs is not in memory pool of ";
20419 0 : std::cout << p_typedefs->class_name() << std::endl;
20420 : }
20421 : }
20422 : else
20423 : {
20424 0 : std::cout << "SgTypeTuple :: " << std::flush;
20425 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
20426 0 : std::cout << " not valid " << std::endl;
20427 : }
20428 : }
20429 :
20430 0 : if ( p_rvalue_ref_to != NULL )
20431 : {
20432 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20433 : {
20434 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
20435 : {
20436 0 : std::cout << "SgTypeTuple :: ";
20437 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
20438 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
20439 : }
20440 : }
20441 : else
20442 : {
20443 0 : std::cout << "SgTypeTuple :: " << std::flush;
20444 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
20445 0 : std::cout << " not valid " << std::endl;
20446 : }
20447 : }
20448 :
20449 0 : if ( p_decltype_ref_to != NULL )
20450 : {
20451 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20452 : {
20453 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
20454 : {
20455 0 : std::cout << "SgTypeTuple :: ";
20456 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
20457 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
20458 : }
20459 : }
20460 : else
20461 : {
20462 0 : std::cout << "SgTypeTuple :: " << std::flush;
20463 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
20464 0 : std::cout << " not valid " << std::endl;
20465 : }
20466 : }
20467 :
20468 0 : if ( p_typeof_ref_to != NULL )
20469 : {
20470 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20471 : {
20472 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
20473 : {
20474 0 : std::cout << "SgTypeTuple :: ";
20475 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
20476 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
20477 : }
20478 : }
20479 : else
20480 : {
20481 0 : std::cout << "SgTypeTuple :: " << std::flush;
20482 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
20483 0 : std::cout << " not valid " << std::endl;
20484 : }
20485 : }
20486 :
20487 0 : if ( p_type_kind != NULL )
20488 : {
20489 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20490 : {
20491 0 : if ( p_type_kind->isInMemoryPool() == false )
20492 : {
20493 0 : std::cout << "SgTypeTuple :: ";
20494 0 : std::cout << " p_type_kind is not in memory pool of ";
20495 0 : std::cout << p_type_kind->class_name() << std::endl;
20496 : }
20497 : }
20498 : else
20499 : {
20500 0 : std::cout << "SgTypeTuple :: " << std::flush;
20501 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
20502 0 : std::cout << " not valid " << std::endl;
20503 : }
20504 : }
20505 :
20506 0 : if ( p_parent != NULL )
20507 : {
20508 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20509 : {
20510 0 : if ( p_parent->isInMemoryPool() == false )
20511 : {
20512 0 : std::cout << "SgTypeTuple :: ";
20513 0 : std::cout << " p_parent is not in memory pool of ";
20514 0 : std::cout << p_parent->class_name() << std::endl;
20515 : }
20516 : }
20517 : else
20518 : {
20519 0 : std::cout << "SgTypeTuple :: " << std::flush;
20520 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
20521 0 : std::cout << " not valid " << std::endl;
20522 : }
20523 : }
20524 :
20525 :
20526 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
20527 :
20528 0 : }
20529 :
20530 :
20531 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
20532 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
20533 : bool
20534 0 : SgTypeTuple::isInMemoryPool ()
20535 : {
20536 0 : typedef unsigned char* TestType;
20537 :
20538 0 : bool found = false;
20539 :
20540 0 : ROSE_ASSERT(this != NULL);
20541 :
20542 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
20543 :
20544 0 : TestType tested = (TestType) ( this ) ;
20545 :
20546 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeTuple::pools.begin();
20547 :
20548 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
20549 : // while (found == false && block < Memory_Block_List.end())
20550 0 : while ( (found == false) && (block != SgTypeTuple::pools.end()) )
20551 : {
20552 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeTuple::pool_size * sizeof(SgTypeTuple) ) ) ;
20553 0 : ++block;
20554 : }
20555 :
20556 : // Special handling for static data
20557 :
20558 :
20559 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
20560 0 : ROSE_ASSERT(found == true);
20561 :
20562 0 : return found;
20563 : }
20564 : /* #line 20565 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
20565 :
20566 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
20567 :
20568 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
20569 :
20570 : /* #line 20571 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
20571 :
20572 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
20573 :
20574 : void
20575 0 : SgTypeChar16::checkDataMemberPointersIfInMemoryPool()
20576 : {
20577 : // ------------ checking pointers of SgTypeChar16 -------------------
20578 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
20579 :
20580 0 : if ( p_ref_to != NULL )
20581 : {
20582 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20583 : {
20584 0 : if ( p_ref_to->isInMemoryPool() == false )
20585 : {
20586 0 : std::cout << "SgTypeChar16 :: ";
20587 0 : std::cout << " p_ref_to is not in memory pool of ";
20588 0 : std::cout << p_ref_to->class_name() << std::endl;
20589 : }
20590 : }
20591 : else
20592 : {
20593 0 : std::cout << "SgTypeChar16 :: " << std::flush;
20594 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
20595 0 : std::cout << " not valid " << std::endl;
20596 : }
20597 : }
20598 :
20599 0 : if ( p_ptr_to != NULL )
20600 : {
20601 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20602 : {
20603 0 : if ( p_ptr_to->isInMemoryPool() == false )
20604 : {
20605 0 : std::cout << "SgTypeChar16 :: ";
20606 0 : std::cout << " p_ptr_to is not in memory pool of ";
20607 0 : std::cout << p_ptr_to->class_name() << std::endl;
20608 : }
20609 : }
20610 : else
20611 : {
20612 0 : std::cout << "SgTypeChar16 :: " << std::flush;
20613 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
20614 0 : std::cout << " not valid " << std::endl;
20615 : }
20616 : }
20617 :
20618 0 : if ( p_modifiers != NULL )
20619 : {
20620 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20621 : {
20622 0 : if ( p_modifiers->isInMemoryPool() == false )
20623 : {
20624 0 : std::cout << "SgTypeChar16 :: ";
20625 0 : std::cout << " p_modifiers is not in memory pool of ";
20626 0 : std::cout << p_modifiers->class_name() << std::endl;
20627 : }
20628 : }
20629 : else
20630 : {
20631 0 : std::cout << "SgTypeChar16 :: " << std::flush;
20632 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
20633 0 : std::cout << " not valid " << std::endl;
20634 : }
20635 : }
20636 :
20637 0 : if ( p_typedefs != NULL )
20638 : {
20639 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20640 : {
20641 0 : if ( p_typedefs->isInMemoryPool() == false )
20642 : {
20643 0 : std::cout << "SgTypeChar16 :: ";
20644 0 : std::cout << " p_typedefs is not in memory pool of ";
20645 0 : std::cout << p_typedefs->class_name() << std::endl;
20646 : }
20647 : }
20648 : else
20649 : {
20650 0 : std::cout << "SgTypeChar16 :: " << std::flush;
20651 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
20652 0 : std::cout << " not valid " << std::endl;
20653 : }
20654 : }
20655 :
20656 0 : if ( p_rvalue_ref_to != NULL )
20657 : {
20658 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20659 : {
20660 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
20661 : {
20662 0 : std::cout << "SgTypeChar16 :: ";
20663 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
20664 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
20665 : }
20666 : }
20667 : else
20668 : {
20669 0 : std::cout << "SgTypeChar16 :: " << std::flush;
20670 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
20671 0 : std::cout << " not valid " << std::endl;
20672 : }
20673 : }
20674 :
20675 0 : if ( p_decltype_ref_to != NULL )
20676 : {
20677 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20678 : {
20679 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
20680 : {
20681 0 : std::cout << "SgTypeChar16 :: ";
20682 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
20683 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
20684 : }
20685 : }
20686 : else
20687 : {
20688 0 : std::cout << "SgTypeChar16 :: " << std::flush;
20689 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
20690 0 : std::cout << " not valid " << std::endl;
20691 : }
20692 : }
20693 :
20694 0 : if ( p_typeof_ref_to != NULL )
20695 : {
20696 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20697 : {
20698 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
20699 : {
20700 0 : std::cout << "SgTypeChar16 :: ";
20701 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
20702 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
20703 : }
20704 : }
20705 : else
20706 : {
20707 0 : std::cout << "SgTypeChar16 :: " << std::flush;
20708 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
20709 0 : std::cout << " not valid " << std::endl;
20710 : }
20711 : }
20712 :
20713 0 : if ( p_type_kind != NULL )
20714 : {
20715 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20716 : {
20717 0 : if ( p_type_kind->isInMemoryPool() == false )
20718 : {
20719 0 : std::cout << "SgTypeChar16 :: ";
20720 0 : std::cout << " p_type_kind is not in memory pool of ";
20721 0 : std::cout << p_type_kind->class_name() << std::endl;
20722 : }
20723 : }
20724 : else
20725 : {
20726 0 : std::cout << "SgTypeChar16 :: " << std::flush;
20727 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
20728 0 : std::cout << " not valid " << std::endl;
20729 : }
20730 : }
20731 :
20732 0 : if ( p_parent != NULL )
20733 : {
20734 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20735 : {
20736 0 : if ( p_parent->isInMemoryPool() == false )
20737 : {
20738 0 : std::cout << "SgTypeChar16 :: ";
20739 0 : std::cout << " p_parent is not in memory pool of ";
20740 0 : std::cout << p_parent->class_name() << std::endl;
20741 : }
20742 : }
20743 : else
20744 : {
20745 0 : std::cout << "SgTypeChar16 :: " << std::flush;
20746 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
20747 0 : std::cout << " not valid " << std::endl;
20748 : }
20749 : }
20750 :
20751 :
20752 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
20753 :
20754 0 : }
20755 :
20756 :
20757 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
20758 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
20759 : bool
20760 0 : SgTypeChar16::isInMemoryPool ()
20761 : {
20762 0 : typedef unsigned char* TestType;
20763 :
20764 0 : bool found = false;
20765 :
20766 0 : ROSE_ASSERT(this != NULL);
20767 :
20768 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
20769 :
20770 0 : TestType tested = (TestType) ( this ) ;
20771 :
20772 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeChar16::pools.begin();
20773 :
20774 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
20775 : // while (found == false && block < Memory_Block_List.end())
20776 0 : while ( (found == false) && (block != SgTypeChar16::pools.end()) )
20777 : {
20778 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeChar16::pool_size * sizeof(SgTypeChar16) ) ) ;
20779 0 : ++block;
20780 : }
20781 :
20782 : // Special handling for static data
20783 :
20784 :
20785 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
20786 0 : ROSE_ASSERT(found == true);
20787 :
20788 0 : return found;
20789 : }
20790 : /* #line 20791 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
20791 :
20792 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
20793 :
20794 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
20795 :
20796 : /* #line 20797 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
20797 :
20798 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
20799 :
20800 : void
20801 0 : SgTypeChar32::checkDataMemberPointersIfInMemoryPool()
20802 : {
20803 : // ------------ checking pointers of SgTypeChar32 -------------------
20804 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
20805 :
20806 0 : if ( p_ref_to != NULL )
20807 : {
20808 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20809 : {
20810 0 : if ( p_ref_to->isInMemoryPool() == false )
20811 : {
20812 0 : std::cout << "SgTypeChar32 :: ";
20813 0 : std::cout << " p_ref_to is not in memory pool of ";
20814 0 : std::cout << p_ref_to->class_name() << std::endl;
20815 : }
20816 : }
20817 : else
20818 : {
20819 0 : std::cout << "SgTypeChar32 :: " << std::flush;
20820 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
20821 0 : std::cout << " not valid " << std::endl;
20822 : }
20823 : }
20824 :
20825 0 : if ( p_ptr_to != NULL )
20826 : {
20827 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20828 : {
20829 0 : if ( p_ptr_to->isInMemoryPool() == false )
20830 : {
20831 0 : std::cout << "SgTypeChar32 :: ";
20832 0 : std::cout << " p_ptr_to is not in memory pool of ";
20833 0 : std::cout << p_ptr_to->class_name() << std::endl;
20834 : }
20835 : }
20836 : else
20837 : {
20838 0 : std::cout << "SgTypeChar32 :: " << std::flush;
20839 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
20840 0 : std::cout << " not valid " << std::endl;
20841 : }
20842 : }
20843 :
20844 0 : if ( p_modifiers != NULL )
20845 : {
20846 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20847 : {
20848 0 : if ( p_modifiers->isInMemoryPool() == false )
20849 : {
20850 0 : std::cout << "SgTypeChar32 :: ";
20851 0 : std::cout << " p_modifiers is not in memory pool of ";
20852 0 : std::cout << p_modifiers->class_name() << std::endl;
20853 : }
20854 : }
20855 : else
20856 : {
20857 0 : std::cout << "SgTypeChar32 :: " << std::flush;
20858 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
20859 0 : std::cout << " not valid " << std::endl;
20860 : }
20861 : }
20862 :
20863 0 : if ( p_typedefs != NULL )
20864 : {
20865 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20866 : {
20867 0 : if ( p_typedefs->isInMemoryPool() == false )
20868 : {
20869 0 : std::cout << "SgTypeChar32 :: ";
20870 0 : std::cout << " p_typedefs is not in memory pool of ";
20871 0 : std::cout << p_typedefs->class_name() << std::endl;
20872 : }
20873 : }
20874 : else
20875 : {
20876 0 : std::cout << "SgTypeChar32 :: " << std::flush;
20877 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
20878 0 : std::cout << " not valid " << std::endl;
20879 : }
20880 : }
20881 :
20882 0 : if ( p_rvalue_ref_to != NULL )
20883 : {
20884 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20885 : {
20886 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
20887 : {
20888 0 : std::cout << "SgTypeChar32 :: ";
20889 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
20890 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
20891 : }
20892 : }
20893 : else
20894 : {
20895 0 : std::cout << "SgTypeChar32 :: " << std::flush;
20896 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
20897 0 : std::cout << " not valid " << std::endl;
20898 : }
20899 : }
20900 :
20901 0 : if ( p_decltype_ref_to != NULL )
20902 : {
20903 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20904 : {
20905 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
20906 : {
20907 0 : std::cout << "SgTypeChar32 :: ";
20908 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
20909 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
20910 : }
20911 : }
20912 : else
20913 : {
20914 0 : std::cout << "SgTypeChar32 :: " << std::flush;
20915 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
20916 0 : std::cout << " not valid " << std::endl;
20917 : }
20918 : }
20919 :
20920 0 : if ( p_typeof_ref_to != NULL )
20921 : {
20922 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20923 : {
20924 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
20925 : {
20926 0 : std::cout << "SgTypeChar32 :: ";
20927 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
20928 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
20929 : }
20930 : }
20931 : else
20932 : {
20933 0 : std::cout << "SgTypeChar32 :: " << std::flush;
20934 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
20935 0 : std::cout << " not valid " << std::endl;
20936 : }
20937 : }
20938 :
20939 0 : if ( p_type_kind != NULL )
20940 : {
20941 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20942 : {
20943 0 : if ( p_type_kind->isInMemoryPool() == false )
20944 : {
20945 0 : std::cout << "SgTypeChar32 :: ";
20946 0 : std::cout << " p_type_kind is not in memory pool of ";
20947 0 : std::cout << p_type_kind->class_name() << std::endl;
20948 : }
20949 : }
20950 : else
20951 : {
20952 0 : std::cout << "SgTypeChar32 :: " << std::flush;
20953 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
20954 0 : std::cout << " not valid " << std::endl;
20955 : }
20956 : }
20957 :
20958 0 : if ( p_parent != NULL )
20959 : {
20960 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
20961 : {
20962 0 : if ( p_parent->isInMemoryPool() == false )
20963 : {
20964 0 : std::cout << "SgTypeChar32 :: ";
20965 0 : std::cout << " p_parent is not in memory pool of ";
20966 0 : std::cout << p_parent->class_name() << std::endl;
20967 : }
20968 : }
20969 : else
20970 : {
20971 0 : std::cout << "SgTypeChar32 :: " << std::flush;
20972 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
20973 0 : std::cout << " not valid " << std::endl;
20974 : }
20975 : }
20976 :
20977 :
20978 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
20979 :
20980 0 : }
20981 :
20982 :
20983 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
20984 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
20985 : bool
20986 0 : SgTypeChar32::isInMemoryPool ()
20987 : {
20988 0 : typedef unsigned char* TestType;
20989 :
20990 0 : bool found = false;
20991 :
20992 0 : ROSE_ASSERT(this != NULL);
20993 :
20994 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
20995 :
20996 0 : TestType tested = (TestType) ( this ) ;
20997 :
20998 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeChar32::pools.begin();
20999 :
21000 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
21001 : // while (found == false && block < Memory_Block_List.end())
21002 0 : while ( (found == false) && (block != SgTypeChar32::pools.end()) )
21003 : {
21004 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeChar32::pool_size * sizeof(SgTypeChar32) ) ) ;
21005 0 : ++block;
21006 : }
21007 :
21008 : // Special handling for static data
21009 :
21010 :
21011 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
21012 0 : ROSE_ASSERT(found == true);
21013 :
21014 0 : return found;
21015 : }
21016 : /* #line 21017 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
21017 :
21018 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
21019 :
21020 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21021 :
21022 : /* #line 21023 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
21023 :
21024 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21025 :
21026 : void
21027 0 : SgTypeFloat128::checkDataMemberPointersIfInMemoryPool()
21028 : {
21029 : // ------------ checking pointers of SgTypeFloat128 -------------------
21030 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
21031 :
21032 0 : if ( p_ref_to != NULL )
21033 : {
21034 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21035 : {
21036 0 : if ( p_ref_to->isInMemoryPool() == false )
21037 : {
21038 0 : std::cout << "SgTypeFloat128 :: ";
21039 0 : std::cout << " p_ref_to is not in memory pool of ";
21040 0 : std::cout << p_ref_to->class_name() << std::endl;
21041 : }
21042 : }
21043 : else
21044 : {
21045 0 : std::cout << "SgTypeFloat128 :: " << std::flush;
21046 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
21047 0 : std::cout << " not valid " << std::endl;
21048 : }
21049 : }
21050 :
21051 0 : if ( p_ptr_to != NULL )
21052 : {
21053 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21054 : {
21055 0 : if ( p_ptr_to->isInMemoryPool() == false )
21056 : {
21057 0 : std::cout << "SgTypeFloat128 :: ";
21058 0 : std::cout << " p_ptr_to is not in memory pool of ";
21059 0 : std::cout << p_ptr_to->class_name() << std::endl;
21060 : }
21061 : }
21062 : else
21063 : {
21064 0 : std::cout << "SgTypeFloat128 :: " << std::flush;
21065 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
21066 0 : std::cout << " not valid " << std::endl;
21067 : }
21068 : }
21069 :
21070 0 : if ( p_modifiers != NULL )
21071 : {
21072 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21073 : {
21074 0 : if ( p_modifiers->isInMemoryPool() == false )
21075 : {
21076 0 : std::cout << "SgTypeFloat128 :: ";
21077 0 : std::cout << " p_modifiers is not in memory pool of ";
21078 0 : std::cout << p_modifiers->class_name() << std::endl;
21079 : }
21080 : }
21081 : else
21082 : {
21083 0 : std::cout << "SgTypeFloat128 :: " << std::flush;
21084 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
21085 0 : std::cout << " not valid " << std::endl;
21086 : }
21087 : }
21088 :
21089 0 : if ( p_typedefs != NULL )
21090 : {
21091 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21092 : {
21093 0 : if ( p_typedefs->isInMemoryPool() == false )
21094 : {
21095 0 : std::cout << "SgTypeFloat128 :: ";
21096 0 : std::cout << " p_typedefs is not in memory pool of ";
21097 0 : std::cout << p_typedefs->class_name() << std::endl;
21098 : }
21099 : }
21100 : else
21101 : {
21102 0 : std::cout << "SgTypeFloat128 :: " << std::flush;
21103 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
21104 0 : std::cout << " not valid " << std::endl;
21105 : }
21106 : }
21107 :
21108 0 : if ( p_rvalue_ref_to != NULL )
21109 : {
21110 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21111 : {
21112 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
21113 : {
21114 0 : std::cout << "SgTypeFloat128 :: ";
21115 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
21116 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
21117 : }
21118 : }
21119 : else
21120 : {
21121 0 : std::cout << "SgTypeFloat128 :: " << std::flush;
21122 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
21123 0 : std::cout << " not valid " << std::endl;
21124 : }
21125 : }
21126 :
21127 0 : if ( p_decltype_ref_to != NULL )
21128 : {
21129 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21130 : {
21131 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
21132 : {
21133 0 : std::cout << "SgTypeFloat128 :: ";
21134 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
21135 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
21136 : }
21137 : }
21138 : else
21139 : {
21140 0 : std::cout << "SgTypeFloat128 :: " << std::flush;
21141 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
21142 0 : std::cout << " not valid " << std::endl;
21143 : }
21144 : }
21145 :
21146 0 : if ( p_typeof_ref_to != NULL )
21147 : {
21148 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21149 : {
21150 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
21151 : {
21152 0 : std::cout << "SgTypeFloat128 :: ";
21153 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
21154 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
21155 : }
21156 : }
21157 : else
21158 : {
21159 0 : std::cout << "SgTypeFloat128 :: " << std::flush;
21160 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
21161 0 : std::cout << " not valid " << std::endl;
21162 : }
21163 : }
21164 :
21165 0 : if ( p_type_kind != NULL )
21166 : {
21167 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21168 : {
21169 0 : if ( p_type_kind->isInMemoryPool() == false )
21170 : {
21171 0 : std::cout << "SgTypeFloat128 :: ";
21172 0 : std::cout << " p_type_kind is not in memory pool of ";
21173 0 : std::cout << p_type_kind->class_name() << std::endl;
21174 : }
21175 : }
21176 : else
21177 : {
21178 0 : std::cout << "SgTypeFloat128 :: " << std::flush;
21179 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
21180 0 : std::cout << " not valid " << std::endl;
21181 : }
21182 : }
21183 :
21184 0 : if ( p_parent != NULL )
21185 : {
21186 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21187 : {
21188 0 : if ( p_parent->isInMemoryPool() == false )
21189 : {
21190 0 : std::cout << "SgTypeFloat128 :: ";
21191 0 : std::cout << " p_parent is not in memory pool of ";
21192 0 : std::cout << p_parent->class_name() << std::endl;
21193 : }
21194 : }
21195 : else
21196 : {
21197 0 : std::cout << "SgTypeFloat128 :: " << std::flush;
21198 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
21199 0 : std::cout << " not valid " << std::endl;
21200 : }
21201 : }
21202 :
21203 :
21204 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21205 :
21206 0 : }
21207 :
21208 :
21209 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
21210 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
21211 : bool
21212 0 : SgTypeFloat128::isInMemoryPool ()
21213 : {
21214 0 : typedef unsigned char* TestType;
21215 :
21216 0 : bool found = false;
21217 :
21218 0 : ROSE_ASSERT(this != NULL);
21219 :
21220 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
21221 :
21222 0 : TestType tested = (TestType) ( this ) ;
21223 :
21224 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeFloat128::pools.begin();
21225 :
21226 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
21227 : // while (found == false && block < Memory_Block_List.end())
21228 0 : while ( (found == false) && (block != SgTypeFloat128::pools.end()) )
21229 : {
21230 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeFloat128::pool_size * sizeof(SgTypeFloat128) ) ) ;
21231 0 : ++block;
21232 : }
21233 :
21234 : // Special handling for static data
21235 :
21236 :
21237 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
21238 0 : ROSE_ASSERT(found == true);
21239 :
21240 0 : return found;
21241 : }
21242 : /* #line 21243 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
21243 :
21244 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
21245 :
21246 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21247 :
21248 : /* #line 21249 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
21249 :
21250 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21251 :
21252 : void
21253 0 : SgTypeFixed::checkDataMemberPointersIfInMemoryPool()
21254 : {
21255 : // ------------ checking pointers of SgTypeFixed -------------------
21256 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
21257 :
21258 0 : if ( p_scale != NULL )
21259 : {
21260 0 : if ( p_scale->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21261 : {
21262 0 : if ( p_scale->isInMemoryPool() == false )
21263 : {
21264 0 : std::cout << "SgTypeFixed :: ";
21265 0 : std::cout << " p_scale is not in memory pool of ";
21266 0 : std::cout << p_scale->class_name() << std::endl;
21267 : }
21268 : }
21269 : else
21270 : {
21271 0 : std::cout << "SgTypeFixed :: " << std::flush;
21272 0 : std::cout << "SgExpression* p_scale = " << p_scale << " --> " << std::flush;
21273 0 : std::cout << " not valid " << std::endl;
21274 : }
21275 : }
21276 :
21277 0 : if ( p_fraction != NULL )
21278 : {
21279 0 : if ( p_fraction->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21280 : {
21281 0 : if ( p_fraction->isInMemoryPool() == false )
21282 : {
21283 0 : std::cout << "SgTypeFixed :: ";
21284 0 : std::cout << " p_fraction is not in memory pool of ";
21285 0 : std::cout << p_fraction->class_name() << std::endl;
21286 : }
21287 : }
21288 : else
21289 : {
21290 0 : std::cout << "SgTypeFixed :: " << std::flush;
21291 0 : std::cout << "SgExpression* p_fraction = " << p_fraction << " --> " << std::flush;
21292 0 : std::cout << " not valid " << std::endl;
21293 : }
21294 : }
21295 :
21296 0 : if ( p_ref_to != NULL )
21297 : {
21298 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21299 : {
21300 0 : if ( p_ref_to->isInMemoryPool() == false )
21301 : {
21302 0 : std::cout << "SgTypeFixed :: ";
21303 0 : std::cout << " p_ref_to is not in memory pool of ";
21304 0 : std::cout << p_ref_to->class_name() << std::endl;
21305 : }
21306 : }
21307 : else
21308 : {
21309 0 : std::cout << "SgTypeFixed :: " << std::flush;
21310 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
21311 0 : std::cout << " not valid " << std::endl;
21312 : }
21313 : }
21314 :
21315 0 : if ( p_ptr_to != NULL )
21316 : {
21317 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21318 : {
21319 0 : if ( p_ptr_to->isInMemoryPool() == false )
21320 : {
21321 0 : std::cout << "SgTypeFixed :: ";
21322 0 : std::cout << " p_ptr_to is not in memory pool of ";
21323 0 : std::cout << p_ptr_to->class_name() << std::endl;
21324 : }
21325 : }
21326 : else
21327 : {
21328 0 : std::cout << "SgTypeFixed :: " << std::flush;
21329 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
21330 0 : std::cout << " not valid " << std::endl;
21331 : }
21332 : }
21333 :
21334 0 : if ( p_modifiers != NULL )
21335 : {
21336 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21337 : {
21338 0 : if ( p_modifiers->isInMemoryPool() == false )
21339 : {
21340 0 : std::cout << "SgTypeFixed :: ";
21341 0 : std::cout << " p_modifiers is not in memory pool of ";
21342 0 : std::cout << p_modifiers->class_name() << std::endl;
21343 : }
21344 : }
21345 : else
21346 : {
21347 0 : std::cout << "SgTypeFixed :: " << std::flush;
21348 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
21349 0 : std::cout << " not valid " << std::endl;
21350 : }
21351 : }
21352 :
21353 0 : if ( p_typedefs != NULL )
21354 : {
21355 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21356 : {
21357 0 : if ( p_typedefs->isInMemoryPool() == false )
21358 : {
21359 0 : std::cout << "SgTypeFixed :: ";
21360 0 : std::cout << " p_typedefs is not in memory pool of ";
21361 0 : std::cout << p_typedefs->class_name() << std::endl;
21362 : }
21363 : }
21364 : else
21365 : {
21366 0 : std::cout << "SgTypeFixed :: " << std::flush;
21367 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
21368 0 : std::cout << " not valid " << std::endl;
21369 : }
21370 : }
21371 :
21372 0 : if ( p_rvalue_ref_to != NULL )
21373 : {
21374 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21375 : {
21376 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
21377 : {
21378 0 : std::cout << "SgTypeFixed :: ";
21379 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
21380 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
21381 : }
21382 : }
21383 : else
21384 : {
21385 0 : std::cout << "SgTypeFixed :: " << std::flush;
21386 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
21387 0 : std::cout << " not valid " << std::endl;
21388 : }
21389 : }
21390 :
21391 0 : if ( p_decltype_ref_to != NULL )
21392 : {
21393 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21394 : {
21395 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
21396 : {
21397 0 : std::cout << "SgTypeFixed :: ";
21398 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
21399 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
21400 : }
21401 : }
21402 : else
21403 : {
21404 0 : std::cout << "SgTypeFixed :: " << std::flush;
21405 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
21406 0 : std::cout << " not valid " << std::endl;
21407 : }
21408 : }
21409 :
21410 0 : if ( p_typeof_ref_to != NULL )
21411 : {
21412 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21413 : {
21414 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
21415 : {
21416 0 : std::cout << "SgTypeFixed :: ";
21417 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
21418 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
21419 : }
21420 : }
21421 : else
21422 : {
21423 0 : std::cout << "SgTypeFixed :: " << std::flush;
21424 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
21425 0 : std::cout << " not valid " << std::endl;
21426 : }
21427 : }
21428 :
21429 0 : if ( p_type_kind != NULL )
21430 : {
21431 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21432 : {
21433 0 : if ( p_type_kind->isInMemoryPool() == false )
21434 : {
21435 0 : std::cout << "SgTypeFixed :: ";
21436 0 : std::cout << " p_type_kind is not in memory pool of ";
21437 0 : std::cout << p_type_kind->class_name() << std::endl;
21438 : }
21439 : }
21440 : else
21441 : {
21442 0 : std::cout << "SgTypeFixed :: " << std::flush;
21443 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
21444 0 : std::cout << " not valid " << std::endl;
21445 : }
21446 : }
21447 :
21448 0 : if ( p_parent != NULL )
21449 : {
21450 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21451 : {
21452 0 : if ( p_parent->isInMemoryPool() == false )
21453 : {
21454 0 : std::cout << "SgTypeFixed :: ";
21455 0 : std::cout << " p_parent is not in memory pool of ";
21456 0 : std::cout << p_parent->class_name() << std::endl;
21457 : }
21458 : }
21459 : else
21460 : {
21461 0 : std::cout << "SgTypeFixed :: " << std::flush;
21462 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
21463 0 : std::cout << " not valid " << std::endl;
21464 : }
21465 : }
21466 :
21467 :
21468 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21469 :
21470 0 : }
21471 :
21472 :
21473 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
21474 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
21475 : bool
21476 0 : SgTypeFixed::isInMemoryPool ()
21477 : {
21478 0 : typedef unsigned char* TestType;
21479 :
21480 0 : bool found = false;
21481 :
21482 0 : ROSE_ASSERT(this != NULL);
21483 :
21484 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
21485 :
21486 0 : TestType tested = (TestType) ( this ) ;
21487 :
21488 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeFixed::pools.begin();
21489 :
21490 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
21491 : // while (found == false && block < Memory_Block_List.end())
21492 0 : while ( (found == false) && (block != SgTypeFixed::pools.end()) )
21493 : {
21494 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeFixed::pool_size * sizeof(SgTypeFixed) ) ) ;
21495 0 : ++block;
21496 : }
21497 :
21498 : // Special handling for static data
21499 :
21500 :
21501 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
21502 0 : ROSE_ASSERT(found == true);
21503 :
21504 0 : return found;
21505 : }
21506 : /* #line 21507 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
21507 :
21508 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
21509 :
21510 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21511 :
21512 : /* #line 21513 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
21513 :
21514 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21515 :
21516 : void
21517 0 : SgAutoType::checkDataMemberPointersIfInMemoryPool()
21518 : {
21519 : // ------------ checking pointers of SgAutoType -------------------
21520 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
21521 :
21522 0 : if ( p_ref_to != NULL )
21523 : {
21524 0 : if ( p_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21525 : {
21526 0 : if ( p_ref_to->isInMemoryPool() == false )
21527 : {
21528 0 : std::cout << "SgAutoType :: ";
21529 0 : std::cout << " p_ref_to is not in memory pool of ";
21530 0 : std::cout << p_ref_to->class_name() << std::endl;
21531 : }
21532 : }
21533 : else
21534 : {
21535 0 : std::cout << "SgAutoType :: " << std::flush;
21536 0 : std::cout << "SgReferenceType* p_ref_to = " << p_ref_to << " --> " << std::flush;
21537 0 : std::cout << " not valid " << std::endl;
21538 : }
21539 : }
21540 :
21541 0 : if ( p_ptr_to != NULL )
21542 : {
21543 0 : if ( p_ptr_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21544 : {
21545 0 : if ( p_ptr_to->isInMemoryPool() == false )
21546 : {
21547 0 : std::cout << "SgAutoType :: ";
21548 0 : std::cout << " p_ptr_to is not in memory pool of ";
21549 0 : std::cout << p_ptr_to->class_name() << std::endl;
21550 : }
21551 : }
21552 : else
21553 : {
21554 0 : std::cout << "SgAutoType :: " << std::flush;
21555 0 : std::cout << "SgPointerType* p_ptr_to = " << p_ptr_to << " --> " << std::flush;
21556 0 : std::cout << " not valid " << std::endl;
21557 : }
21558 : }
21559 :
21560 0 : if ( p_modifiers != NULL )
21561 : {
21562 0 : if ( p_modifiers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21563 : {
21564 0 : if ( p_modifiers->isInMemoryPool() == false )
21565 : {
21566 0 : std::cout << "SgAutoType :: ";
21567 0 : std::cout << " p_modifiers is not in memory pool of ";
21568 0 : std::cout << p_modifiers->class_name() << std::endl;
21569 : }
21570 : }
21571 : else
21572 : {
21573 0 : std::cout << "SgAutoType :: " << std::flush;
21574 0 : std::cout << "SgModifierNodes* p_modifiers = " << p_modifiers << " --> " << std::flush;
21575 0 : std::cout << " not valid " << std::endl;
21576 : }
21577 : }
21578 :
21579 0 : if ( p_typedefs != NULL )
21580 : {
21581 0 : if ( p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21582 : {
21583 0 : if ( p_typedefs->isInMemoryPool() == false )
21584 : {
21585 0 : std::cout << "SgAutoType :: ";
21586 0 : std::cout << " p_typedefs is not in memory pool of ";
21587 0 : std::cout << p_typedefs->class_name() << std::endl;
21588 : }
21589 : }
21590 : else
21591 : {
21592 0 : std::cout << "SgAutoType :: " << std::flush;
21593 0 : std::cout << "SgTypedefSeq* p_typedefs = " << p_typedefs << " --> " << std::flush;
21594 0 : std::cout << " not valid " << std::endl;
21595 : }
21596 : }
21597 :
21598 0 : if ( p_rvalue_ref_to != NULL )
21599 : {
21600 0 : if ( p_rvalue_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21601 : {
21602 0 : if ( p_rvalue_ref_to->isInMemoryPool() == false )
21603 : {
21604 0 : std::cout << "SgAutoType :: ";
21605 0 : std::cout << " p_rvalue_ref_to is not in memory pool of ";
21606 0 : std::cout << p_rvalue_ref_to->class_name() << std::endl;
21607 : }
21608 : }
21609 : else
21610 : {
21611 0 : std::cout << "SgAutoType :: " << std::flush;
21612 0 : std::cout << "SgRvalueReferenceType* p_rvalue_ref_to = " << p_rvalue_ref_to << " --> " << std::flush;
21613 0 : std::cout << " not valid " << std::endl;
21614 : }
21615 : }
21616 :
21617 0 : if ( p_decltype_ref_to != NULL )
21618 : {
21619 0 : if ( p_decltype_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21620 : {
21621 0 : if ( p_decltype_ref_to->isInMemoryPool() == false )
21622 : {
21623 0 : std::cout << "SgAutoType :: ";
21624 0 : std::cout << " p_decltype_ref_to is not in memory pool of ";
21625 0 : std::cout << p_decltype_ref_to->class_name() << std::endl;
21626 : }
21627 : }
21628 : else
21629 : {
21630 0 : std::cout << "SgAutoType :: " << std::flush;
21631 0 : std::cout << "SgDeclType* p_decltype_ref_to = " << p_decltype_ref_to << " --> " << std::flush;
21632 0 : std::cout << " not valid " << std::endl;
21633 : }
21634 : }
21635 :
21636 0 : if ( p_typeof_ref_to != NULL )
21637 : {
21638 0 : if ( p_typeof_ref_to->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21639 : {
21640 0 : if ( p_typeof_ref_to->isInMemoryPool() == false )
21641 : {
21642 0 : std::cout << "SgAutoType :: ";
21643 0 : std::cout << " p_typeof_ref_to is not in memory pool of ";
21644 0 : std::cout << p_typeof_ref_to->class_name() << std::endl;
21645 : }
21646 : }
21647 : else
21648 : {
21649 0 : std::cout << "SgAutoType :: " << std::flush;
21650 0 : std::cout << "SgTypeOfType* p_typeof_ref_to = " << p_typeof_ref_to << " --> " << std::flush;
21651 0 : std::cout << " not valid " << std::endl;
21652 : }
21653 : }
21654 :
21655 0 : if ( p_type_kind != NULL )
21656 : {
21657 0 : if ( p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21658 : {
21659 0 : if ( p_type_kind->isInMemoryPool() == false )
21660 : {
21661 0 : std::cout << "SgAutoType :: ";
21662 0 : std::cout << " p_type_kind is not in memory pool of ";
21663 0 : std::cout << p_type_kind->class_name() << std::endl;
21664 : }
21665 : }
21666 : else
21667 : {
21668 0 : std::cout << "SgAutoType :: " << std::flush;
21669 0 : std::cout << "SgExpression* p_type_kind = " << p_type_kind << " --> " << std::flush;
21670 0 : std::cout << " not valid " << std::endl;
21671 : }
21672 : }
21673 :
21674 0 : if ( p_parent != NULL )
21675 : {
21676 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21677 : {
21678 0 : if ( p_parent->isInMemoryPool() == false )
21679 : {
21680 0 : std::cout << "SgAutoType :: ";
21681 0 : std::cout << " p_parent is not in memory pool of ";
21682 0 : std::cout << p_parent->class_name() << std::endl;
21683 : }
21684 : }
21685 : else
21686 : {
21687 0 : std::cout << "SgAutoType :: " << std::flush;
21688 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
21689 0 : std::cout << " not valid " << std::endl;
21690 : }
21691 : }
21692 :
21693 :
21694 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21695 :
21696 0 : }
21697 :
21698 :
21699 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
21700 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
21701 : bool
21702 0 : SgAutoType::isInMemoryPool ()
21703 : {
21704 0 : typedef unsigned char* TestType;
21705 :
21706 0 : bool found = false;
21707 :
21708 0 : ROSE_ASSERT(this != NULL);
21709 :
21710 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
21711 :
21712 0 : TestType tested = (TestType) ( this ) ;
21713 :
21714 0 : std::vector < unsigned char* > :: const_iterator block = SgAutoType::pools.begin();
21715 :
21716 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
21717 : // while (found == false && block < Memory_Block_List.end())
21718 0 : while ( (found == false) && (block != SgAutoType::pools.end()) )
21719 : {
21720 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAutoType::pool_size * sizeof(SgAutoType) ) ) ;
21721 0 : ++block;
21722 : }
21723 :
21724 : // Special handling for static data
21725 :
21726 :
21727 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
21728 0 : ROSE_ASSERT(found == true);
21729 :
21730 0 : return found;
21731 : }
21732 : /* #line 21733 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
21733 :
21734 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
21735 :
21736 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21737 :
21738 : /* #line 21739 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
21739 :
21740 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21741 :
21742 : void
21743 0 : SgLocatedNode::checkDataMemberPointersIfInMemoryPool()
21744 : {
21745 : // ------------ checking pointers of SgLocatedNode -------------------
21746 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
21747 :
21748 0 : if ( p_startOfConstruct != NULL )
21749 : {
21750 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21751 : {
21752 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
21753 : {
21754 0 : std::cout << "SgLocatedNode :: ";
21755 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
21756 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
21757 : }
21758 : }
21759 : else
21760 : {
21761 0 : std::cout << "SgLocatedNode :: " << std::flush;
21762 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
21763 0 : std::cout << " not valid " << std::endl;
21764 : }
21765 : }
21766 :
21767 0 : if ( p_endOfConstruct != NULL )
21768 : {
21769 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21770 : {
21771 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
21772 : {
21773 0 : std::cout << "SgLocatedNode :: ";
21774 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
21775 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
21776 : }
21777 : }
21778 : else
21779 : {
21780 0 : std::cout << "SgLocatedNode :: " << std::flush;
21781 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
21782 0 : std::cout << " not valid " << std::endl;
21783 : }
21784 : }
21785 :
21786 0 : if ( p_parent != NULL )
21787 : {
21788 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21789 : {
21790 0 : if ( p_parent->isInMemoryPool() == false )
21791 : {
21792 0 : std::cout << "SgLocatedNode :: ";
21793 0 : std::cout << " p_parent is not in memory pool of ";
21794 0 : std::cout << p_parent->class_name() << std::endl;
21795 : }
21796 : }
21797 : else
21798 : {
21799 0 : std::cout << "SgLocatedNode :: " << std::flush;
21800 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
21801 0 : std::cout << " not valid " << std::endl;
21802 : }
21803 : }
21804 :
21805 :
21806 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21807 :
21808 0 : }
21809 :
21810 :
21811 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
21812 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
21813 : bool
21814 0 : SgLocatedNode::isInMemoryPool ()
21815 : {
21816 0 : typedef unsigned char* TestType;
21817 :
21818 0 : bool found = false;
21819 :
21820 0 : ROSE_ASSERT(this != NULL);
21821 :
21822 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
21823 :
21824 0 : TestType tested = (TestType) ( this ) ;
21825 :
21826 0 : std::vector < unsigned char* > :: const_iterator block = SgLocatedNode::pools.begin();
21827 :
21828 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
21829 : // while (found == false && block < Memory_Block_List.end())
21830 0 : while ( (found == false) && (block != SgLocatedNode::pools.end()) )
21831 : {
21832 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLocatedNode::pool_size * sizeof(SgLocatedNode) ) ) ;
21833 0 : ++block;
21834 : }
21835 :
21836 : // Special handling for static data
21837 :
21838 :
21839 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
21840 0 : ROSE_ASSERT(found == true);
21841 :
21842 0 : return found;
21843 : }
21844 : /* #line 21845 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
21845 :
21846 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
21847 :
21848 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21849 :
21850 : /* #line 21851 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
21851 :
21852 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21853 :
21854 : void
21855 0 : SgToken::checkDataMemberPointersIfInMemoryPool()
21856 : {
21857 : // ------------ checking pointers of SgToken -------------------
21858 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
21859 :
21860 0 : if ( p_startOfConstruct != NULL )
21861 : {
21862 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21863 : {
21864 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
21865 : {
21866 0 : std::cout << "SgToken :: ";
21867 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
21868 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
21869 : }
21870 : }
21871 : else
21872 : {
21873 0 : std::cout << "SgToken :: " << std::flush;
21874 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
21875 0 : std::cout << " not valid " << std::endl;
21876 : }
21877 : }
21878 :
21879 0 : if ( p_endOfConstruct != NULL )
21880 : {
21881 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21882 : {
21883 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
21884 : {
21885 0 : std::cout << "SgToken :: ";
21886 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
21887 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
21888 : }
21889 : }
21890 : else
21891 : {
21892 0 : std::cout << "SgToken :: " << std::flush;
21893 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
21894 0 : std::cout << " not valid " << std::endl;
21895 : }
21896 : }
21897 :
21898 0 : if ( p_parent != NULL )
21899 : {
21900 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21901 : {
21902 0 : if ( p_parent->isInMemoryPool() == false )
21903 : {
21904 0 : std::cout << "SgToken :: ";
21905 0 : std::cout << " p_parent is not in memory pool of ";
21906 0 : std::cout << p_parent->class_name() << std::endl;
21907 : }
21908 : }
21909 : else
21910 : {
21911 0 : std::cout << "SgToken :: " << std::flush;
21912 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
21913 0 : std::cout << " not valid " << std::endl;
21914 : }
21915 : }
21916 :
21917 :
21918 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21919 :
21920 0 : }
21921 :
21922 :
21923 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
21924 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
21925 : bool
21926 0 : SgToken::isInMemoryPool ()
21927 : {
21928 0 : typedef unsigned char* TestType;
21929 :
21930 0 : bool found = false;
21931 :
21932 0 : ROSE_ASSERT(this != NULL);
21933 :
21934 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
21935 :
21936 0 : TestType tested = (TestType) ( this ) ;
21937 :
21938 0 : std::vector < unsigned char* > :: const_iterator block = SgToken::pools.begin();
21939 :
21940 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
21941 : // while (found == false && block < Memory_Block_List.end())
21942 0 : while ( (found == false) && (block != SgToken::pools.end()) )
21943 : {
21944 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgToken::pool_size * sizeof(SgToken) ) ) ;
21945 0 : ++block;
21946 : }
21947 :
21948 : // Special handling for static data
21949 :
21950 :
21951 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
21952 0 : ROSE_ASSERT(found == true);
21953 :
21954 0 : return found;
21955 : }
21956 : /* #line 21957 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
21957 :
21958 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
21959 :
21960 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21961 :
21962 : /* #line 21963 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
21963 :
21964 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
21965 :
21966 : void
21967 0 : SgLocatedNodeSupport::checkDataMemberPointersIfInMemoryPool()
21968 : {
21969 : // ------------ checking pointers of SgLocatedNodeSupport -------------------
21970 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
21971 :
21972 0 : if ( p_startOfConstruct != NULL )
21973 : {
21974 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21975 : {
21976 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
21977 : {
21978 0 : std::cout << "SgLocatedNodeSupport :: ";
21979 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
21980 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
21981 : }
21982 : }
21983 : else
21984 : {
21985 0 : std::cout << "SgLocatedNodeSupport :: " << std::flush;
21986 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
21987 0 : std::cout << " not valid " << std::endl;
21988 : }
21989 : }
21990 :
21991 0 : if ( p_endOfConstruct != NULL )
21992 : {
21993 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
21994 : {
21995 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
21996 : {
21997 0 : std::cout << "SgLocatedNodeSupport :: ";
21998 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
21999 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
22000 : }
22001 : }
22002 : else
22003 : {
22004 0 : std::cout << "SgLocatedNodeSupport :: " << std::flush;
22005 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
22006 0 : std::cout << " not valid " << std::endl;
22007 : }
22008 : }
22009 :
22010 0 : if ( p_parent != NULL )
22011 : {
22012 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22013 : {
22014 0 : if ( p_parent->isInMemoryPool() == false )
22015 : {
22016 0 : std::cout << "SgLocatedNodeSupport :: ";
22017 0 : std::cout << " p_parent is not in memory pool of ";
22018 0 : std::cout << p_parent->class_name() << std::endl;
22019 : }
22020 : }
22021 : else
22022 : {
22023 0 : std::cout << "SgLocatedNodeSupport :: " << std::flush;
22024 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
22025 0 : std::cout << " not valid " << std::endl;
22026 : }
22027 : }
22028 :
22029 :
22030 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22031 :
22032 0 : }
22033 :
22034 :
22035 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
22036 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
22037 : bool
22038 0 : SgLocatedNodeSupport::isInMemoryPool ()
22039 : {
22040 0 : typedef unsigned char* TestType;
22041 :
22042 0 : bool found = false;
22043 :
22044 0 : ROSE_ASSERT(this != NULL);
22045 :
22046 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
22047 :
22048 0 : TestType tested = (TestType) ( this ) ;
22049 :
22050 0 : std::vector < unsigned char* > :: const_iterator block = SgLocatedNodeSupport::pools.begin();
22051 :
22052 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
22053 : // while (found == false && block < Memory_Block_List.end())
22054 0 : while ( (found == false) && (block != SgLocatedNodeSupport::pools.end()) )
22055 : {
22056 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLocatedNodeSupport::pool_size * sizeof(SgLocatedNodeSupport) ) ) ;
22057 0 : ++block;
22058 : }
22059 :
22060 : // Special handling for static data
22061 :
22062 :
22063 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
22064 0 : ROSE_ASSERT(found == true);
22065 :
22066 0 : return found;
22067 : }
22068 : /* #line 22069 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
22069 :
22070 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
22071 :
22072 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22073 :
22074 : /* #line 22075 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
22075 :
22076 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22077 :
22078 : void
22079 0 : SgCommonBlockObject::checkDataMemberPointersIfInMemoryPool()
22080 : {
22081 : // ------------ checking pointers of SgCommonBlockObject -------------------
22082 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
22083 :
22084 0 : if ( p_variable_reference_list != NULL )
22085 : {
22086 0 : if ( p_variable_reference_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22087 : {
22088 0 : if ( p_variable_reference_list->isInMemoryPool() == false )
22089 : {
22090 0 : std::cout << "SgCommonBlockObject :: ";
22091 0 : std::cout << " p_variable_reference_list is not in memory pool of ";
22092 0 : std::cout << p_variable_reference_list->class_name() << std::endl;
22093 : }
22094 : }
22095 : else
22096 : {
22097 0 : std::cout << "SgCommonBlockObject :: " << std::flush;
22098 0 : std::cout << "SgExprListExp* p_variable_reference_list = " << p_variable_reference_list << " --> " << std::flush;
22099 0 : std::cout << " not valid " << std::endl;
22100 : }
22101 : }
22102 :
22103 0 : if ( p_startOfConstruct != NULL )
22104 : {
22105 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22106 : {
22107 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
22108 : {
22109 0 : std::cout << "SgCommonBlockObject :: ";
22110 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
22111 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
22112 : }
22113 : }
22114 : else
22115 : {
22116 0 : std::cout << "SgCommonBlockObject :: " << std::flush;
22117 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
22118 0 : std::cout << " not valid " << std::endl;
22119 : }
22120 : }
22121 :
22122 0 : if ( p_endOfConstruct != NULL )
22123 : {
22124 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22125 : {
22126 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
22127 : {
22128 0 : std::cout << "SgCommonBlockObject :: ";
22129 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
22130 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
22131 : }
22132 : }
22133 : else
22134 : {
22135 0 : std::cout << "SgCommonBlockObject :: " << std::flush;
22136 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
22137 0 : std::cout << " not valid " << std::endl;
22138 : }
22139 : }
22140 :
22141 0 : if ( p_parent != NULL )
22142 : {
22143 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22144 : {
22145 0 : if ( p_parent->isInMemoryPool() == false )
22146 : {
22147 0 : std::cout << "SgCommonBlockObject :: ";
22148 0 : std::cout << " p_parent is not in memory pool of ";
22149 0 : std::cout << p_parent->class_name() << std::endl;
22150 : }
22151 : }
22152 : else
22153 : {
22154 0 : std::cout << "SgCommonBlockObject :: " << std::flush;
22155 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
22156 0 : std::cout << " not valid " << std::endl;
22157 : }
22158 : }
22159 :
22160 :
22161 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22162 :
22163 0 : }
22164 :
22165 :
22166 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
22167 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
22168 : bool
22169 0 : SgCommonBlockObject::isInMemoryPool ()
22170 : {
22171 0 : typedef unsigned char* TestType;
22172 :
22173 0 : bool found = false;
22174 :
22175 0 : ROSE_ASSERT(this != NULL);
22176 :
22177 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
22178 :
22179 0 : TestType tested = (TestType) ( this ) ;
22180 :
22181 0 : std::vector < unsigned char* > :: const_iterator block = SgCommonBlockObject::pools.begin();
22182 :
22183 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
22184 : // while (found == false && block < Memory_Block_List.end())
22185 0 : while ( (found == false) && (block != SgCommonBlockObject::pools.end()) )
22186 : {
22187 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCommonBlockObject::pool_size * sizeof(SgCommonBlockObject) ) ) ;
22188 0 : ++block;
22189 : }
22190 :
22191 : // Special handling for static data
22192 :
22193 :
22194 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
22195 0 : ROSE_ASSERT(found == true);
22196 :
22197 0 : return found;
22198 : }
22199 : /* #line 22200 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
22200 :
22201 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
22202 :
22203 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22204 :
22205 : /* #line 22206 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
22206 :
22207 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22208 :
22209 : void
22210 0 : SgInitializedName::checkDataMemberPointersIfInMemoryPool()
22211 : {
22212 : // ------------ checking pointers of SgInitializedName -------------------
22213 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
22214 :
22215 0 : if ( p_typeptr != NULL )
22216 : {
22217 0 : if ( p_typeptr->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22218 : {
22219 0 : if ( p_typeptr->isInMemoryPool() == false )
22220 : {
22221 0 : std::cout << "SgInitializedName :: ";
22222 0 : std::cout << " p_typeptr is not in memory pool of ";
22223 0 : std::cout << p_typeptr->class_name() << std::endl;
22224 : }
22225 : }
22226 : else
22227 : {
22228 0 : std::cout << "SgInitializedName :: " << std::flush;
22229 0 : std::cout << "SgType* p_typeptr = " << p_typeptr << " --> " << std::flush;
22230 0 : std::cout << " not valid " << std::endl;
22231 : }
22232 : }
22233 :
22234 0 : if ( p_initptr != NULL )
22235 : {
22236 0 : if ( p_initptr->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22237 : {
22238 0 : if ( p_initptr->isInMemoryPool() == false )
22239 : {
22240 0 : std::cout << "SgInitializedName :: ";
22241 0 : std::cout << " p_initptr is not in memory pool of ";
22242 0 : std::cout << p_initptr->class_name() << std::endl;
22243 : }
22244 : }
22245 : else
22246 : {
22247 0 : std::cout << "SgInitializedName :: " << std::flush;
22248 0 : std::cout << "SgInitializer* p_initptr = " << p_initptr << " --> " << std::flush;
22249 0 : std::cout << " not valid " << std::endl;
22250 : }
22251 : }
22252 :
22253 0 : if ( p_prev_decl_item != NULL )
22254 : {
22255 0 : if ( p_prev_decl_item->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22256 : {
22257 0 : if ( p_prev_decl_item->isInMemoryPool() == false )
22258 : {
22259 0 : std::cout << "SgInitializedName :: ";
22260 0 : std::cout << " p_prev_decl_item is not in memory pool of ";
22261 0 : std::cout << p_prev_decl_item->class_name() << std::endl;
22262 : }
22263 : }
22264 : else
22265 : {
22266 0 : std::cout << "SgInitializedName :: " << std::flush;
22267 0 : std::cout << "SgInitializedName* p_prev_decl_item = " << p_prev_decl_item << " --> " << std::flush;
22268 0 : std::cout << " not valid " << std::endl;
22269 : }
22270 : }
22271 :
22272 0 : if ( p_declptr != NULL )
22273 : {
22274 0 : if ( p_declptr->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22275 : {
22276 0 : if ( p_declptr->isInMemoryPool() == false )
22277 : {
22278 0 : std::cout << "SgInitializedName :: ";
22279 0 : std::cout << " p_declptr is not in memory pool of ";
22280 0 : std::cout << p_declptr->class_name() << std::endl;
22281 : }
22282 : }
22283 : else
22284 : {
22285 0 : std::cout << "SgInitializedName :: " << std::flush;
22286 0 : std::cout << "SgDeclarationStatement* p_declptr = " << p_declptr << " --> " << std::flush;
22287 0 : std::cout << " not valid " << std::endl;
22288 : }
22289 : }
22290 :
22291 0 : if ( p_storageModifier != NULL )
22292 : {
22293 0 : if ( p_storageModifier->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22294 : {
22295 0 : if ( p_storageModifier->isInMemoryPool() == false )
22296 : {
22297 0 : std::cout << "SgInitializedName :: ";
22298 0 : std::cout << " p_storageModifier is not in memory pool of ";
22299 0 : std::cout << p_storageModifier->class_name() << std::endl;
22300 : }
22301 : }
22302 : else
22303 : {
22304 0 : std::cout << "SgInitializedName :: " << std::flush;
22305 0 : std::cout << "SgStorageModifier* p_storageModifier = " << p_storageModifier << " --> " << std::flush;
22306 0 : std::cout << " not valid " << std::endl;
22307 : }
22308 : }
22309 :
22310 0 : if ( p_scope != NULL )
22311 : {
22312 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22313 : {
22314 0 : if ( p_scope->isInMemoryPool() == false )
22315 : {
22316 0 : std::cout << "SgInitializedName :: ";
22317 0 : std::cout << " p_scope is not in memory pool of ";
22318 0 : std::cout << p_scope->class_name() << std::endl;
22319 : }
22320 : }
22321 : else
22322 : {
22323 0 : std::cout << "SgInitializedName :: " << std::flush;
22324 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
22325 0 : std::cout << " not valid " << std::endl;
22326 : }
22327 : }
22328 :
22329 0 : if ( p_constant_or_type_argument_for_Alignas_keyword != NULL )
22330 : {
22331 0 : if ( p_constant_or_type_argument_for_Alignas_keyword->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22332 : {
22333 0 : if ( p_constant_or_type_argument_for_Alignas_keyword->isInMemoryPool() == false )
22334 : {
22335 0 : std::cout << "SgInitializedName :: ";
22336 0 : std::cout << " p_constant_or_type_argument_for_Alignas_keyword is not in memory pool of ";
22337 0 : std::cout << p_constant_or_type_argument_for_Alignas_keyword->class_name() << std::endl;
22338 : }
22339 : }
22340 : else
22341 : {
22342 0 : std::cout << "SgInitializedName :: " << std::flush;
22343 0 : std::cout << "SgNode* p_constant_or_type_argument_for_Alignas_keyword = " << p_constant_or_type_argument_for_Alignas_keyword << " --> " << std::flush;
22344 0 : std::cout << " not valid " << std::endl;
22345 : }
22346 : }
22347 :
22348 0 : if ( p_auto_decltype != NULL )
22349 : {
22350 0 : if ( p_auto_decltype->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22351 : {
22352 0 : if ( p_auto_decltype->isInMemoryPool() == false )
22353 : {
22354 0 : std::cout << "SgInitializedName :: ";
22355 0 : std::cout << " p_auto_decltype is not in memory pool of ";
22356 0 : std::cout << p_auto_decltype->class_name() << std::endl;
22357 : }
22358 : }
22359 : else
22360 : {
22361 0 : std::cout << "SgInitializedName :: " << std::flush;
22362 0 : std::cout << "SgType * p_auto_decltype = " << p_auto_decltype << " --> " << std::flush;
22363 0 : std::cout << " not valid " << std::endl;
22364 : }
22365 : }
22366 :
22367 0 : if ( p_startOfConstruct != NULL )
22368 : {
22369 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22370 : {
22371 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
22372 : {
22373 0 : std::cout << "SgInitializedName :: ";
22374 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
22375 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
22376 : }
22377 : }
22378 : else
22379 : {
22380 0 : std::cout << "SgInitializedName :: " << std::flush;
22381 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
22382 0 : std::cout << " not valid " << std::endl;
22383 : }
22384 : }
22385 :
22386 0 : if ( p_endOfConstruct != NULL )
22387 : {
22388 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22389 : {
22390 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
22391 : {
22392 0 : std::cout << "SgInitializedName :: ";
22393 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
22394 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
22395 : }
22396 : }
22397 : else
22398 : {
22399 0 : std::cout << "SgInitializedName :: " << std::flush;
22400 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
22401 0 : std::cout << " not valid " << std::endl;
22402 : }
22403 : }
22404 :
22405 0 : if ( p_parent != NULL )
22406 : {
22407 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22408 : {
22409 0 : if ( p_parent->isInMemoryPool() == false )
22410 : {
22411 0 : std::cout << "SgInitializedName :: ";
22412 0 : std::cout << " p_parent is not in memory pool of ";
22413 0 : std::cout << p_parent->class_name() << std::endl;
22414 : }
22415 : }
22416 : else
22417 : {
22418 0 : std::cout << "SgInitializedName :: " << std::flush;
22419 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
22420 0 : std::cout << " not valid " << std::endl;
22421 : }
22422 : }
22423 :
22424 :
22425 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22426 :
22427 0 : }
22428 :
22429 :
22430 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
22431 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
22432 : bool
22433 0 : SgInitializedName::isInMemoryPool ()
22434 : {
22435 0 : typedef unsigned char* TestType;
22436 :
22437 0 : bool found = false;
22438 :
22439 0 : ROSE_ASSERT(this != NULL);
22440 :
22441 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
22442 :
22443 0 : TestType tested = (TestType) ( this ) ;
22444 :
22445 0 : std::vector < unsigned char* > :: const_iterator block = SgInitializedName::pools.begin();
22446 :
22447 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
22448 : // while (found == false && block < Memory_Block_List.end())
22449 0 : while ( (found == false) && (block != SgInitializedName::pools.end()) )
22450 : {
22451 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgInitializedName::pool_size * sizeof(SgInitializedName) ) ) ;
22452 0 : ++block;
22453 : }
22454 :
22455 : // Special handling for static data
22456 :
22457 :
22458 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
22459 0 : ROSE_ASSERT(found == true);
22460 :
22461 0 : return found;
22462 : }
22463 : /* #line 22464 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
22464 :
22465 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
22466 :
22467 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22468 :
22469 : /* #line 22470 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
22470 :
22471 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22472 :
22473 : void
22474 0 : SgInterfaceBody::checkDataMemberPointersIfInMemoryPool()
22475 : {
22476 : // ------------ checking pointers of SgInterfaceBody -------------------
22477 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
22478 :
22479 0 : if ( p_functionDeclaration != NULL )
22480 : {
22481 0 : if ( p_functionDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22482 : {
22483 0 : if ( p_functionDeclaration->isInMemoryPool() == false )
22484 : {
22485 0 : std::cout << "SgInterfaceBody :: ";
22486 0 : std::cout << " p_functionDeclaration is not in memory pool of ";
22487 0 : std::cout << p_functionDeclaration->class_name() << std::endl;
22488 : }
22489 : }
22490 : else
22491 : {
22492 0 : std::cout << "SgInterfaceBody :: " << std::flush;
22493 0 : std::cout << "SgFunctionDeclaration* p_functionDeclaration = " << p_functionDeclaration << " --> " << std::flush;
22494 0 : std::cout << " not valid " << std::endl;
22495 : }
22496 : }
22497 :
22498 0 : if ( p_startOfConstruct != NULL )
22499 : {
22500 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22501 : {
22502 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
22503 : {
22504 0 : std::cout << "SgInterfaceBody :: ";
22505 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
22506 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
22507 : }
22508 : }
22509 : else
22510 : {
22511 0 : std::cout << "SgInterfaceBody :: " << std::flush;
22512 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
22513 0 : std::cout << " not valid " << std::endl;
22514 : }
22515 : }
22516 :
22517 0 : if ( p_endOfConstruct != NULL )
22518 : {
22519 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22520 : {
22521 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
22522 : {
22523 0 : std::cout << "SgInterfaceBody :: ";
22524 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
22525 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
22526 : }
22527 : }
22528 : else
22529 : {
22530 0 : std::cout << "SgInterfaceBody :: " << std::flush;
22531 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
22532 0 : std::cout << " not valid " << std::endl;
22533 : }
22534 : }
22535 :
22536 0 : if ( p_parent != NULL )
22537 : {
22538 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22539 : {
22540 0 : if ( p_parent->isInMemoryPool() == false )
22541 : {
22542 0 : std::cout << "SgInterfaceBody :: ";
22543 0 : std::cout << " p_parent is not in memory pool of ";
22544 0 : std::cout << p_parent->class_name() << std::endl;
22545 : }
22546 : }
22547 : else
22548 : {
22549 0 : std::cout << "SgInterfaceBody :: " << std::flush;
22550 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
22551 0 : std::cout << " not valid " << std::endl;
22552 : }
22553 : }
22554 :
22555 :
22556 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22557 :
22558 0 : }
22559 :
22560 :
22561 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
22562 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
22563 : bool
22564 0 : SgInterfaceBody::isInMemoryPool ()
22565 : {
22566 0 : typedef unsigned char* TestType;
22567 :
22568 0 : bool found = false;
22569 :
22570 0 : ROSE_ASSERT(this != NULL);
22571 :
22572 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
22573 :
22574 0 : TestType tested = (TestType) ( this ) ;
22575 :
22576 0 : std::vector < unsigned char* > :: const_iterator block = SgInterfaceBody::pools.begin();
22577 :
22578 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
22579 : // while (found == false && block < Memory_Block_List.end())
22580 0 : while ( (found == false) && (block != SgInterfaceBody::pools.end()) )
22581 : {
22582 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgInterfaceBody::pool_size * sizeof(SgInterfaceBody) ) ) ;
22583 0 : ++block;
22584 : }
22585 :
22586 : // Special handling for static data
22587 :
22588 :
22589 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
22590 0 : ROSE_ASSERT(found == true);
22591 :
22592 0 : return found;
22593 : }
22594 : /* #line 22595 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
22595 :
22596 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
22597 :
22598 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22599 :
22600 : /* #line 22601 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
22601 :
22602 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22603 :
22604 : void
22605 0 : SgHeaderFileBody::checkDataMemberPointersIfInMemoryPool()
22606 : {
22607 : // ------------ checking pointers of SgHeaderFileBody -------------------
22608 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
22609 :
22610 0 : if ( p_include_file != NULL )
22611 : {
22612 0 : if ( p_include_file->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22613 : {
22614 0 : if ( p_include_file->isInMemoryPool() == false )
22615 : {
22616 0 : std::cout << "SgHeaderFileBody :: ";
22617 0 : std::cout << " p_include_file is not in memory pool of ";
22618 0 : std::cout << p_include_file->class_name() << std::endl;
22619 : }
22620 : }
22621 : else
22622 : {
22623 0 : std::cout << "SgHeaderFileBody :: " << std::flush;
22624 0 : std::cout << "SgSourceFile* p_include_file = " << p_include_file << " --> " << std::flush;
22625 0 : std::cout << " not valid " << std::endl;
22626 : }
22627 : }
22628 :
22629 0 : if ( p_startOfConstruct != NULL )
22630 : {
22631 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22632 : {
22633 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
22634 : {
22635 0 : std::cout << "SgHeaderFileBody :: ";
22636 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
22637 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
22638 : }
22639 : }
22640 : else
22641 : {
22642 0 : std::cout << "SgHeaderFileBody :: " << std::flush;
22643 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
22644 0 : std::cout << " not valid " << std::endl;
22645 : }
22646 : }
22647 :
22648 0 : if ( p_endOfConstruct != NULL )
22649 : {
22650 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22651 : {
22652 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
22653 : {
22654 0 : std::cout << "SgHeaderFileBody :: ";
22655 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
22656 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
22657 : }
22658 : }
22659 : else
22660 : {
22661 0 : std::cout << "SgHeaderFileBody :: " << std::flush;
22662 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
22663 0 : std::cout << " not valid " << std::endl;
22664 : }
22665 : }
22666 :
22667 0 : if ( p_parent != NULL )
22668 : {
22669 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22670 : {
22671 0 : if ( p_parent->isInMemoryPool() == false )
22672 : {
22673 0 : std::cout << "SgHeaderFileBody :: ";
22674 0 : std::cout << " p_parent is not in memory pool of ";
22675 0 : std::cout << p_parent->class_name() << std::endl;
22676 : }
22677 : }
22678 : else
22679 : {
22680 0 : std::cout << "SgHeaderFileBody :: " << std::flush;
22681 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
22682 0 : std::cout << " not valid " << std::endl;
22683 : }
22684 : }
22685 :
22686 :
22687 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22688 :
22689 0 : }
22690 :
22691 :
22692 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
22693 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
22694 : bool
22695 0 : SgHeaderFileBody::isInMemoryPool ()
22696 : {
22697 0 : typedef unsigned char* TestType;
22698 :
22699 0 : bool found = false;
22700 :
22701 0 : ROSE_ASSERT(this != NULL);
22702 :
22703 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
22704 :
22705 0 : TestType tested = (TestType) ( this ) ;
22706 :
22707 0 : std::vector < unsigned char* > :: const_iterator block = SgHeaderFileBody::pools.begin();
22708 :
22709 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
22710 : // while (found == false && block < Memory_Block_List.end())
22711 0 : while ( (found == false) && (block != SgHeaderFileBody::pools.end()) )
22712 : {
22713 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgHeaderFileBody::pool_size * sizeof(SgHeaderFileBody) ) ) ;
22714 0 : ++block;
22715 : }
22716 :
22717 : // Special handling for static data
22718 :
22719 :
22720 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
22721 0 : ROSE_ASSERT(found == true);
22722 :
22723 0 : return found;
22724 : }
22725 : /* #line 22726 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
22726 :
22727 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
22728 :
22729 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22730 :
22731 : /* #line 22732 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
22732 :
22733 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22734 :
22735 : void
22736 0 : SgRenamePair::checkDataMemberPointersIfInMemoryPool()
22737 : {
22738 : // ------------ checking pointers of SgRenamePair -------------------
22739 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
22740 :
22741 0 : if ( p_startOfConstruct != NULL )
22742 : {
22743 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22744 : {
22745 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
22746 : {
22747 0 : std::cout << "SgRenamePair :: ";
22748 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
22749 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
22750 : }
22751 : }
22752 : else
22753 : {
22754 0 : std::cout << "SgRenamePair :: " << std::flush;
22755 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
22756 0 : std::cout << " not valid " << std::endl;
22757 : }
22758 : }
22759 :
22760 0 : if ( p_endOfConstruct != NULL )
22761 : {
22762 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22763 : {
22764 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
22765 : {
22766 0 : std::cout << "SgRenamePair :: ";
22767 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
22768 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
22769 : }
22770 : }
22771 : else
22772 : {
22773 0 : std::cout << "SgRenamePair :: " << std::flush;
22774 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
22775 0 : std::cout << " not valid " << std::endl;
22776 : }
22777 : }
22778 :
22779 0 : if ( p_parent != NULL )
22780 : {
22781 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22782 : {
22783 0 : if ( p_parent->isInMemoryPool() == false )
22784 : {
22785 0 : std::cout << "SgRenamePair :: ";
22786 0 : std::cout << " p_parent is not in memory pool of ";
22787 0 : std::cout << p_parent->class_name() << std::endl;
22788 : }
22789 : }
22790 : else
22791 : {
22792 0 : std::cout << "SgRenamePair :: " << std::flush;
22793 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
22794 0 : std::cout << " not valid " << std::endl;
22795 : }
22796 : }
22797 :
22798 :
22799 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22800 :
22801 0 : }
22802 :
22803 :
22804 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
22805 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
22806 : bool
22807 0 : SgRenamePair::isInMemoryPool ()
22808 : {
22809 0 : typedef unsigned char* TestType;
22810 :
22811 0 : bool found = false;
22812 :
22813 0 : ROSE_ASSERT(this != NULL);
22814 :
22815 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
22816 :
22817 0 : TestType tested = (TestType) ( this ) ;
22818 :
22819 0 : std::vector < unsigned char* > :: const_iterator block = SgRenamePair::pools.begin();
22820 :
22821 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
22822 : // while (found == false && block < Memory_Block_List.end())
22823 0 : while ( (found == false) && (block != SgRenamePair::pools.end()) )
22824 : {
22825 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgRenamePair::pool_size * sizeof(SgRenamePair) ) ) ;
22826 0 : ++block;
22827 : }
22828 :
22829 : // Special handling for static data
22830 :
22831 :
22832 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
22833 0 : ROSE_ASSERT(found == true);
22834 :
22835 0 : return found;
22836 : }
22837 : /* #line 22838 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
22838 :
22839 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
22840 :
22841 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22842 :
22843 : /* #line 22844 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
22844 :
22845 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22846 :
22847 : void
22848 0 : SgOmpClause::checkDataMemberPointersIfInMemoryPool()
22849 : {
22850 : // ------------ checking pointers of SgOmpClause -------------------
22851 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
22852 :
22853 0 : if ( p_startOfConstruct != NULL )
22854 : {
22855 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22856 : {
22857 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
22858 : {
22859 0 : std::cout << "SgOmpClause :: ";
22860 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
22861 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
22862 : }
22863 : }
22864 : else
22865 : {
22866 0 : std::cout << "SgOmpClause :: " << std::flush;
22867 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
22868 0 : std::cout << " not valid " << std::endl;
22869 : }
22870 : }
22871 :
22872 0 : if ( p_endOfConstruct != NULL )
22873 : {
22874 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22875 : {
22876 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
22877 : {
22878 0 : std::cout << "SgOmpClause :: ";
22879 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
22880 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
22881 : }
22882 : }
22883 : else
22884 : {
22885 0 : std::cout << "SgOmpClause :: " << std::flush;
22886 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
22887 0 : std::cout << " not valid " << std::endl;
22888 : }
22889 : }
22890 :
22891 0 : if ( p_parent != NULL )
22892 : {
22893 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22894 : {
22895 0 : if ( p_parent->isInMemoryPool() == false )
22896 : {
22897 0 : std::cout << "SgOmpClause :: ";
22898 0 : std::cout << " p_parent is not in memory pool of ";
22899 0 : std::cout << p_parent->class_name() << std::endl;
22900 : }
22901 : }
22902 : else
22903 : {
22904 0 : std::cout << "SgOmpClause :: " << std::flush;
22905 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
22906 0 : std::cout << " not valid " << std::endl;
22907 : }
22908 : }
22909 :
22910 :
22911 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22912 :
22913 0 : }
22914 :
22915 :
22916 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
22917 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
22918 : bool
22919 0 : SgOmpClause::isInMemoryPool ()
22920 : {
22921 0 : typedef unsigned char* TestType;
22922 :
22923 0 : bool found = false;
22924 :
22925 0 : ROSE_ASSERT(this != NULL);
22926 :
22927 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
22928 :
22929 0 : TestType tested = (TestType) ( this ) ;
22930 :
22931 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpClause::pools.begin();
22932 :
22933 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
22934 : // while (found == false && block < Memory_Block_List.end())
22935 0 : while ( (found == false) && (block != SgOmpClause::pools.end()) )
22936 : {
22937 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpClause::pool_size * sizeof(SgOmpClause) ) ) ;
22938 0 : ++block;
22939 : }
22940 :
22941 : // Special handling for static data
22942 :
22943 :
22944 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
22945 0 : ROSE_ASSERT(found == true);
22946 :
22947 0 : return found;
22948 : }
22949 : /* #line 22950 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
22950 :
22951 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
22952 :
22953 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22954 :
22955 : /* #line 22956 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
22956 :
22957 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
22958 :
22959 : void
22960 0 : SgOmpNowaitClause::checkDataMemberPointersIfInMemoryPool()
22961 : {
22962 : // ------------ checking pointers of SgOmpNowaitClause -------------------
22963 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
22964 :
22965 0 : if ( p_startOfConstruct != NULL )
22966 : {
22967 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22968 : {
22969 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
22970 : {
22971 0 : std::cout << "SgOmpNowaitClause :: ";
22972 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
22973 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
22974 : }
22975 : }
22976 : else
22977 : {
22978 0 : std::cout << "SgOmpNowaitClause :: " << std::flush;
22979 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
22980 0 : std::cout << " not valid " << std::endl;
22981 : }
22982 : }
22983 :
22984 0 : if ( p_endOfConstruct != NULL )
22985 : {
22986 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
22987 : {
22988 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
22989 : {
22990 0 : std::cout << "SgOmpNowaitClause :: ";
22991 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
22992 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
22993 : }
22994 : }
22995 : else
22996 : {
22997 0 : std::cout << "SgOmpNowaitClause :: " << std::flush;
22998 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
22999 0 : std::cout << " not valid " << std::endl;
23000 : }
23001 : }
23002 :
23003 0 : if ( p_parent != NULL )
23004 : {
23005 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23006 : {
23007 0 : if ( p_parent->isInMemoryPool() == false )
23008 : {
23009 0 : std::cout << "SgOmpNowaitClause :: ";
23010 0 : std::cout << " p_parent is not in memory pool of ";
23011 0 : std::cout << p_parent->class_name() << std::endl;
23012 : }
23013 : }
23014 : else
23015 : {
23016 0 : std::cout << "SgOmpNowaitClause :: " << std::flush;
23017 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
23018 0 : std::cout << " not valid " << std::endl;
23019 : }
23020 : }
23021 :
23022 :
23023 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23024 :
23025 0 : }
23026 :
23027 :
23028 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
23029 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
23030 : bool
23031 0 : SgOmpNowaitClause::isInMemoryPool ()
23032 : {
23033 0 : typedef unsigned char* TestType;
23034 :
23035 0 : bool found = false;
23036 :
23037 0 : ROSE_ASSERT(this != NULL);
23038 :
23039 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
23040 :
23041 0 : TestType tested = (TestType) ( this ) ;
23042 :
23043 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpNowaitClause::pools.begin();
23044 :
23045 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
23046 : // while (found == false && block < Memory_Block_List.end())
23047 0 : while ( (found == false) && (block != SgOmpNowaitClause::pools.end()) )
23048 : {
23049 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpNowaitClause::pool_size * sizeof(SgOmpNowaitClause) ) ) ;
23050 0 : ++block;
23051 : }
23052 :
23053 : // Special handling for static data
23054 :
23055 :
23056 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
23057 0 : ROSE_ASSERT(found == true);
23058 :
23059 0 : return found;
23060 : }
23061 : /* #line 23062 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23062 :
23063 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
23064 :
23065 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23066 :
23067 : /* #line 23068 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23068 :
23069 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23070 :
23071 : void
23072 0 : SgOmpReadClause::checkDataMemberPointersIfInMemoryPool()
23073 : {
23074 : // ------------ checking pointers of SgOmpReadClause -------------------
23075 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
23076 :
23077 0 : if ( p_startOfConstruct != NULL )
23078 : {
23079 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23080 : {
23081 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
23082 : {
23083 0 : std::cout << "SgOmpReadClause :: ";
23084 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
23085 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
23086 : }
23087 : }
23088 : else
23089 : {
23090 0 : std::cout << "SgOmpReadClause :: " << std::flush;
23091 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
23092 0 : std::cout << " not valid " << std::endl;
23093 : }
23094 : }
23095 :
23096 0 : if ( p_endOfConstruct != NULL )
23097 : {
23098 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23099 : {
23100 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
23101 : {
23102 0 : std::cout << "SgOmpReadClause :: ";
23103 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
23104 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
23105 : }
23106 : }
23107 : else
23108 : {
23109 0 : std::cout << "SgOmpReadClause :: " << std::flush;
23110 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
23111 0 : std::cout << " not valid " << std::endl;
23112 : }
23113 : }
23114 :
23115 0 : if ( p_parent != NULL )
23116 : {
23117 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23118 : {
23119 0 : if ( p_parent->isInMemoryPool() == false )
23120 : {
23121 0 : std::cout << "SgOmpReadClause :: ";
23122 0 : std::cout << " p_parent is not in memory pool of ";
23123 0 : std::cout << p_parent->class_name() << std::endl;
23124 : }
23125 : }
23126 : else
23127 : {
23128 0 : std::cout << "SgOmpReadClause :: " << std::flush;
23129 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
23130 0 : std::cout << " not valid " << std::endl;
23131 : }
23132 : }
23133 :
23134 :
23135 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23136 :
23137 0 : }
23138 :
23139 :
23140 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
23141 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
23142 : bool
23143 0 : SgOmpReadClause::isInMemoryPool ()
23144 : {
23145 0 : typedef unsigned char* TestType;
23146 :
23147 0 : bool found = false;
23148 :
23149 0 : ROSE_ASSERT(this != NULL);
23150 :
23151 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
23152 :
23153 0 : TestType tested = (TestType) ( this ) ;
23154 :
23155 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpReadClause::pools.begin();
23156 :
23157 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
23158 : // while (found == false && block < Memory_Block_List.end())
23159 0 : while ( (found == false) && (block != SgOmpReadClause::pools.end()) )
23160 : {
23161 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpReadClause::pool_size * sizeof(SgOmpReadClause) ) ) ;
23162 0 : ++block;
23163 : }
23164 :
23165 : // Special handling for static data
23166 :
23167 :
23168 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
23169 0 : ROSE_ASSERT(found == true);
23170 :
23171 0 : return found;
23172 : }
23173 : /* #line 23174 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23174 :
23175 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
23176 :
23177 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23178 :
23179 : /* #line 23180 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23180 :
23181 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23182 :
23183 : void
23184 0 : SgOmpThreadsClause::checkDataMemberPointersIfInMemoryPool()
23185 : {
23186 : // ------------ checking pointers of SgOmpThreadsClause -------------------
23187 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
23188 :
23189 0 : if ( p_startOfConstruct != NULL )
23190 : {
23191 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23192 : {
23193 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
23194 : {
23195 0 : std::cout << "SgOmpThreadsClause :: ";
23196 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
23197 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
23198 : }
23199 : }
23200 : else
23201 : {
23202 0 : std::cout << "SgOmpThreadsClause :: " << std::flush;
23203 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
23204 0 : std::cout << " not valid " << std::endl;
23205 : }
23206 : }
23207 :
23208 0 : if ( p_endOfConstruct != NULL )
23209 : {
23210 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23211 : {
23212 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
23213 : {
23214 0 : std::cout << "SgOmpThreadsClause :: ";
23215 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
23216 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
23217 : }
23218 : }
23219 : else
23220 : {
23221 0 : std::cout << "SgOmpThreadsClause :: " << std::flush;
23222 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
23223 0 : std::cout << " not valid " << std::endl;
23224 : }
23225 : }
23226 :
23227 0 : if ( p_parent != NULL )
23228 : {
23229 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23230 : {
23231 0 : if ( p_parent->isInMemoryPool() == false )
23232 : {
23233 0 : std::cout << "SgOmpThreadsClause :: ";
23234 0 : std::cout << " p_parent is not in memory pool of ";
23235 0 : std::cout << p_parent->class_name() << std::endl;
23236 : }
23237 : }
23238 : else
23239 : {
23240 0 : std::cout << "SgOmpThreadsClause :: " << std::flush;
23241 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
23242 0 : std::cout << " not valid " << std::endl;
23243 : }
23244 : }
23245 :
23246 :
23247 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23248 :
23249 0 : }
23250 :
23251 :
23252 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
23253 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
23254 : bool
23255 0 : SgOmpThreadsClause::isInMemoryPool ()
23256 : {
23257 0 : typedef unsigned char* TestType;
23258 :
23259 0 : bool found = false;
23260 :
23261 0 : ROSE_ASSERT(this != NULL);
23262 :
23263 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
23264 :
23265 0 : TestType tested = (TestType) ( this ) ;
23266 :
23267 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpThreadsClause::pools.begin();
23268 :
23269 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
23270 : // while (found == false && block < Memory_Block_List.end())
23271 0 : while ( (found == false) && (block != SgOmpThreadsClause::pools.end()) )
23272 : {
23273 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpThreadsClause::pool_size * sizeof(SgOmpThreadsClause) ) ) ;
23274 0 : ++block;
23275 : }
23276 :
23277 : // Special handling for static data
23278 :
23279 :
23280 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
23281 0 : ROSE_ASSERT(found == true);
23282 :
23283 0 : return found;
23284 : }
23285 : /* #line 23286 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23286 :
23287 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
23288 :
23289 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23290 :
23291 : /* #line 23292 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23292 :
23293 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23294 :
23295 : void
23296 0 : SgOmpSimdClause::checkDataMemberPointersIfInMemoryPool()
23297 : {
23298 : // ------------ checking pointers of SgOmpSimdClause -------------------
23299 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
23300 :
23301 0 : if ( p_startOfConstruct != NULL )
23302 : {
23303 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23304 : {
23305 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
23306 : {
23307 0 : std::cout << "SgOmpSimdClause :: ";
23308 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
23309 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
23310 : }
23311 : }
23312 : else
23313 : {
23314 0 : std::cout << "SgOmpSimdClause :: " << std::flush;
23315 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
23316 0 : std::cout << " not valid " << std::endl;
23317 : }
23318 : }
23319 :
23320 0 : if ( p_endOfConstruct != NULL )
23321 : {
23322 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23323 : {
23324 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
23325 : {
23326 0 : std::cout << "SgOmpSimdClause :: ";
23327 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
23328 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
23329 : }
23330 : }
23331 : else
23332 : {
23333 0 : std::cout << "SgOmpSimdClause :: " << std::flush;
23334 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
23335 0 : std::cout << " not valid " << std::endl;
23336 : }
23337 : }
23338 :
23339 0 : if ( p_parent != NULL )
23340 : {
23341 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23342 : {
23343 0 : if ( p_parent->isInMemoryPool() == false )
23344 : {
23345 0 : std::cout << "SgOmpSimdClause :: ";
23346 0 : std::cout << " p_parent is not in memory pool of ";
23347 0 : std::cout << p_parent->class_name() << std::endl;
23348 : }
23349 : }
23350 : else
23351 : {
23352 0 : std::cout << "SgOmpSimdClause :: " << std::flush;
23353 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
23354 0 : std::cout << " not valid " << std::endl;
23355 : }
23356 : }
23357 :
23358 :
23359 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23360 :
23361 0 : }
23362 :
23363 :
23364 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
23365 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
23366 : bool
23367 0 : SgOmpSimdClause::isInMemoryPool ()
23368 : {
23369 0 : typedef unsigned char* TestType;
23370 :
23371 0 : bool found = false;
23372 :
23373 0 : ROSE_ASSERT(this != NULL);
23374 :
23375 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
23376 :
23377 0 : TestType tested = (TestType) ( this ) ;
23378 :
23379 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpSimdClause::pools.begin();
23380 :
23381 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
23382 : // while (found == false && block < Memory_Block_List.end())
23383 0 : while ( (found == false) && (block != SgOmpSimdClause::pools.end()) )
23384 : {
23385 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpSimdClause::pool_size * sizeof(SgOmpSimdClause) ) ) ;
23386 0 : ++block;
23387 : }
23388 :
23389 : // Special handling for static data
23390 :
23391 :
23392 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
23393 0 : ROSE_ASSERT(found == true);
23394 :
23395 0 : return found;
23396 : }
23397 : /* #line 23398 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23398 :
23399 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
23400 :
23401 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23402 :
23403 : /* #line 23404 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23404 :
23405 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23406 :
23407 : void
23408 0 : SgOmpWriteClause::checkDataMemberPointersIfInMemoryPool()
23409 : {
23410 : // ------------ checking pointers of SgOmpWriteClause -------------------
23411 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
23412 :
23413 0 : if ( p_startOfConstruct != NULL )
23414 : {
23415 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23416 : {
23417 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
23418 : {
23419 0 : std::cout << "SgOmpWriteClause :: ";
23420 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
23421 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
23422 : }
23423 : }
23424 : else
23425 : {
23426 0 : std::cout << "SgOmpWriteClause :: " << std::flush;
23427 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
23428 0 : std::cout << " not valid " << std::endl;
23429 : }
23430 : }
23431 :
23432 0 : if ( p_endOfConstruct != NULL )
23433 : {
23434 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23435 : {
23436 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
23437 : {
23438 0 : std::cout << "SgOmpWriteClause :: ";
23439 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
23440 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
23441 : }
23442 : }
23443 : else
23444 : {
23445 0 : std::cout << "SgOmpWriteClause :: " << std::flush;
23446 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
23447 0 : std::cout << " not valid " << std::endl;
23448 : }
23449 : }
23450 :
23451 0 : if ( p_parent != NULL )
23452 : {
23453 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23454 : {
23455 0 : if ( p_parent->isInMemoryPool() == false )
23456 : {
23457 0 : std::cout << "SgOmpWriteClause :: ";
23458 0 : std::cout << " p_parent is not in memory pool of ";
23459 0 : std::cout << p_parent->class_name() << std::endl;
23460 : }
23461 : }
23462 : else
23463 : {
23464 0 : std::cout << "SgOmpWriteClause :: " << std::flush;
23465 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
23466 0 : std::cout << " not valid " << std::endl;
23467 : }
23468 : }
23469 :
23470 :
23471 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23472 :
23473 0 : }
23474 :
23475 :
23476 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
23477 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
23478 : bool
23479 0 : SgOmpWriteClause::isInMemoryPool ()
23480 : {
23481 0 : typedef unsigned char* TestType;
23482 :
23483 0 : bool found = false;
23484 :
23485 0 : ROSE_ASSERT(this != NULL);
23486 :
23487 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
23488 :
23489 0 : TestType tested = (TestType) ( this ) ;
23490 :
23491 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpWriteClause::pools.begin();
23492 :
23493 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
23494 : // while (found == false && block < Memory_Block_List.end())
23495 0 : while ( (found == false) && (block != SgOmpWriteClause::pools.end()) )
23496 : {
23497 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpWriteClause::pool_size * sizeof(SgOmpWriteClause) ) ) ;
23498 0 : ++block;
23499 : }
23500 :
23501 : // Special handling for static data
23502 :
23503 :
23504 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
23505 0 : ROSE_ASSERT(found == true);
23506 :
23507 0 : return found;
23508 : }
23509 : /* #line 23510 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23510 :
23511 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
23512 :
23513 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23514 :
23515 : /* #line 23516 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23516 :
23517 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23518 :
23519 : void
23520 0 : SgOmpUpdateClause::checkDataMemberPointersIfInMemoryPool()
23521 : {
23522 : // ------------ checking pointers of SgOmpUpdateClause -------------------
23523 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
23524 :
23525 0 : if ( p_startOfConstruct != NULL )
23526 : {
23527 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23528 : {
23529 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
23530 : {
23531 0 : std::cout << "SgOmpUpdateClause :: ";
23532 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
23533 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
23534 : }
23535 : }
23536 : else
23537 : {
23538 0 : std::cout << "SgOmpUpdateClause :: " << std::flush;
23539 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
23540 0 : std::cout << " not valid " << std::endl;
23541 : }
23542 : }
23543 :
23544 0 : if ( p_endOfConstruct != NULL )
23545 : {
23546 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23547 : {
23548 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
23549 : {
23550 0 : std::cout << "SgOmpUpdateClause :: ";
23551 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
23552 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
23553 : }
23554 : }
23555 : else
23556 : {
23557 0 : std::cout << "SgOmpUpdateClause :: " << std::flush;
23558 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
23559 0 : std::cout << " not valid " << std::endl;
23560 : }
23561 : }
23562 :
23563 0 : if ( p_parent != NULL )
23564 : {
23565 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23566 : {
23567 0 : if ( p_parent->isInMemoryPool() == false )
23568 : {
23569 0 : std::cout << "SgOmpUpdateClause :: ";
23570 0 : std::cout << " p_parent is not in memory pool of ";
23571 0 : std::cout << p_parent->class_name() << std::endl;
23572 : }
23573 : }
23574 : else
23575 : {
23576 0 : std::cout << "SgOmpUpdateClause :: " << std::flush;
23577 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
23578 0 : std::cout << " not valid " << std::endl;
23579 : }
23580 : }
23581 :
23582 :
23583 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23584 :
23585 0 : }
23586 :
23587 :
23588 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
23589 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
23590 : bool
23591 0 : SgOmpUpdateClause::isInMemoryPool ()
23592 : {
23593 0 : typedef unsigned char* TestType;
23594 :
23595 0 : bool found = false;
23596 :
23597 0 : ROSE_ASSERT(this != NULL);
23598 :
23599 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
23600 :
23601 0 : TestType tested = (TestType) ( this ) ;
23602 :
23603 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpUpdateClause::pools.begin();
23604 :
23605 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
23606 : // while (found == false && block < Memory_Block_List.end())
23607 0 : while ( (found == false) && (block != SgOmpUpdateClause::pools.end()) )
23608 : {
23609 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpUpdateClause::pool_size * sizeof(SgOmpUpdateClause) ) ) ;
23610 0 : ++block;
23611 : }
23612 :
23613 : // Special handling for static data
23614 :
23615 :
23616 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
23617 0 : ROSE_ASSERT(found == true);
23618 :
23619 0 : return found;
23620 : }
23621 : /* #line 23622 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23622 :
23623 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
23624 :
23625 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23626 :
23627 : /* #line 23628 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23628 :
23629 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23630 :
23631 : void
23632 0 : SgOmpDepobjUpdateClause::checkDataMemberPointersIfInMemoryPool()
23633 : {
23634 : // ------------ checking pointers of SgOmpDepobjUpdateClause -------------------
23635 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
23636 :
23637 0 : if ( p_startOfConstruct != NULL )
23638 : {
23639 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23640 : {
23641 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
23642 : {
23643 0 : std::cout << "SgOmpDepobjUpdateClause :: ";
23644 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
23645 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
23646 : }
23647 : }
23648 : else
23649 : {
23650 0 : std::cout << "SgOmpDepobjUpdateClause :: " << std::flush;
23651 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
23652 0 : std::cout << " not valid " << std::endl;
23653 : }
23654 : }
23655 :
23656 0 : if ( p_endOfConstruct != NULL )
23657 : {
23658 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23659 : {
23660 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
23661 : {
23662 0 : std::cout << "SgOmpDepobjUpdateClause :: ";
23663 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
23664 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
23665 : }
23666 : }
23667 : else
23668 : {
23669 0 : std::cout << "SgOmpDepobjUpdateClause :: " << std::flush;
23670 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
23671 0 : std::cout << " not valid " << std::endl;
23672 : }
23673 : }
23674 :
23675 0 : if ( p_parent != NULL )
23676 : {
23677 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23678 : {
23679 0 : if ( p_parent->isInMemoryPool() == false )
23680 : {
23681 0 : std::cout << "SgOmpDepobjUpdateClause :: ";
23682 0 : std::cout << " p_parent is not in memory pool of ";
23683 0 : std::cout << p_parent->class_name() << std::endl;
23684 : }
23685 : }
23686 : else
23687 : {
23688 0 : std::cout << "SgOmpDepobjUpdateClause :: " << std::flush;
23689 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
23690 0 : std::cout << " not valid " << std::endl;
23691 : }
23692 : }
23693 :
23694 :
23695 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23696 :
23697 0 : }
23698 :
23699 :
23700 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
23701 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
23702 : bool
23703 0 : SgOmpDepobjUpdateClause::isInMemoryPool ()
23704 : {
23705 0 : typedef unsigned char* TestType;
23706 :
23707 0 : bool found = false;
23708 :
23709 0 : ROSE_ASSERT(this != NULL);
23710 :
23711 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
23712 :
23713 0 : TestType tested = (TestType) ( this ) ;
23714 :
23715 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDepobjUpdateClause::pools.begin();
23716 :
23717 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
23718 : // while (found == false && block < Memory_Block_List.end())
23719 0 : while ( (found == false) && (block != SgOmpDepobjUpdateClause::pools.end()) )
23720 : {
23721 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDepobjUpdateClause::pool_size * sizeof(SgOmpDepobjUpdateClause) ) ) ;
23722 0 : ++block;
23723 : }
23724 :
23725 : // Special handling for static data
23726 :
23727 :
23728 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
23729 0 : ROSE_ASSERT(found == true);
23730 :
23731 0 : return found;
23732 : }
23733 : /* #line 23734 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23734 :
23735 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
23736 :
23737 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23738 :
23739 : /* #line 23740 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23740 :
23741 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23742 :
23743 : void
23744 0 : SgOmpDestroyClause::checkDataMemberPointersIfInMemoryPool()
23745 : {
23746 : // ------------ checking pointers of SgOmpDestroyClause -------------------
23747 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
23748 :
23749 0 : if ( p_startOfConstruct != NULL )
23750 : {
23751 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23752 : {
23753 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
23754 : {
23755 0 : std::cout << "SgOmpDestroyClause :: ";
23756 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
23757 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
23758 : }
23759 : }
23760 : else
23761 : {
23762 0 : std::cout << "SgOmpDestroyClause :: " << std::flush;
23763 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
23764 0 : std::cout << " not valid " << std::endl;
23765 : }
23766 : }
23767 :
23768 0 : if ( p_endOfConstruct != NULL )
23769 : {
23770 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23771 : {
23772 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
23773 : {
23774 0 : std::cout << "SgOmpDestroyClause :: ";
23775 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
23776 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
23777 : }
23778 : }
23779 : else
23780 : {
23781 0 : std::cout << "SgOmpDestroyClause :: " << std::flush;
23782 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
23783 0 : std::cout << " not valid " << std::endl;
23784 : }
23785 : }
23786 :
23787 0 : if ( p_parent != NULL )
23788 : {
23789 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23790 : {
23791 0 : if ( p_parent->isInMemoryPool() == false )
23792 : {
23793 0 : std::cout << "SgOmpDestroyClause :: ";
23794 0 : std::cout << " p_parent is not in memory pool of ";
23795 0 : std::cout << p_parent->class_name() << std::endl;
23796 : }
23797 : }
23798 : else
23799 : {
23800 0 : std::cout << "SgOmpDestroyClause :: " << std::flush;
23801 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
23802 0 : std::cout << " not valid " << std::endl;
23803 : }
23804 : }
23805 :
23806 :
23807 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23808 :
23809 0 : }
23810 :
23811 :
23812 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
23813 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
23814 : bool
23815 0 : SgOmpDestroyClause::isInMemoryPool ()
23816 : {
23817 0 : typedef unsigned char* TestType;
23818 :
23819 0 : bool found = false;
23820 :
23821 0 : ROSE_ASSERT(this != NULL);
23822 :
23823 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
23824 :
23825 0 : TestType tested = (TestType) ( this ) ;
23826 :
23827 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDestroyClause::pools.begin();
23828 :
23829 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
23830 : // while (found == false && block < Memory_Block_List.end())
23831 0 : while ( (found == false) && (block != SgOmpDestroyClause::pools.end()) )
23832 : {
23833 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDestroyClause::pool_size * sizeof(SgOmpDestroyClause) ) ) ;
23834 0 : ++block;
23835 : }
23836 :
23837 : // Special handling for static data
23838 :
23839 :
23840 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
23841 0 : ROSE_ASSERT(found == true);
23842 :
23843 0 : return found;
23844 : }
23845 : /* #line 23846 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23846 :
23847 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
23848 :
23849 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23850 :
23851 : /* #line 23852 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23852 :
23853 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23854 :
23855 : void
23856 0 : SgOmpCaptureClause::checkDataMemberPointersIfInMemoryPool()
23857 : {
23858 : // ------------ checking pointers of SgOmpCaptureClause -------------------
23859 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
23860 :
23861 0 : if ( p_startOfConstruct != NULL )
23862 : {
23863 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23864 : {
23865 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
23866 : {
23867 0 : std::cout << "SgOmpCaptureClause :: ";
23868 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
23869 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
23870 : }
23871 : }
23872 : else
23873 : {
23874 0 : std::cout << "SgOmpCaptureClause :: " << std::flush;
23875 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
23876 0 : std::cout << " not valid " << std::endl;
23877 : }
23878 : }
23879 :
23880 0 : if ( p_endOfConstruct != NULL )
23881 : {
23882 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23883 : {
23884 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
23885 : {
23886 0 : std::cout << "SgOmpCaptureClause :: ";
23887 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
23888 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
23889 : }
23890 : }
23891 : else
23892 : {
23893 0 : std::cout << "SgOmpCaptureClause :: " << std::flush;
23894 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
23895 0 : std::cout << " not valid " << std::endl;
23896 : }
23897 : }
23898 :
23899 0 : if ( p_parent != NULL )
23900 : {
23901 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23902 : {
23903 0 : if ( p_parent->isInMemoryPool() == false )
23904 : {
23905 0 : std::cout << "SgOmpCaptureClause :: ";
23906 0 : std::cout << " p_parent is not in memory pool of ";
23907 0 : std::cout << p_parent->class_name() << std::endl;
23908 : }
23909 : }
23910 : else
23911 : {
23912 0 : std::cout << "SgOmpCaptureClause :: " << std::flush;
23913 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
23914 0 : std::cout << " not valid " << std::endl;
23915 : }
23916 : }
23917 :
23918 :
23919 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23920 :
23921 0 : }
23922 :
23923 :
23924 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
23925 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
23926 : bool
23927 0 : SgOmpCaptureClause::isInMemoryPool ()
23928 : {
23929 0 : typedef unsigned char* TestType;
23930 :
23931 0 : bool found = false;
23932 :
23933 0 : ROSE_ASSERT(this != NULL);
23934 :
23935 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
23936 :
23937 0 : TestType tested = (TestType) ( this ) ;
23938 :
23939 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpCaptureClause::pools.begin();
23940 :
23941 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
23942 : // while (found == false && block < Memory_Block_List.end())
23943 0 : while ( (found == false) && (block != SgOmpCaptureClause::pools.end()) )
23944 : {
23945 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpCaptureClause::pool_size * sizeof(SgOmpCaptureClause) ) ) ;
23946 0 : ++block;
23947 : }
23948 :
23949 : // Special handling for static data
23950 :
23951 :
23952 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
23953 0 : ROSE_ASSERT(found == true);
23954 :
23955 0 : return found;
23956 : }
23957 : /* #line 23958 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23958 :
23959 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
23960 :
23961 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23962 :
23963 : /* #line 23964 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
23964 :
23965 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
23966 :
23967 : void
23968 0 : SgOmpBeginClause::checkDataMemberPointersIfInMemoryPool()
23969 : {
23970 : // ------------ checking pointers of SgOmpBeginClause -------------------
23971 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
23972 :
23973 0 : if ( p_startOfConstruct != NULL )
23974 : {
23975 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23976 : {
23977 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
23978 : {
23979 0 : std::cout << "SgOmpBeginClause :: ";
23980 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
23981 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
23982 : }
23983 : }
23984 : else
23985 : {
23986 0 : std::cout << "SgOmpBeginClause :: " << std::flush;
23987 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
23988 0 : std::cout << " not valid " << std::endl;
23989 : }
23990 : }
23991 :
23992 0 : if ( p_endOfConstruct != NULL )
23993 : {
23994 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
23995 : {
23996 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
23997 : {
23998 0 : std::cout << "SgOmpBeginClause :: ";
23999 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
24000 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
24001 : }
24002 : }
24003 : else
24004 : {
24005 0 : std::cout << "SgOmpBeginClause :: " << std::flush;
24006 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
24007 0 : std::cout << " not valid " << std::endl;
24008 : }
24009 : }
24010 :
24011 0 : if ( p_parent != NULL )
24012 : {
24013 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24014 : {
24015 0 : if ( p_parent->isInMemoryPool() == false )
24016 : {
24017 0 : std::cout << "SgOmpBeginClause :: ";
24018 0 : std::cout << " p_parent is not in memory pool of ";
24019 0 : std::cout << p_parent->class_name() << std::endl;
24020 : }
24021 : }
24022 : else
24023 : {
24024 0 : std::cout << "SgOmpBeginClause :: " << std::flush;
24025 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
24026 0 : std::cout << " not valid " << std::endl;
24027 : }
24028 : }
24029 :
24030 :
24031 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24032 :
24033 0 : }
24034 :
24035 :
24036 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
24037 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
24038 : bool
24039 0 : SgOmpBeginClause::isInMemoryPool ()
24040 : {
24041 0 : typedef unsigned char* TestType;
24042 :
24043 0 : bool found = false;
24044 :
24045 0 : ROSE_ASSERT(this != NULL);
24046 :
24047 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
24048 :
24049 0 : TestType tested = (TestType) ( this ) ;
24050 :
24051 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpBeginClause::pools.begin();
24052 :
24053 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
24054 : // while (found == false && block < Memory_Block_List.end())
24055 0 : while ( (found == false) && (block != SgOmpBeginClause::pools.end()) )
24056 : {
24057 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpBeginClause::pool_size * sizeof(SgOmpBeginClause) ) ) ;
24058 0 : ++block;
24059 : }
24060 :
24061 : // Special handling for static data
24062 :
24063 :
24064 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
24065 0 : ROSE_ASSERT(found == true);
24066 :
24067 0 : return found;
24068 : }
24069 : /* #line 24070 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24070 :
24071 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
24072 :
24073 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24074 :
24075 : /* #line 24076 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24076 :
24077 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24078 :
24079 : void
24080 0 : SgOmpEndClause::checkDataMemberPointersIfInMemoryPool()
24081 : {
24082 : // ------------ checking pointers of SgOmpEndClause -------------------
24083 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
24084 :
24085 0 : if ( p_startOfConstruct != NULL )
24086 : {
24087 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24088 : {
24089 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
24090 : {
24091 0 : std::cout << "SgOmpEndClause :: ";
24092 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
24093 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
24094 : }
24095 : }
24096 : else
24097 : {
24098 0 : std::cout << "SgOmpEndClause :: " << std::flush;
24099 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
24100 0 : std::cout << " not valid " << std::endl;
24101 : }
24102 : }
24103 :
24104 0 : if ( p_endOfConstruct != NULL )
24105 : {
24106 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24107 : {
24108 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
24109 : {
24110 0 : std::cout << "SgOmpEndClause :: ";
24111 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
24112 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
24113 : }
24114 : }
24115 : else
24116 : {
24117 0 : std::cout << "SgOmpEndClause :: " << std::flush;
24118 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
24119 0 : std::cout << " not valid " << std::endl;
24120 : }
24121 : }
24122 :
24123 0 : if ( p_parent != NULL )
24124 : {
24125 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24126 : {
24127 0 : if ( p_parent->isInMemoryPool() == false )
24128 : {
24129 0 : std::cout << "SgOmpEndClause :: ";
24130 0 : std::cout << " p_parent is not in memory pool of ";
24131 0 : std::cout << p_parent->class_name() << std::endl;
24132 : }
24133 : }
24134 : else
24135 : {
24136 0 : std::cout << "SgOmpEndClause :: " << std::flush;
24137 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
24138 0 : std::cout << " not valid " << std::endl;
24139 : }
24140 : }
24141 :
24142 :
24143 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24144 :
24145 0 : }
24146 :
24147 :
24148 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
24149 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
24150 : bool
24151 0 : SgOmpEndClause::isInMemoryPool ()
24152 : {
24153 0 : typedef unsigned char* TestType;
24154 :
24155 0 : bool found = false;
24156 :
24157 0 : ROSE_ASSERT(this != NULL);
24158 :
24159 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
24160 :
24161 0 : TestType tested = (TestType) ( this ) ;
24162 :
24163 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpEndClause::pools.begin();
24164 :
24165 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
24166 : // while (found == false && block < Memory_Block_List.end())
24167 0 : while ( (found == false) && (block != SgOmpEndClause::pools.end()) )
24168 : {
24169 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpEndClause::pool_size * sizeof(SgOmpEndClause) ) ) ;
24170 0 : ++block;
24171 : }
24172 :
24173 : // Special handling for static data
24174 :
24175 :
24176 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
24177 0 : ROSE_ASSERT(found == true);
24178 :
24179 0 : return found;
24180 : }
24181 : /* #line 24182 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24182 :
24183 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
24184 :
24185 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24186 :
24187 : /* #line 24188 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24188 :
24189 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24190 :
24191 : void
24192 0 : SgOmpUntiedClause::checkDataMemberPointersIfInMemoryPool()
24193 : {
24194 : // ------------ checking pointers of SgOmpUntiedClause -------------------
24195 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
24196 :
24197 0 : if ( p_startOfConstruct != NULL )
24198 : {
24199 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24200 : {
24201 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
24202 : {
24203 0 : std::cout << "SgOmpUntiedClause :: ";
24204 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
24205 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
24206 : }
24207 : }
24208 : else
24209 : {
24210 0 : std::cout << "SgOmpUntiedClause :: " << std::flush;
24211 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
24212 0 : std::cout << " not valid " << std::endl;
24213 : }
24214 : }
24215 :
24216 0 : if ( p_endOfConstruct != NULL )
24217 : {
24218 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24219 : {
24220 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
24221 : {
24222 0 : std::cout << "SgOmpUntiedClause :: ";
24223 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
24224 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
24225 : }
24226 : }
24227 : else
24228 : {
24229 0 : std::cout << "SgOmpUntiedClause :: " << std::flush;
24230 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
24231 0 : std::cout << " not valid " << std::endl;
24232 : }
24233 : }
24234 :
24235 0 : if ( p_parent != NULL )
24236 : {
24237 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24238 : {
24239 0 : if ( p_parent->isInMemoryPool() == false )
24240 : {
24241 0 : std::cout << "SgOmpUntiedClause :: ";
24242 0 : std::cout << " p_parent is not in memory pool of ";
24243 0 : std::cout << p_parent->class_name() << std::endl;
24244 : }
24245 : }
24246 : else
24247 : {
24248 0 : std::cout << "SgOmpUntiedClause :: " << std::flush;
24249 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
24250 0 : std::cout << " not valid " << std::endl;
24251 : }
24252 : }
24253 :
24254 :
24255 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24256 :
24257 0 : }
24258 :
24259 :
24260 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
24261 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
24262 : bool
24263 0 : SgOmpUntiedClause::isInMemoryPool ()
24264 : {
24265 0 : typedef unsigned char* TestType;
24266 :
24267 0 : bool found = false;
24268 :
24269 0 : ROSE_ASSERT(this != NULL);
24270 :
24271 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
24272 :
24273 0 : TestType tested = (TestType) ( this ) ;
24274 :
24275 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpUntiedClause::pools.begin();
24276 :
24277 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
24278 : // while (found == false && block < Memory_Block_List.end())
24279 0 : while ( (found == false) && (block != SgOmpUntiedClause::pools.end()) )
24280 : {
24281 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpUntiedClause::pool_size * sizeof(SgOmpUntiedClause) ) ) ;
24282 0 : ++block;
24283 : }
24284 :
24285 : // Special handling for static data
24286 :
24287 :
24288 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
24289 0 : ROSE_ASSERT(found == true);
24290 :
24291 0 : return found;
24292 : }
24293 : /* #line 24294 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24294 :
24295 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
24296 :
24297 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24298 :
24299 : /* #line 24300 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24300 :
24301 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24302 :
24303 : void
24304 0 : SgOmpSeqCstClause::checkDataMemberPointersIfInMemoryPool()
24305 : {
24306 : // ------------ checking pointers of SgOmpSeqCstClause -------------------
24307 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
24308 :
24309 0 : if ( p_startOfConstruct != NULL )
24310 : {
24311 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24312 : {
24313 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
24314 : {
24315 0 : std::cout << "SgOmpSeqCstClause :: ";
24316 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
24317 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
24318 : }
24319 : }
24320 : else
24321 : {
24322 0 : std::cout << "SgOmpSeqCstClause :: " << std::flush;
24323 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
24324 0 : std::cout << " not valid " << std::endl;
24325 : }
24326 : }
24327 :
24328 0 : if ( p_endOfConstruct != NULL )
24329 : {
24330 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24331 : {
24332 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
24333 : {
24334 0 : std::cout << "SgOmpSeqCstClause :: ";
24335 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
24336 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
24337 : }
24338 : }
24339 : else
24340 : {
24341 0 : std::cout << "SgOmpSeqCstClause :: " << std::flush;
24342 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
24343 0 : std::cout << " not valid " << std::endl;
24344 : }
24345 : }
24346 :
24347 0 : if ( p_parent != NULL )
24348 : {
24349 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24350 : {
24351 0 : if ( p_parent->isInMemoryPool() == false )
24352 : {
24353 0 : std::cout << "SgOmpSeqCstClause :: ";
24354 0 : std::cout << " p_parent is not in memory pool of ";
24355 0 : std::cout << p_parent->class_name() << std::endl;
24356 : }
24357 : }
24358 : else
24359 : {
24360 0 : std::cout << "SgOmpSeqCstClause :: " << std::flush;
24361 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
24362 0 : std::cout << " not valid " << std::endl;
24363 : }
24364 : }
24365 :
24366 :
24367 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24368 :
24369 0 : }
24370 :
24371 :
24372 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
24373 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
24374 : bool
24375 0 : SgOmpSeqCstClause::isInMemoryPool ()
24376 : {
24377 0 : typedef unsigned char* TestType;
24378 :
24379 0 : bool found = false;
24380 :
24381 0 : ROSE_ASSERT(this != NULL);
24382 :
24383 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
24384 :
24385 0 : TestType tested = (TestType) ( this ) ;
24386 :
24387 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpSeqCstClause::pools.begin();
24388 :
24389 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
24390 : // while (found == false && block < Memory_Block_List.end())
24391 0 : while ( (found == false) && (block != SgOmpSeqCstClause::pools.end()) )
24392 : {
24393 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpSeqCstClause::pool_size * sizeof(SgOmpSeqCstClause) ) ) ;
24394 0 : ++block;
24395 : }
24396 :
24397 : // Special handling for static data
24398 :
24399 :
24400 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
24401 0 : ROSE_ASSERT(found == true);
24402 :
24403 0 : return found;
24404 : }
24405 : /* #line 24406 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24406 :
24407 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
24408 :
24409 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24410 :
24411 : /* #line 24412 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24412 :
24413 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24414 :
24415 : void
24416 0 : SgOmpAcqRelClause::checkDataMemberPointersIfInMemoryPool()
24417 : {
24418 : // ------------ checking pointers of SgOmpAcqRelClause -------------------
24419 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
24420 :
24421 0 : if ( p_startOfConstruct != NULL )
24422 : {
24423 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24424 : {
24425 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
24426 : {
24427 0 : std::cout << "SgOmpAcqRelClause :: ";
24428 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
24429 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
24430 : }
24431 : }
24432 : else
24433 : {
24434 0 : std::cout << "SgOmpAcqRelClause :: " << std::flush;
24435 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
24436 0 : std::cout << " not valid " << std::endl;
24437 : }
24438 : }
24439 :
24440 0 : if ( p_endOfConstruct != NULL )
24441 : {
24442 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24443 : {
24444 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
24445 : {
24446 0 : std::cout << "SgOmpAcqRelClause :: ";
24447 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
24448 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
24449 : }
24450 : }
24451 : else
24452 : {
24453 0 : std::cout << "SgOmpAcqRelClause :: " << std::flush;
24454 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
24455 0 : std::cout << " not valid " << std::endl;
24456 : }
24457 : }
24458 :
24459 0 : if ( p_parent != NULL )
24460 : {
24461 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24462 : {
24463 0 : if ( p_parent->isInMemoryPool() == false )
24464 : {
24465 0 : std::cout << "SgOmpAcqRelClause :: ";
24466 0 : std::cout << " p_parent is not in memory pool of ";
24467 0 : std::cout << p_parent->class_name() << std::endl;
24468 : }
24469 : }
24470 : else
24471 : {
24472 0 : std::cout << "SgOmpAcqRelClause :: " << std::flush;
24473 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
24474 0 : std::cout << " not valid " << std::endl;
24475 : }
24476 : }
24477 :
24478 :
24479 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24480 :
24481 0 : }
24482 :
24483 :
24484 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
24485 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
24486 : bool
24487 0 : SgOmpAcqRelClause::isInMemoryPool ()
24488 : {
24489 0 : typedef unsigned char* TestType;
24490 :
24491 0 : bool found = false;
24492 :
24493 0 : ROSE_ASSERT(this != NULL);
24494 :
24495 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
24496 :
24497 0 : TestType tested = (TestType) ( this ) ;
24498 :
24499 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpAcqRelClause::pools.begin();
24500 :
24501 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
24502 : // while (found == false && block < Memory_Block_List.end())
24503 0 : while ( (found == false) && (block != SgOmpAcqRelClause::pools.end()) )
24504 : {
24505 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpAcqRelClause::pool_size * sizeof(SgOmpAcqRelClause) ) ) ;
24506 0 : ++block;
24507 : }
24508 :
24509 : // Special handling for static data
24510 :
24511 :
24512 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
24513 0 : ROSE_ASSERT(found == true);
24514 :
24515 0 : return found;
24516 : }
24517 : /* #line 24518 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24518 :
24519 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
24520 :
24521 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24522 :
24523 : /* #line 24524 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24524 :
24525 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24526 :
24527 : void
24528 0 : SgOmpReleaseClause::checkDataMemberPointersIfInMemoryPool()
24529 : {
24530 : // ------------ checking pointers of SgOmpReleaseClause -------------------
24531 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
24532 :
24533 0 : if ( p_startOfConstruct != NULL )
24534 : {
24535 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24536 : {
24537 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
24538 : {
24539 0 : std::cout << "SgOmpReleaseClause :: ";
24540 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
24541 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
24542 : }
24543 : }
24544 : else
24545 : {
24546 0 : std::cout << "SgOmpReleaseClause :: " << std::flush;
24547 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
24548 0 : std::cout << " not valid " << std::endl;
24549 : }
24550 : }
24551 :
24552 0 : if ( p_endOfConstruct != NULL )
24553 : {
24554 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24555 : {
24556 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
24557 : {
24558 0 : std::cout << "SgOmpReleaseClause :: ";
24559 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
24560 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
24561 : }
24562 : }
24563 : else
24564 : {
24565 0 : std::cout << "SgOmpReleaseClause :: " << std::flush;
24566 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
24567 0 : std::cout << " not valid " << std::endl;
24568 : }
24569 : }
24570 :
24571 0 : if ( p_parent != NULL )
24572 : {
24573 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24574 : {
24575 0 : if ( p_parent->isInMemoryPool() == false )
24576 : {
24577 0 : std::cout << "SgOmpReleaseClause :: ";
24578 0 : std::cout << " p_parent is not in memory pool of ";
24579 0 : std::cout << p_parent->class_name() << std::endl;
24580 : }
24581 : }
24582 : else
24583 : {
24584 0 : std::cout << "SgOmpReleaseClause :: " << std::flush;
24585 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
24586 0 : std::cout << " not valid " << std::endl;
24587 : }
24588 : }
24589 :
24590 :
24591 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24592 :
24593 0 : }
24594 :
24595 :
24596 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
24597 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
24598 : bool
24599 0 : SgOmpReleaseClause::isInMemoryPool ()
24600 : {
24601 0 : typedef unsigned char* TestType;
24602 :
24603 0 : bool found = false;
24604 :
24605 0 : ROSE_ASSERT(this != NULL);
24606 :
24607 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
24608 :
24609 0 : TestType tested = (TestType) ( this ) ;
24610 :
24611 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpReleaseClause::pools.begin();
24612 :
24613 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
24614 : // while (found == false && block < Memory_Block_List.end())
24615 0 : while ( (found == false) && (block != SgOmpReleaseClause::pools.end()) )
24616 : {
24617 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpReleaseClause::pool_size * sizeof(SgOmpReleaseClause) ) ) ;
24618 0 : ++block;
24619 : }
24620 :
24621 : // Special handling for static data
24622 :
24623 :
24624 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
24625 0 : ROSE_ASSERT(found == true);
24626 :
24627 0 : return found;
24628 : }
24629 : /* #line 24630 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24630 :
24631 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
24632 :
24633 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24634 :
24635 : /* #line 24636 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24636 :
24637 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24638 :
24639 : void
24640 0 : SgOmpAcquireClause::checkDataMemberPointersIfInMemoryPool()
24641 : {
24642 : // ------------ checking pointers of SgOmpAcquireClause -------------------
24643 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
24644 :
24645 0 : if ( p_startOfConstruct != NULL )
24646 : {
24647 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24648 : {
24649 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
24650 : {
24651 0 : std::cout << "SgOmpAcquireClause :: ";
24652 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
24653 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
24654 : }
24655 : }
24656 : else
24657 : {
24658 0 : std::cout << "SgOmpAcquireClause :: " << std::flush;
24659 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
24660 0 : std::cout << " not valid " << std::endl;
24661 : }
24662 : }
24663 :
24664 0 : if ( p_endOfConstruct != NULL )
24665 : {
24666 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24667 : {
24668 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
24669 : {
24670 0 : std::cout << "SgOmpAcquireClause :: ";
24671 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
24672 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
24673 : }
24674 : }
24675 : else
24676 : {
24677 0 : std::cout << "SgOmpAcquireClause :: " << std::flush;
24678 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
24679 0 : std::cout << " not valid " << std::endl;
24680 : }
24681 : }
24682 :
24683 0 : if ( p_parent != NULL )
24684 : {
24685 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24686 : {
24687 0 : if ( p_parent->isInMemoryPool() == false )
24688 : {
24689 0 : std::cout << "SgOmpAcquireClause :: ";
24690 0 : std::cout << " p_parent is not in memory pool of ";
24691 0 : std::cout << p_parent->class_name() << std::endl;
24692 : }
24693 : }
24694 : else
24695 : {
24696 0 : std::cout << "SgOmpAcquireClause :: " << std::flush;
24697 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
24698 0 : std::cout << " not valid " << std::endl;
24699 : }
24700 : }
24701 :
24702 :
24703 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24704 :
24705 0 : }
24706 :
24707 :
24708 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
24709 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
24710 : bool
24711 0 : SgOmpAcquireClause::isInMemoryPool ()
24712 : {
24713 0 : typedef unsigned char* TestType;
24714 :
24715 0 : bool found = false;
24716 :
24717 0 : ROSE_ASSERT(this != NULL);
24718 :
24719 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
24720 :
24721 0 : TestType tested = (TestType) ( this ) ;
24722 :
24723 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpAcquireClause::pools.begin();
24724 :
24725 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
24726 : // while (found == false && block < Memory_Block_List.end())
24727 0 : while ( (found == false) && (block != SgOmpAcquireClause::pools.end()) )
24728 : {
24729 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpAcquireClause::pool_size * sizeof(SgOmpAcquireClause) ) ) ;
24730 0 : ++block;
24731 : }
24732 :
24733 : // Special handling for static data
24734 :
24735 :
24736 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
24737 0 : ROSE_ASSERT(found == true);
24738 :
24739 0 : return found;
24740 : }
24741 : /* #line 24742 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24742 :
24743 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
24744 :
24745 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24746 :
24747 : /* #line 24748 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24748 :
24749 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24750 :
24751 : void
24752 0 : SgOmpRelaxedClause::checkDataMemberPointersIfInMemoryPool()
24753 : {
24754 : // ------------ checking pointers of SgOmpRelaxedClause -------------------
24755 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
24756 :
24757 0 : if ( p_startOfConstruct != NULL )
24758 : {
24759 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24760 : {
24761 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
24762 : {
24763 0 : std::cout << "SgOmpRelaxedClause :: ";
24764 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
24765 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
24766 : }
24767 : }
24768 : else
24769 : {
24770 0 : std::cout << "SgOmpRelaxedClause :: " << std::flush;
24771 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
24772 0 : std::cout << " not valid " << std::endl;
24773 : }
24774 : }
24775 :
24776 0 : if ( p_endOfConstruct != NULL )
24777 : {
24778 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24779 : {
24780 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
24781 : {
24782 0 : std::cout << "SgOmpRelaxedClause :: ";
24783 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
24784 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
24785 : }
24786 : }
24787 : else
24788 : {
24789 0 : std::cout << "SgOmpRelaxedClause :: " << std::flush;
24790 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
24791 0 : std::cout << " not valid " << std::endl;
24792 : }
24793 : }
24794 :
24795 0 : if ( p_parent != NULL )
24796 : {
24797 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24798 : {
24799 0 : if ( p_parent->isInMemoryPool() == false )
24800 : {
24801 0 : std::cout << "SgOmpRelaxedClause :: ";
24802 0 : std::cout << " p_parent is not in memory pool of ";
24803 0 : std::cout << p_parent->class_name() << std::endl;
24804 : }
24805 : }
24806 : else
24807 : {
24808 0 : std::cout << "SgOmpRelaxedClause :: " << std::flush;
24809 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
24810 0 : std::cout << " not valid " << std::endl;
24811 : }
24812 : }
24813 :
24814 :
24815 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24816 :
24817 0 : }
24818 :
24819 :
24820 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
24821 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
24822 : bool
24823 0 : SgOmpRelaxedClause::isInMemoryPool ()
24824 : {
24825 0 : typedef unsigned char* TestType;
24826 :
24827 0 : bool found = false;
24828 :
24829 0 : ROSE_ASSERT(this != NULL);
24830 :
24831 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
24832 :
24833 0 : TestType tested = (TestType) ( this ) ;
24834 :
24835 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpRelaxedClause::pools.begin();
24836 :
24837 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
24838 : // while (found == false && block < Memory_Block_List.end())
24839 0 : while ( (found == false) && (block != SgOmpRelaxedClause::pools.end()) )
24840 : {
24841 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpRelaxedClause::pool_size * sizeof(SgOmpRelaxedClause) ) ) ;
24842 0 : ++block;
24843 : }
24844 :
24845 : // Special handling for static data
24846 :
24847 :
24848 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
24849 0 : ROSE_ASSERT(found == true);
24850 :
24851 0 : return found;
24852 : }
24853 : /* #line 24854 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24854 :
24855 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
24856 :
24857 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24858 :
24859 : /* #line 24860 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24860 :
24861 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24862 :
24863 : void
24864 0 : SgOmpReverseOffloadClause::checkDataMemberPointersIfInMemoryPool()
24865 : {
24866 : // ------------ checking pointers of SgOmpReverseOffloadClause -------------------
24867 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
24868 :
24869 0 : if ( p_startOfConstruct != NULL )
24870 : {
24871 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24872 : {
24873 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
24874 : {
24875 0 : std::cout << "SgOmpReverseOffloadClause :: ";
24876 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
24877 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
24878 : }
24879 : }
24880 : else
24881 : {
24882 0 : std::cout << "SgOmpReverseOffloadClause :: " << std::flush;
24883 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
24884 0 : std::cout << " not valid " << std::endl;
24885 : }
24886 : }
24887 :
24888 0 : if ( p_endOfConstruct != NULL )
24889 : {
24890 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24891 : {
24892 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
24893 : {
24894 0 : std::cout << "SgOmpReverseOffloadClause :: ";
24895 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
24896 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
24897 : }
24898 : }
24899 : else
24900 : {
24901 0 : std::cout << "SgOmpReverseOffloadClause :: " << std::flush;
24902 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
24903 0 : std::cout << " not valid " << std::endl;
24904 : }
24905 : }
24906 :
24907 0 : if ( p_parent != NULL )
24908 : {
24909 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24910 : {
24911 0 : if ( p_parent->isInMemoryPool() == false )
24912 : {
24913 0 : std::cout << "SgOmpReverseOffloadClause :: ";
24914 0 : std::cout << " p_parent is not in memory pool of ";
24915 0 : std::cout << p_parent->class_name() << std::endl;
24916 : }
24917 : }
24918 : else
24919 : {
24920 0 : std::cout << "SgOmpReverseOffloadClause :: " << std::flush;
24921 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
24922 0 : std::cout << " not valid " << std::endl;
24923 : }
24924 : }
24925 :
24926 :
24927 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24928 :
24929 0 : }
24930 :
24931 :
24932 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
24933 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
24934 : bool
24935 0 : SgOmpReverseOffloadClause::isInMemoryPool ()
24936 : {
24937 0 : typedef unsigned char* TestType;
24938 :
24939 0 : bool found = false;
24940 :
24941 0 : ROSE_ASSERT(this != NULL);
24942 :
24943 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
24944 :
24945 0 : TestType tested = (TestType) ( this ) ;
24946 :
24947 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpReverseOffloadClause::pools.begin();
24948 :
24949 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
24950 : // while (found == false && block < Memory_Block_List.end())
24951 0 : while ( (found == false) && (block != SgOmpReverseOffloadClause::pools.end()) )
24952 : {
24953 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpReverseOffloadClause::pool_size * sizeof(SgOmpReverseOffloadClause) ) ) ;
24954 0 : ++block;
24955 : }
24956 :
24957 : // Special handling for static data
24958 :
24959 :
24960 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
24961 0 : ROSE_ASSERT(found == true);
24962 :
24963 0 : return found;
24964 : }
24965 : /* #line 24966 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24966 :
24967 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
24968 :
24969 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24970 :
24971 : /* #line 24972 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
24972 :
24973 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
24974 :
24975 : void
24976 0 : SgOmpUnifiedAddressClause::checkDataMemberPointersIfInMemoryPool()
24977 : {
24978 : // ------------ checking pointers of SgOmpUnifiedAddressClause -------------------
24979 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
24980 :
24981 0 : if ( p_startOfConstruct != NULL )
24982 : {
24983 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
24984 : {
24985 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
24986 : {
24987 0 : std::cout << "SgOmpUnifiedAddressClause :: ";
24988 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
24989 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
24990 : }
24991 : }
24992 : else
24993 : {
24994 0 : std::cout << "SgOmpUnifiedAddressClause :: " << std::flush;
24995 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
24996 0 : std::cout << " not valid " << std::endl;
24997 : }
24998 : }
24999 :
25000 0 : if ( p_endOfConstruct != NULL )
25001 : {
25002 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25003 : {
25004 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
25005 : {
25006 0 : std::cout << "SgOmpUnifiedAddressClause :: ";
25007 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
25008 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
25009 : }
25010 : }
25011 : else
25012 : {
25013 0 : std::cout << "SgOmpUnifiedAddressClause :: " << std::flush;
25014 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
25015 0 : std::cout << " not valid " << std::endl;
25016 : }
25017 : }
25018 :
25019 0 : if ( p_parent != NULL )
25020 : {
25021 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25022 : {
25023 0 : if ( p_parent->isInMemoryPool() == false )
25024 : {
25025 0 : std::cout << "SgOmpUnifiedAddressClause :: ";
25026 0 : std::cout << " p_parent is not in memory pool of ";
25027 0 : std::cout << p_parent->class_name() << std::endl;
25028 : }
25029 : }
25030 : else
25031 : {
25032 0 : std::cout << "SgOmpUnifiedAddressClause :: " << std::flush;
25033 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
25034 0 : std::cout << " not valid " << std::endl;
25035 : }
25036 : }
25037 :
25038 :
25039 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25040 :
25041 0 : }
25042 :
25043 :
25044 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
25045 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
25046 : bool
25047 0 : SgOmpUnifiedAddressClause::isInMemoryPool ()
25048 : {
25049 0 : typedef unsigned char* TestType;
25050 :
25051 0 : bool found = false;
25052 :
25053 0 : ROSE_ASSERT(this != NULL);
25054 :
25055 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
25056 :
25057 0 : TestType tested = (TestType) ( this ) ;
25058 :
25059 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpUnifiedAddressClause::pools.begin();
25060 :
25061 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
25062 : // while (found == false && block < Memory_Block_List.end())
25063 0 : while ( (found == false) && (block != SgOmpUnifiedAddressClause::pools.end()) )
25064 : {
25065 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpUnifiedAddressClause::pool_size * sizeof(SgOmpUnifiedAddressClause) ) ) ;
25066 0 : ++block;
25067 : }
25068 :
25069 : // Special handling for static data
25070 :
25071 :
25072 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
25073 0 : ROSE_ASSERT(found == true);
25074 :
25075 0 : return found;
25076 : }
25077 : /* #line 25078 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25078 :
25079 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
25080 :
25081 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25082 :
25083 : /* #line 25084 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25084 :
25085 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25086 :
25087 : void
25088 0 : SgOmpUnifiedSharedMemoryClause::checkDataMemberPointersIfInMemoryPool()
25089 : {
25090 : // ------------ checking pointers of SgOmpUnifiedSharedMemoryClause -------------------
25091 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
25092 :
25093 0 : if ( p_startOfConstruct != NULL )
25094 : {
25095 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25096 : {
25097 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
25098 : {
25099 0 : std::cout << "SgOmpUnifiedSharedMemoryClause :: ";
25100 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
25101 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
25102 : }
25103 : }
25104 : else
25105 : {
25106 0 : std::cout << "SgOmpUnifiedSharedMemoryClause :: " << std::flush;
25107 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
25108 0 : std::cout << " not valid " << std::endl;
25109 : }
25110 : }
25111 :
25112 0 : if ( p_endOfConstruct != NULL )
25113 : {
25114 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25115 : {
25116 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
25117 : {
25118 0 : std::cout << "SgOmpUnifiedSharedMemoryClause :: ";
25119 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
25120 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
25121 : }
25122 : }
25123 : else
25124 : {
25125 0 : std::cout << "SgOmpUnifiedSharedMemoryClause :: " << std::flush;
25126 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
25127 0 : std::cout << " not valid " << std::endl;
25128 : }
25129 : }
25130 :
25131 0 : if ( p_parent != NULL )
25132 : {
25133 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25134 : {
25135 0 : if ( p_parent->isInMemoryPool() == false )
25136 : {
25137 0 : std::cout << "SgOmpUnifiedSharedMemoryClause :: ";
25138 0 : std::cout << " p_parent is not in memory pool of ";
25139 0 : std::cout << p_parent->class_name() << std::endl;
25140 : }
25141 : }
25142 : else
25143 : {
25144 0 : std::cout << "SgOmpUnifiedSharedMemoryClause :: " << std::flush;
25145 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
25146 0 : std::cout << " not valid " << std::endl;
25147 : }
25148 : }
25149 :
25150 :
25151 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25152 :
25153 0 : }
25154 :
25155 :
25156 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
25157 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
25158 : bool
25159 0 : SgOmpUnifiedSharedMemoryClause::isInMemoryPool ()
25160 : {
25161 0 : typedef unsigned char* TestType;
25162 :
25163 0 : bool found = false;
25164 :
25165 0 : ROSE_ASSERT(this != NULL);
25166 :
25167 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
25168 :
25169 0 : TestType tested = (TestType) ( this ) ;
25170 :
25171 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpUnifiedSharedMemoryClause::pools.begin();
25172 :
25173 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
25174 : // while (found == false && block < Memory_Block_List.end())
25175 0 : while ( (found == false) && (block != SgOmpUnifiedSharedMemoryClause::pools.end()) )
25176 : {
25177 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpUnifiedSharedMemoryClause::pool_size * sizeof(SgOmpUnifiedSharedMemoryClause) ) ) ;
25178 0 : ++block;
25179 : }
25180 :
25181 : // Special handling for static data
25182 :
25183 :
25184 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
25185 0 : ROSE_ASSERT(found == true);
25186 :
25187 0 : return found;
25188 : }
25189 : /* #line 25190 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25190 :
25191 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
25192 :
25193 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25194 :
25195 : /* #line 25196 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25196 :
25197 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25198 :
25199 : void
25200 0 : SgOmpDynamicAllocatorsClause::checkDataMemberPointersIfInMemoryPool()
25201 : {
25202 : // ------------ checking pointers of SgOmpDynamicAllocatorsClause -------------------
25203 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
25204 :
25205 0 : if ( p_startOfConstruct != NULL )
25206 : {
25207 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25208 : {
25209 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
25210 : {
25211 0 : std::cout << "SgOmpDynamicAllocatorsClause :: ";
25212 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
25213 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
25214 : }
25215 : }
25216 : else
25217 : {
25218 0 : std::cout << "SgOmpDynamicAllocatorsClause :: " << std::flush;
25219 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
25220 0 : std::cout << " not valid " << std::endl;
25221 : }
25222 : }
25223 :
25224 0 : if ( p_endOfConstruct != NULL )
25225 : {
25226 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25227 : {
25228 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
25229 : {
25230 0 : std::cout << "SgOmpDynamicAllocatorsClause :: ";
25231 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
25232 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
25233 : }
25234 : }
25235 : else
25236 : {
25237 0 : std::cout << "SgOmpDynamicAllocatorsClause :: " << std::flush;
25238 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
25239 0 : std::cout << " not valid " << std::endl;
25240 : }
25241 : }
25242 :
25243 0 : if ( p_parent != NULL )
25244 : {
25245 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25246 : {
25247 0 : if ( p_parent->isInMemoryPool() == false )
25248 : {
25249 0 : std::cout << "SgOmpDynamicAllocatorsClause :: ";
25250 0 : std::cout << " p_parent is not in memory pool of ";
25251 0 : std::cout << p_parent->class_name() << std::endl;
25252 : }
25253 : }
25254 : else
25255 : {
25256 0 : std::cout << "SgOmpDynamicAllocatorsClause :: " << std::flush;
25257 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
25258 0 : std::cout << " not valid " << std::endl;
25259 : }
25260 : }
25261 :
25262 :
25263 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25264 :
25265 0 : }
25266 :
25267 :
25268 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
25269 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
25270 : bool
25271 0 : SgOmpDynamicAllocatorsClause::isInMemoryPool ()
25272 : {
25273 0 : typedef unsigned char* TestType;
25274 :
25275 0 : bool found = false;
25276 :
25277 0 : ROSE_ASSERT(this != NULL);
25278 :
25279 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
25280 :
25281 0 : TestType tested = (TestType) ( this ) ;
25282 :
25283 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDynamicAllocatorsClause::pools.begin();
25284 :
25285 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
25286 : // while (found == false && block < Memory_Block_List.end())
25287 0 : while ( (found == false) && (block != SgOmpDynamicAllocatorsClause::pools.end()) )
25288 : {
25289 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDynamicAllocatorsClause::pool_size * sizeof(SgOmpDynamicAllocatorsClause) ) ) ;
25290 0 : ++block;
25291 : }
25292 :
25293 : // Special handling for static data
25294 :
25295 :
25296 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
25297 0 : ROSE_ASSERT(found == true);
25298 :
25299 0 : return found;
25300 : }
25301 : /* #line 25302 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25302 :
25303 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
25304 :
25305 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25306 :
25307 : /* #line 25308 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25308 :
25309 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25310 :
25311 : void
25312 0 : SgOmpParallelClause::checkDataMemberPointersIfInMemoryPool()
25313 : {
25314 : // ------------ checking pointers of SgOmpParallelClause -------------------
25315 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
25316 :
25317 0 : if ( p_startOfConstruct != NULL )
25318 : {
25319 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25320 : {
25321 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
25322 : {
25323 0 : std::cout << "SgOmpParallelClause :: ";
25324 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
25325 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
25326 : }
25327 : }
25328 : else
25329 : {
25330 0 : std::cout << "SgOmpParallelClause :: " << std::flush;
25331 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
25332 0 : std::cout << " not valid " << std::endl;
25333 : }
25334 : }
25335 :
25336 0 : if ( p_endOfConstruct != NULL )
25337 : {
25338 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25339 : {
25340 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
25341 : {
25342 0 : std::cout << "SgOmpParallelClause :: ";
25343 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
25344 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
25345 : }
25346 : }
25347 : else
25348 : {
25349 0 : std::cout << "SgOmpParallelClause :: " << std::flush;
25350 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
25351 0 : std::cout << " not valid " << std::endl;
25352 : }
25353 : }
25354 :
25355 0 : if ( p_parent != NULL )
25356 : {
25357 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25358 : {
25359 0 : if ( p_parent->isInMemoryPool() == false )
25360 : {
25361 0 : std::cout << "SgOmpParallelClause :: ";
25362 0 : std::cout << " p_parent is not in memory pool of ";
25363 0 : std::cout << p_parent->class_name() << std::endl;
25364 : }
25365 : }
25366 : else
25367 : {
25368 0 : std::cout << "SgOmpParallelClause :: " << std::flush;
25369 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
25370 0 : std::cout << " not valid " << std::endl;
25371 : }
25372 : }
25373 :
25374 :
25375 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25376 :
25377 0 : }
25378 :
25379 :
25380 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
25381 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
25382 : bool
25383 0 : SgOmpParallelClause::isInMemoryPool ()
25384 : {
25385 0 : typedef unsigned char* TestType;
25386 :
25387 0 : bool found = false;
25388 :
25389 0 : ROSE_ASSERT(this != NULL);
25390 :
25391 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
25392 :
25393 0 : TestType tested = (TestType) ( this ) ;
25394 :
25395 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpParallelClause::pools.begin();
25396 :
25397 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
25398 : // while (found == false && block < Memory_Block_List.end())
25399 0 : while ( (found == false) && (block != SgOmpParallelClause::pools.end()) )
25400 : {
25401 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpParallelClause::pool_size * sizeof(SgOmpParallelClause) ) ) ;
25402 0 : ++block;
25403 : }
25404 :
25405 : // Special handling for static data
25406 :
25407 :
25408 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
25409 0 : ROSE_ASSERT(found == true);
25410 :
25411 0 : return found;
25412 : }
25413 : /* #line 25414 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25414 :
25415 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
25416 :
25417 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25418 :
25419 : /* #line 25420 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25420 :
25421 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25422 :
25423 : void
25424 0 : SgOmpSectionsClause::checkDataMemberPointersIfInMemoryPool()
25425 : {
25426 : // ------------ checking pointers of SgOmpSectionsClause -------------------
25427 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
25428 :
25429 0 : if ( p_startOfConstruct != NULL )
25430 : {
25431 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25432 : {
25433 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
25434 : {
25435 0 : std::cout << "SgOmpSectionsClause :: ";
25436 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
25437 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
25438 : }
25439 : }
25440 : else
25441 : {
25442 0 : std::cout << "SgOmpSectionsClause :: " << std::flush;
25443 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
25444 0 : std::cout << " not valid " << std::endl;
25445 : }
25446 : }
25447 :
25448 0 : if ( p_endOfConstruct != NULL )
25449 : {
25450 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25451 : {
25452 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
25453 : {
25454 0 : std::cout << "SgOmpSectionsClause :: ";
25455 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
25456 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
25457 : }
25458 : }
25459 : else
25460 : {
25461 0 : std::cout << "SgOmpSectionsClause :: " << std::flush;
25462 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
25463 0 : std::cout << " not valid " << std::endl;
25464 : }
25465 : }
25466 :
25467 0 : if ( p_parent != NULL )
25468 : {
25469 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25470 : {
25471 0 : if ( p_parent->isInMemoryPool() == false )
25472 : {
25473 0 : std::cout << "SgOmpSectionsClause :: ";
25474 0 : std::cout << " p_parent is not in memory pool of ";
25475 0 : std::cout << p_parent->class_name() << std::endl;
25476 : }
25477 : }
25478 : else
25479 : {
25480 0 : std::cout << "SgOmpSectionsClause :: " << std::flush;
25481 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
25482 0 : std::cout << " not valid " << std::endl;
25483 : }
25484 : }
25485 :
25486 :
25487 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25488 :
25489 0 : }
25490 :
25491 :
25492 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
25493 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
25494 : bool
25495 0 : SgOmpSectionsClause::isInMemoryPool ()
25496 : {
25497 0 : typedef unsigned char* TestType;
25498 :
25499 0 : bool found = false;
25500 :
25501 0 : ROSE_ASSERT(this != NULL);
25502 :
25503 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
25504 :
25505 0 : TestType tested = (TestType) ( this ) ;
25506 :
25507 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpSectionsClause::pools.begin();
25508 :
25509 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
25510 : // while (found == false && block < Memory_Block_List.end())
25511 0 : while ( (found == false) && (block != SgOmpSectionsClause::pools.end()) )
25512 : {
25513 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpSectionsClause::pool_size * sizeof(SgOmpSectionsClause) ) ) ;
25514 0 : ++block;
25515 : }
25516 :
25517 : // Special handling for static data
25518 :
25519 :
25520 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
25521 0 : ROSE_ASSERT(found == true);
25522 :
25523 0 : return found;
25524 : }
25525 : /* #line 25526 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25526 :
25527 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
25528 :
25529 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25530 :
25531 : /* #line 25532 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25532 :
25533 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25534 :
25535 : void
25536 0 : SgOmpForClause::checkDataMemberPointersIfInMemoryPool()
25537 : {
25538 : // ------------ checking pointers of SgOmpForClause -------------------
25539 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
25540 :
25541 0 : if ( p_startOfConstruct != NULL )
25542 : {
25543 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25544 : {
25545 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
25546 : {
25547 0 : std::cout << "SgOmpForClause :: ";
25548 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
25549 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
25550 : }
25551 : }
25552 : else
25553 : {
25554 0 : std::cout << "SgOmpForClause :: " << std::flush;
25555 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
25556 0 : std::cout << " not valid " << std::endl;
25557 : }
25558 : }
25559 :
25560 0 : if ( p_endOfConstruct != NULL )
25561 : {
25562 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25563 : {
25564 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
25565 : {
25566 0 : std::cout << "SgOmpForClause :: ";
25567 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
25568 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
25569 : }
25570 : }
25571 : else
25572 : {
25573 0 : std::cout << "SgOmpForClause :: " << std::flush;
25574 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
25575 0 : std::cout << " not valid " << std::endl;
25576 : }
25577 : }
25578 :
25579 0 : if ( p_parent != NULL )
25580 : {
25581 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25582 : {
25583 0 : if ( p_parent->isInMemoryPool() == false )
25584 : {
25585 0 : std::cout << "SgOmpForClause :: ";
25586 0 : std::cout << " p_parent is not in memory pool of ";
25587 0 : std::cout << p_parent->class_name() << std::endl;
25588 : }
25589 : }
25590 : else
25591 : {
25592 0 : std::cout << "SgOmpForClause :: " << std::flush;
25593 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
25594 0 : std::cout << " not valid " << std::endl;
25595 : }
25596 : }
25597 :
25598 :
25599 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25600 :
25601 0 : }
25602 :
25603 :
25604 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
25605 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
25606 : bool
25607 0 : SgOmpForClause::isInMemoryPool ()
25608 : {
25609 0 : typedef unsigned char* TestType;
25610 :
25611 0 : bool found = false;
25612 :
25613 0 : ROSE_ASSERT(this != NULL);
25614 :
25615 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
25616 :
25617 0 : TestType tested = (TestType) ( this ) ;
25618 :
25619 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpForClause::pools.begin();
25620 :
25621 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
25622 : // while (found == false && block < Memory_Block_List.end())
25623 0 : while ( (found == false) && (block != SgOmpForClause::pools.end()) )
25624 : {
25625 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpForClause::pool_size * sizeof(SgOmpForClause) ) ) ;
25626 0 : ++block;
25627 : }
25628 :
25629 : // Special handling for static data
25630 :
25631 :
25632 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
25633 0 : ROSE_ASSERT(found == true);
25634 :
25635 0 : return found;
25636 : }
25637 : /* #line 25638 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25638 :
25639 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
25640 :
25641 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25642 :
25643 : /* #line 25644 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25644 :
25645 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25646 :
25647 : void
25648 0 : SgOmpTaskgroupClause::checkDataMemberPointersIfInMemoryPool()
25649 : {
25650 : // ------------ checking pointers of SgOmpTaskgroupClause -------------------
25651 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
25652 :
25653 0 : if ( p_startOfConstruct != NULL )
25654 : {
25655 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25656 : {
25657 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
25658 : {
25659 0 : std::cout << "SgOmpTaskgroupClause :: ";
25660 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
25661 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
25662 : }
25663 : }
25664 : else
25665 : {
25666 0 : std::cout << "SgOmpTaskgroupClause :: " << std::flush;
25667 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
25668 0 : std::cout << " not valid " << std::endl;
25669 : }
25670 : }
25671 :
25672 0 : if ( p_endOfConstruct != NULL )
25673 : {
25674 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25675 : {
25676 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
25677 : {
25678 0 : std::cout << "SgOmpTaskgroupClause :: ";
25679 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
25680 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
25681 : }
25682 : }
25683 : else
25684 : {
25685 0 : std::cout << "SgOmpTaskgroupClause :: " << std::flush;
25686 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
25687 0 : std::cout << " not valid " << std::endl;
25688 : }
25689 : }
25690 :
25691 0 : if ( p_parent != NULL )
25692 : {
25693 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25694 : {
25695 0 : if ( p_parent->isInMemoryPool() == false )
25696 : {
25697 0 : std::cout << "SgOmpTaskgroupClause :: ";
25698 0 : std::cout << " p_parent is not in memory pool of ";
25699 0 : std::cout << p_parent->class_name() << std::endl;
25700 : }
25701 : }
25702 : else
25703 : {
25704 0 : std::cout << "SgOmpTaskgroupClause :: " << std::flush;
25705 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
25706 0 : std::cout << " not valid " << std::endl;
25707 : }
25708 : }
25709 :
25710 :
25711 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25712 :
25713 0 : }
25714 :
25715 :
25716 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
25717 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
25718 : bool
25719 0 : SgOmpTaskgroupClause::isInMemoryPool ()
25720 : {
25721 0 : typedef unsigned char* TestType;
25722 :
25723 0 : bool found = false;
25724 :
25725 0 : ROSE_ASSERT(this != NULL);
25726 :
25727 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
25728 :
25729 0 : TestType tested = (TestType) ( this ) ;
25730 :
25731 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTaskgroupClause::pools.begin();
25732 :
25733 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
25734 : // while (found == false && block < Memory_Block_List.end())
25735 0 : while ( (found == false) && (block != SgOmpTaskgroupClause::pools.end()) )
25736 : {
25737 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTaskgroupClause::pool_size * sizeof(SgOmpTaskgroupClause) ) ) ;
25738 0 : ++block;
25739 : }
25740 :
25741 : // Special handling for static data
25742 :
25743 :
25744 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
25745 0 : ROSE_ASSERT(found == true);
25746 :
25747 0 : return found;
25748 : }
25749 : /* #line 25750 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25750 :
25751 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
25752 :
25753 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25754 :
25755 : /* #line 25756 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25756 :
25757 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25758 :
25759 : void
25760 0 : SgOmpNogroupClause::checkDataMemberPointersIfInMemoryPool()
25761 : {
25762 : // ------------ checking pointers of SgOmpNogroupClause -------------------
25763 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
25764 :
25765 0 : if ( p_startOfConstruct != NULL )
25766 : {
25767 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25768 : {
25769 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
25770 : {
25771 0 : std::cout << "SgOmpNogroupClause :: ";
25772 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
25773 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
25774 : }
25775 : }
25776 : else
25777 : {
25778 0 : std::cout << "SgOmpNogroupClause :: " << std::flush;
25779 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
25780 0 : std::cout << " not valid " << std::endl;
25781 : }
25782 : }
25783 :
25784 0 : if ( p_endOfConstruct != NULL )
25785 : {
25786 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25787 : {
25788 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
25789 : {
25790 0 : std::cout << "SgOmpNogroupClause :: ";
25791 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
25792 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
25793 : }
25794 : }
25795 : else
25796 : {
25797 0 : std::cout << "SgOmpNogroupClause :: " << std::flush;
25798 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
25799 0 : std::cout << " not valid " << std::endl;
25800 : }
25801 : }
25802 :
25803 0 : if ( p_parent != NULL )
25804 : {
25805 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25806 : {
25807 0 : if ( p_parent->isInMemoryPool() == false )
25808 : {
25809 0 : std::cout << "SgOmpNogroupClause :: ";
25810 0 : std::cout << " p_parent is not in memory pool of ";
25811 0 : std::cout << p_parent->class_name() << std::endl;
25812 : }
25813 : }
25814 : else
25815 : {
25816 0 : std::cout << "SgOmpNogroupClause :: " << std::flush;
25817 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
25818 0 : std::cout << " not valid " << std::endl;
25819 : }
25820 : }
25821 :
25822 :
25823 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25824 :
25825 0 : }
25826 :
25827 :
25828 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
25829 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
25830 : bool
25831 0 : SgOmpNogroupClause::isInMemoryPool ()
25832 : {
25833 0 : typedef unsigned char* TestType;
25834 :
25835 0 : bool found = false;
25836 :
25837 0 : ROSE_ASSERT(this != NULL);
25838 :
25839 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
25840 :
25841 0 : TestType tested = (TestType) ( this ) ;
25842 :
25843 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpNogroupClause::pools.begin();
25844 :
25845 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
25846 : // while (found == false && block < Memory_Block_List.end())
25847 0 : while ( (found == false) && (block != SgOmpNogroupClause::pools.end()) )
25848 : {
25849 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpNogroupClause::pool_size * sizeof(SgOmpNogroupClause) ) ) ;
25850 0 : ++block;
25851 : }
25852 :
25853 : // Special handling for static data
25854 :
25855 :
25856 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
25857 0 : ROSE_ASSERT(found == true);
25858 :
25859 0 : return found;
25860 : }
25861 : /* #line 25862 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25862 :
25863 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
25864 :
25865 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25866 :
25867 : /* #line 25868 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25868 :
25869 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25870 :
25871 : void
25872 0 : SgOmpDefaultClause::checkDataMemberPointersIfInMemoryPool()
25873 : {
25874 : // ------------ checking pointers of SgOmpDefaultClause -------------------
25875 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
25876 :
25877 0 : if ( p_variant_directive != NULL )
25878 : {
25879 0 : if ( p_variant_directive->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25880 : {
25881 0 : if ( p_variant_directive->isInMemoryPool() == false )
25882 : {
25883 0 : std::cout << "SgOmpDefaultClause :: ";
25884 0 : std::cout << " p_variant_directive is not in memory pool of ";
25885 0 : std::cout << p_variant_directive->class_name() << std::endl;
25886 : }
25887 : }
25888 : else
25889 : {
25890 0 : std::cout << "SgOmpDefaultClause :: " << std::flush;
25891 0 : std::cout << "SgStatement* p_variant_directive = " << p_variant_directive << " --> " << std::flush;
25892 0 : std::cout << " not valid " << std::endl;
25893 : }
25894 : }
25895 :
25896 0 : if ( p_startOfConstruct != NULL )
25897 : {
25898 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25899 : {
25900 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
25901 : {
25902 0 : std::cout << "SgOmpDefaultClause :: ";
25903 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
25904 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
25905 : }
25906 : }
25907 : else
25908 : {
25909 0 : std::cout << "SgOmpDefaultClause :: " << std::flush;
25910 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
25911 0 : std::cout << " not valid " << std::endl;
25912 : }
25913 : }
25914 :
25915 0 : if ( p_endOfConstruct != NULL )
25916 : {
25917 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25918 : {
25919 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
25920 : {
25921 0 : std::cout << "SgOmpDefaultClause :: ";
25922 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
25923 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
25924 : }
25925 : }
25926 : else
25927 : {
25928 0 : std::cout << "SgOmpDefaultClause :: " << std::flush;
25929 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
25930 0 : std::cout << " not valid " << std::endl;
25931 : }
25932 : }
25933 :
25934 0 : if ( p_parent != NULL )
25935 : {
25936 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
25937 : {
25938 0 : if ( p_parent->isInMemoryPool() == false )
25939 : {
25940 0 : std::cout << "SgOmpDefaultClause :: ";
25941 0 : std::cout << " p_parent is not in memory pool of ";
25942 0 : std::cout << p_parent->class_name() << std::endl;
25943 : }
25944 : }
25945 : else
25946 : {
25947 0 : std::cout << "SgOmpDefaultClause :: " << std::flush;
25948 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
25949 0 : std::cout << " not valid " << std::endl;
25950 : }
25951 : }
25952 :
25953 :
25954 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25955 :
25956 0 : }
25957 :
25958 :
25959 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
25960 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
25961 : bool
25962 0 : SgOmpDefaultClause::isInMemoryPool ()
25963 : {
25964 0 : typedef unsigned char* TestType;
25965 :
25966 0 : bool found = false;
25967 :
25968 0 : ROSE_ASSERT(this != NULL);
25969 :
25970 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
25971 :
25972 0 : TestType tested = (TestType) ( this ) ;
25973 :
25974 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDefaultClause::pools.begin();
25975 :
25976 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
25977 : // while (found == false && block < Memory_Block_List.end())
25978 0 : while ( (found == false) && (block != SgOmpDefaultClause::pools.end()) )
25979 : {
25980 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDefaultClause::pool_size * sizeof(SgOmpDefaultClause) ) ) ;
25981 0 : ++block;
25982 : }
25983 :
25984 : // Special handling for static data
25985 :
25986 :
25987 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
25988 0 : ROSE_ASSERT(found == true);
25989 :
25990 0 : return found;
25991 : }
25992 : /* #line 25993 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25993 :
25994 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
25995 :
25996 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
25997 :
25998 : /* #line 25999 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
25999 :
26000 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26001 :
26002 : void
26003 0 : SgOmpAllocatorClause::checkDataMemberPointersIfInMemoryPool()
26004 : {
26005 : // ------------ checking pointers of SgOmpAllocatorClause -------------------
26006 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
26007 :
26008 0 : if ( p_user_defined_modifier != NULL )
26009 : {
26010 0 : if ( p_user_defined_modifier->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26011 : {
26012 0 : if ( p_user_defined_modifier->isInMemoryPool() == false )
26013 : {
26014 0 : std::cout << "SgOmpAllocatorClause :: ";
26015 0 : std::cout << " p_user_defined_modifier is not in memory pool of ";
26016 0 : std::cout << p_user_defined_modifier->class_name() << std::endl;
26017 : }
26018 : }
26019 : else
26020 : {
26021 0 : std::cout << "SgOmpAllocatorClause :: " << std::flush;
26022 0 : std::cout << "SgExpression* p_user_defined_modifier = " << p_user_defined_modifier << " --> " << std::flush;
26023 0 : std::cout << " not valid " << std::endl;
26024 : }
26025 : }
26026 :
26027 0 : if ( p_startOfConstruct != NULL )
26028 : {
26029 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26030 : {
26031 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
26032 : {
26033 0 : std::cout << "SgOmpAllocatorClause :: ";
26034 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
26035 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
26036 : }
26037 : }
26038 : else
26039 : {
26040 0 : std::cout << "SgOmpAllocatorClause :: " << std::flush;
26041 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
26042 0 : std::cout << " not valid " << std::endl;
26043 : }
26044 : }
26045 :
26046 0 : if ( p_endOfConstruct != NULL )
26047 : {
26048 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26049 : {
26050 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
26051 : {
26052 0 : std::cout << "SgOmpAllocatorClause :: ";
26053 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
26054 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
26055 : }
26056 : }
26057 : else
26058 : {
26059 0 : std::cout << "SgOmpAllocatorClause :: " << std::flush;
26060 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
26061 0 : std::cout << " not valid " << std::endl;
26062 : }
26063 : }
26064 :
26065 0 : if ( p_parent != NULL )
26066 : {
26067 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26068 : {
26069 0 : if ( p_parent->isInMemoryPool() == false )
26070 : {
26071 0 : std::cout << "SgOmpAllocatorClause :: ";
26072 0 : std::cout << " p_parent is not in memory pool of ";
26073 0 : std::cout << p_parent->class_name() << std::endl;
26074 : }
26075 : }
26076 : else
26077 : {
26078 0 : std::cout << "SgOmpAllocatorClause :: " << std::flush;
26079 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
26080 0 : std::cout << " not valid " << std::endl;
26081 : }
26082 : }
26083 :
26084 :
26085 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26086 :
26087 0 : }
26088 :
26089 :
26090 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
26091 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
26092 : bool
26093 0 : SgOmpAllocatorClause::isInMemoryPool ()
26094 : {
26095 0 : typedef unsigned char* TestType;
26096 :
26097 0 : bool found = false;
26098 :
26099 0 : ROSE_ASSERT(this != NULL);
26100 :
26101 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
26102 :
26103 0 : TestType tested = (TestType) ( this ) ;
26104 :
26105 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpAllocatorClause::pools.begin();
26106 :
26107 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
26108 : // while (found == false && block < Memory_Block_List.end())
26109 0 : while ( (found == false) && (block != SgOmpAllocatorClause::pools.end()) )
26110 : {
26111 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpAllocatorClause::pool_size * sizeof(SgOmpAllocatorClause) ) ) ;
26112 0 : ++block;
26113 : }
26114 :
26115 : // Special handling for static data
26116 :
26117 :
26118 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
26119 0 : ROSE_ASSERT(found == true);
26120 :
26121 0 : return found;
26122 : }
26123 : /* #line 26124 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
26124 :
26125 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
26126 :
26127 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26128 :
26129 : /* #line 26130 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
26130 :
26131 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26132 :
26133 : void
26134 0 : SgOmpAtomicClause::checkDataMemberPointersIfInMemoryPool()
26135 : {
26136 : // ------------ checking pointers of SgOmpAtomicClause -------------------
26137 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
26138 :
26139 0 : if ( p_startOfConstruct != NULL )
26140 : {
26141 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26142 : {
26143 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
26144 : {
26145 0 : std::cout << "SgOmpAtomicClause :: ";
26146 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
26147 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
26148 : }
26149 : }
26150 : else
26151 : {
26152 0 : std::cout << "SgOmpAtomicClause :: " << std::flush;
26153 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
26154 0 : std::cout << " not valid " << std::endl;
26155 : }
26156 : }
26157 :
26158 0 : if ( p_endOfConstruct != NULL )
26159 : {
26160 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26161 : {
26162 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
26163 : {
26164 0 : std::cout << "SgOmpAtomicClause :: ";
26165 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
26166 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
26167 : }
26168 : }
26169 : else
26170 : {
26171 0 : std::cout << "SgOmpAtomicClause :: " << std::flush;
26172 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
26173 0 : std::cout << " not valid " << std::endl;
26174 : }
26175 : }
26176 :
26177 0 : if ( p_parent != NULL )
26178 : {
26179 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26180 : {
26181 0 : if ( p_parent->isInMemoryPool() == false )
26182 : {
26183 0 : std::cout << "SgOmpAtomicClause :: ";
26184 0 : std::cout << " p_parent is not in memory pool of ";
26185 0 : std::cout << p_parent->class_name() << std::endl;
26186 : }
26187 : }
26188 : else
26189 : {
26190 0 : std::cout << "SgOmpAtomicClause :: " << std::flush;
26191 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
26192 0 : std::cout << " not valid " << std::endl;
26193 : }
26194 : }
26195 :
26196 :
26197 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26198 :
26199 0 : }
26200 :
26201 :
26202 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
26203 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
26204 : bool
26205 0 : SgOmpAtomicClause::isInMemoryPool ()
26206 : {
26207 0 : typedef unsigned char* TestType;
26208 :
26209 0 : bool found = false;
26210 :
26211 0 : ROSE_ASSERT(this != NULL);
26212 :
26213 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
26214 :
26215 0 : TestType tested = (TestType) ( this ) ;
26216 :
26217 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpAtomicClause::pools.begin();
26218 :
26219 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
26220 : // while (found == false && block < Memory_Block_List.end())
26221 0 : while ( (found == false) && (block != SgOmpAtomicClause::pools.end()) )
26222 : {
26223 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpAtomicClause::pool_size * sizeof(SgOmpAtomicClause) ) ) ;
26224 0 : ++block;
26225 : }
26226 :
26227 : // Special handling for static data
26228 :
26229 :
26230 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
26231 0 : ROSE_ASSERT(found == true);
26232 :
26233 0 : return found;
26234 : }
26235 : /* #line 26236 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
26236 :
26237 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
26238 :
26239 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26240 :
26241 : /* #line 26242 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
26242 :
26243 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26244 :
26245 : void
26246 0 : SgOmpProcBindClause::checkDataMemberPointersIfInMemoryPool()
26247 : {
26248 : // ------------ checking pointers of SgOmpProcBindClause -------------------
26249 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
26250 :
26251 0 : if ( p_startOfConstruct != NULL )
26252 : {
26253 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26254 : {
26255 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
26256 : {
26257 0 : std::cout << "SgOmpProcBindClause :: ";
26258 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
26259 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
26260 : }
26261 : }
26262 : else
26263 : {
26264 0 : std::cout << "SgOmpProcBindClause :: " << std::flush;
26265 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
26266 0 : std::cout << " not valid " << std::endl;
26267 : }
26268 : }
26269 :
26270 0 : if ( p_endOfConstruct != NULL )
26271 : {
26272 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26273 : {
26274 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
26275 : {
26276 0 : std::cout << "SgOmpProcBindClause :: ";
26277 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
26278 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
26279 : }
26280 : }
26281 : else
26282 : {
26283 0 : std::cout << "SgOmpProcBindClause :: " << std::flush;
26284 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
26285 0 : std::cout << " not valid " << std::endl;
26286 : }
26287 : }
26288 :
26289 0 : if ( p_parent != NULL )
26290 : {
26291 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26292 : {
26293 0 : if ( p_parent->isInMemoryPool() == false )
26294 : {
26295 0 : std::cout << "SgOmpProcBindClause :: ";
26296 0 : std::cout << " p_parent is not in memory pool of ";
26297 0 : std::cout << p_parent->class_name() << std::endl;
26298 : }
26299 : }
26300 : else
26301 : {
26302 0 : std::cout << "SgOmpProcBindClause :: " << std::flush;
26303 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
26304 0 : std::cout << " not valid " << std::endl;
26305 : }
26306 : }
26307 :
26308 :
26309 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26310 :
26311 0 : }
26312 :
26313 :
26314 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
26315 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
26316 : bool
26317 0 : SgOmpProcBindClause::isInMemoryPool ()
26318 : {
26319 0 : typedef unsigned char* TestType;
26320 :
26321 0 : bool found = false;
26322 :
26323 0 : ROSE_ASSERT(this != NULL);
26324 :
26325 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
26326 :
26327 0 : TestType tested = (TestType) ( this ) ;
26328 :
26329 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpProcBindClause::pools.begin();
26330 :
26331 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
26332 : // while (found == false && block < Memory_Block_List.end())
26333 0 : while ( (found == false) && (block != SgOmpProcBindClause::pools.end()) )
26334 : {
26335 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpProcBindClause::pool_size * sizeof(SgOmpProcBindClause) ) ) ;
26336 0 : ++block;
26337 : }
26338 :
26339 : // Special handling for static data
26340 :
26341 :
26342 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
26343 0 : ROSE_ASSERT(found == true);
26344 :
26345 0 : return found;
26346 : }
26347 : /* #line 26348 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
26348 :
26349 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
26350 :
26351 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26352 :
26353 : /* #line 26354 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
26354 :
26355 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26356 :
26357 : void
26358 0 : SgOmpBindClause::checkDataMemberPointersIfInMemoryPool()
26359 : {
26360 : // ------------ checking pointers of SgOmpBindClause -------------------
26361 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
26362 :
26363 0 : if ( p_startOfConstruct != NULL )
26364 : {
26365 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26366 : {
26367 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
26368 : {
26369 0 : std::cout << "SgOmpBindClause :: ";
26370 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
26371 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
26372 : }
26373 : }
26374 : else
26375 : {
26376 0 : std::cout << "SgOmpBindClause :: " << std::flush;
26377 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
26378 0 : std::cout << " not valid " << std::endl;
26379 : }
26380 : }
26381 :
26382 0 : if ( p_endOfConstruct != NULL )
26383 : {
26384 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26385 : {
26386 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
26387 : {
26388 0 : std::cout << "SgOmpBindClause :: ";
26389 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
26390 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
26391 : }
26392 : }
26393 : else
26394 : {
26395 0 : std::cout << "SgOmpBindClause :: " << std::flush;
26396 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
26397 0 : std::cout << " not valid " << std::endl;
26398 : }
26399 : }
26400 :
26401 0 : if ( p_parent != NULL )
26402 : {
26403 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26404 : {
26405 0 : if ( p_parent->isInMemoryPool() == false )
26406 : {
26407 0 : std::cout << "SgOmpBindClause :: ";
26408 0 : std::cout << " p_parent is not in memory pool of ";
26409 0 : std::cout << p_parent->class_name() << std::endl;
26410 : }
26411 : }
26412 : else
26413 : {
26414 0 : std::cout << "SgOmpBindClause :: " << std::flush;
26415 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
26416 0 : std::cout << " not valid " << std::endl;
26417 : }
26418 : }
26419 :
26420 :
26421 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26422 :
26423 0 : }
26424 :
26425 :
26426 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
26427 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
26428 : bool
26429 0 : SgOmpBindClause::isInMemoryPool ()
26430 : {
26431 0 : typedef unsigned char* TestType;
26432 :
26433 0 : bool found = false;
26434 :
26435 0 : ROSE_ASSERT(this != NULL);
26436 :
26437 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
26438 :
26439 0 : TestType tested = (TestType) ( this ) ;
26440 :
26441 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpBindClause::pools.begin();
26442 :
26443 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
26444 : // while (found == false && block < Memory_Block_List.end())
26445 0 : while ( (found == false) && (block != SgOmpBindClause::pools.end()) )
26446 : {
26447 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpBindClause::pool_size * sizeof(SgOmpBindClause) ) ) ;
26448 0 : ++block;
26449 : }
26450 :
26451 : // Special handling for static data
26452 :
26453 :
26454 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
26455 0 : ROSE_ASSERT(found == true);
26456 :
26457 0 : return found;
26458 : }
26459 : /* #line 26460 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
26460 :
26461 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
26462 :
26463 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26464 :
26465 : /* #line 26466 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
26466 :
26467 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26468 :
26469 : void
26470 0 : SgOmpOrderClause::checkDataMemberPointersIfInMemoryPool()
26471 : {
26472 : // ------------ checking pointers of SgOmpOrderClause -------------------
26473 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
26474 :
26475 0 : if ( p_startOfConstruct != NULL )
26476 : {
26477 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26478 : {
26479 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
26480 : {
26481 0 : std::cout << "SgOmpOrderClause :: ";
26482 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
26483 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
26484 : }
26485 : }
26486 : else
26487 : {
26488 0 : std::cout << "SgOmpOrderClause :: " << std::flush;
26489 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
26490 0 : std::cout << " not valid " << std::endl;
26491 : }
26492 : }
26493 :
26494 0 : if ( p_endOfConstruct != NULL )
26495 : {
26496 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26497 : {
26498 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
26499 : {
26500 0 : std::cout << "SgOmpOrderClause :: ";
26501 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
26502 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
26503 : }
26504 : }
26505 : else
26506 : {
26507 0 : std::cout << "SgOmpOrderClause :: " << std::flush;
26508 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
26509 0 : std::cout << " not valid " << std::endl;
26510 : }
26511 : }
26512 :
26513 0 : if ( p_parent != NULL )
26514 : {
26515 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26516 : {
26517 0 : if ( p_parent->isInMemoryPool() == false )
26518 : {
26519 0 : std::cout << "SgOmpOrderClause :: ";
26520 0 : std::cout << " p_parent is not in memory pool of ";
26521 0 : std::cout << p_parent->class_name() << std::endl;
26522 : }
26523 : }
26524 : else
26525 : {
26526 0 : std::cout << "SgOmpOrderClause :: " << std::flush;
26527 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
26528 0 : std::cout << " not valid " << std::endl;
26529 : }
26530 : }
26531 :
26532 :
26533 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26534 :
26535 0 : }
26536 :
26537 :
26538 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
26539 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
26540 : bool
26541 0 : SgOmpOrderClause::isInMemoryPool ()
26542 : {
26543 0 : typedef unsigned char* TestType;
26544 :
26545 0 : bool found = false;
26546 :
26547 0 : ROSE_ASSERT(this != NULL);
26548 :
26549 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
26550 :
26551 0 : TestType tested = (TestType) ( this ) ;
26552 :
26553 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpOrderClause::pools.begin();
26554 :
26555 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
26556 : // while (found == false && block < Memory_Block_List.end())
26557 0 : while ( (found == false) && (block != SgOmpOrderClause::pools.end()) )
26558 : {
26559 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpOrderClause::pool_size * sizeof(SgOmpOrderClause) ) ) ;
26560 0 : ++block;
26561 : }
26562 :
26563 : // Special handling for static data
26564 :
26565 :
26566 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
26567 0 : ROSE_ASSERT(found == true);
26568 :
26569 0 : return found;
26570 : }
26571 : /* #line 26572 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
26572 :
26573 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
26574 :
26575 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26576 :
26577 : /* #line 26578 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
26578 :
26579 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26580 :
26581 : void
26582 0 : SgOmpDistScheduleClause::checkDataMemberPointersIfInMemoryPool()
26583 : {
26584 : // ------------ checking pointers of SgOmpDistScheduleClause -------------------
26585 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
26586 :
26587 0 : if ( p_chunk_size != NULL )
26588 : {
26589 0 : if ( p_chunk_size->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26590 : {
26591 0 : if ( p_chunk_size->isInMemoryPool() == false )
26592 : {
26593 0 : std::cout << "SgOmpDistScheduleClause :: ";
26594 0 : std::cout << " p_chunk_size is not in memory pool of ";
26595 0 : std::cout << p_chunk_size->class_name() << std::endl;
26596 : }
26597 : }
26598 : else
26599 : {
26600 0 : std::cout << "SgOmpDistScheduleClause :: " << std::flush;
26601 0 : std::cout << "SgExpression* p_chunk_size = " << p_chunk_size << " --> " << std::flush;
26602 0 : std::cout << " not valid " << std::endl;
26603 : }
26604 : }
26605 :
26606 0 : if ( p_startOfConstruct != NULL )
26607 : {
26608 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26609 : {
26610 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
26611 : {
26612 0 : std::cout << "SgOmpDistScheduleClause :: ";
26613 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
26614 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
26615 : }
26616 : }
26617 : else
26618 : {
26619 0 : std::cout << "SgOmpDistScheduleClause :: " << std::flush;
26620 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
26621 0 : std::cout << " not valid " << std::endl;
26622 : }
26623 : }
26624 :
26625 0 : if ( p_endOfConstruct != NULL )
26626 : {
26627 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26628 : {
26629 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
26630 : {
26631 0 : std::cout << "SgOmpDistScheduleClause :: ";
26632 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
26633 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
26634 : }
26635 : }
26636 : else
26637 : {
26638 0 : std::cout << "SgOmpDistScheduleClause :: " << std::flush;
26639 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
26640 0 : std::cout << " not valid " << std::endl;
26641 : }
26642 : }
26643 :
26644 0 : if ( p_parent != NULL )
26645 : {
26646 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26647 : {
26648 0 : if ( p_parent->isInMemoryPool() == false )
26649 : {
26650 0 : std::cout << "SgOmpDistScheduleClause :: ";
26651 0 : std::cout << " p_parent is not in memory pool of ";
26652 0 : std::cout << p_parent->class_name() << std::endl;
26653 : }
26654 : }
26655 : else
26656 : {
26657 0 : std::cout << "SgOmpDistScheduleClause :: " << std::flush;
26658 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
26659 0 : std::cout << " not valid " << std::endl;
26660 : }
26661 : }
26662 :
26663 :
26664 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26665 :
26666 0 : }
26667 :
26668 :
26669 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
26670 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
26671 : bool
26672 0 : SgOmpDistScheduleClause::isInMemoryPool ()
26673 : {
26674 0 : typedef unsigned char* TestType;
26675 :
26676 0 : bool found = false;
26677 :
26678 0 : ROSE_ASSERT(this != NULL);
26679 :
26680 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
26681 :
26682 0 : TestType tested = (TestType) ( this ) ;
26683 :
26684 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDistScheduleClause::pools.begin();
26685 :
26686 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
26687 : // while (found == false && block < Memory_Block_List.end())
26688 0 : while ( (found == false) && (block != SgOmpDistScheduleClause::pools.end()) )
26689 : {
26690 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDistScheduleClause::pool_size * sizeof(SgOmpDistScheduleClause) ) ) ;
26691 0 : ++block;
26692 : }
26693 :
26694 : // Special handling for static data
26695 :
26696 :
26697 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
26698 0 : ROSE_ASSERT(found == true);
26699 :
26700 0 : return found;
26701 : }
26702 : /* #line 26703 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
26703 :
26704 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
26705 :
26706 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26707 :
26708 : /* #line 26709 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
26709 :
26710 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26711 :
26712 : void
26713 0 : SgOmpExpressionClause::checkDataMemberPointersIfInMemoryPool()
26714 : {
26715 : // ------------ checking pointers of SgOmpExpressionClause -------------------
26716 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
26717 :
26718 0 : if ( p_expression != NULL )
26719 : {
26720 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26721 : {
26722 0 : if ( p_expression->isInMemoryPool() == false )
26723 : {
26724 0 : std::cout << "SgOmpExpressionClause :: ";
26725 0 : std::cout << " p_expression is not in memory pool of ";
26726 0 : std::cout << p_expression->class_name() << std::endl;
26727 : }
26728 : }
26729 : else
26730 : {
26731 0 : std::cout << "SgOmpExpressionClause :: " << std::flush;
26732 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
26733 0 : std::cout << " not valid " << std::endl;
26734 : }
26735 : }
26736 :
26737 0 : if ( p_startOfConstruct != NULL )
26738 : {
26739 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26740 : {
26741 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
26742 : {
26743 0 : std::cout << "SgOmpExpressionClause :: ";
26744 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
26745 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
26746 : }
26747 : }
26748 : else
26749 : {
26750 0 : std::cout << "SgOmpExpressionClause :: " << std::flush;
26751 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
26752 0 : std::cout << " not valid " << std::endl;
26753 : }
26754 : }
26755 :
26756 0 : if ( p_endOfConstruct != NULL )
26757 : {
26758 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26759 : {
26760 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
26761 : {
26762 0 : std::cout << "SgOmpExpressionClause :: ";
26763 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
26764 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
26765 : }
26766 : }
26767 : else
26768 : {
26769 0 : std::cout << "SgOmpExpressionClause :: " << std::flush;
26770 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
26771 0 : std::cout << " not valid " << std::endl;
26772 : }
26773 : }
26774 :
26775 0 : if ( p_parent != NULL )
26776 : {
26777 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26778 : {
26779 0 : if ( p_parent->isInMemoryPool() == false )
26780 : {
26781 0 : std::cout << "SgOmpExpressionClause :: ";
26782 0 : std::cout << " p_parent is not in memory pool of ";
26783 0 : std::cout << p_parent->class_name() << std::endl;
26784 : }
26785 : }
26786 : else
26787 : {
26788 0 : std::cout << "SgOmpExpressionClause :: " << std::flush;
26789 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
26790 0 : std::cout << " not valid " << std::endl;
26791 : }
26792 : }
26793 :
26794 :
26795 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26796 :
26797 0 : }
26798 :
26799 :
26800 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
26801 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
26802 : bool
26803 0 : SgOmpExpressionClause::isInMemoryPool ()
26804 : {
26805 0 : typedef unsigned char* TestType;
26806 :
26807 0 : bool found = false;
26808 :
26809 0 : ROSE_ASSERT(this != NULL);
26810 :
26811 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
26812 :
26813 0 : TestType tested = (TestType) ( this ) ;
26814 :
26815 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpExpressionClause::pools.begin();
26816 :
26817 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
26818 : // while (found == false && block < Memory_Block_List.end())
26819 0 : while ( (found == false) && (block != SgOmpExpressionClause::pools.end()) )
26820 : {
26821 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpExpressionClause::pool_size * sizeof(SgOmpExpressionClause) ) ) ;
26822 0 : ++block;
26823 : }
26824 :
26825 : // Special handling for static data
26826 :
26827 :
26828 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
26829 0 : ROSE_ASSERT(found == true);
26830 :
26831 0 : return found;
26832 : }
26833 : /* #line 26834 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
26834 :
26835 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
26836 :
26837 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26838 :
26839 : /* #line 26840 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
26840 :
26841 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26842 :
26843 : void
26844 0 : SgOmpOrderedClause::checkDataMemberPointersIfInMemoryPool()
26845 : {
26846 : // ------------ checking pointers of SgOmpOrderedClause -------------------
26847 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
26848 :
26849 0 : if ( p_expression != NULL )
26850 : {
26851 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26852 : {
26853 0 : if ( p_expression->isInMemoryPool() == false )
26854 : {
26855 0 : std::cout << "SgOmpOrderedClause :: ";
26856 0 : std::cout << " p_expression is not in memory pool of ";
26857 0 : std::cout << p_expression->class_name() << std::endl;
26858 : }
26859 : }
26860 : else
26861 : {
26862 0 : std::cout << "SgOmpOrderedClause :: " << std::flush;
26863 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
26864 0 : std::cout << " not valid " << std::endl;
26865 : }
26866 : }
26867 :
26868 0 : if ( p_startOfConstruct != NULL )
26869 : {
26870 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26871 : {
26872 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
26873 : {
26874 0 : std::cout << "SgOmpOrderedClause :: ";
26875 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
26876 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
26877 : }
26878 : }
26879 : else
26880 : {
26881 0 : std::cout << "SgOmpOrderedClause :: " << std::flush;
26882 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
26883 0 : std::cout << " not valid " << std::endl;
26884 : }
26885 : }
26886 :
26887 0 : if ( p_endOfConstruct != NULL )
26888 : {
26889 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26890 : {
26891 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
26892 : {
26893 0 : std::cout << "SgOmpOrderedClause :: ";
26894 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
26895 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
26896 : }
26897 : }
26898 : else
26899 : {
26900 0 : std::cout << "SgOmpOrderedClause :: " << std::flush;
26901 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
26902 0 : std::cout << " not valid " << std::endl;
26903 : }
26904 : }
26905 :
26906 0 : if ( p_parent != NULL )
26907 : {
26908 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26909 : {
26910 0 : if ( p_parent->isInMemoryPool() == false )
26911 : {
26912 0 : std::cout << "SgOmpOrderedClause :: ";
26913 0 : std::cout << " p_parent is not in memory pool of ";
26914 0 : std::cout << p_parent->class_name() << std::endl;
26915 : }
26916 : }
26917 : else
26918 : {
26919 0 : std::cout << "SgOmpOrderedClause :: " << std::flush;
26920 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
26921 0 : std::cout << " not valid " << std::endl;
26922 : }
26923 : }
26924 :
26925 :
26926 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26927 :
26928 0 : }
26929 :
26930 :
26931 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
26932 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
26933 : bool
26934 0 : SgOmpOrderedClause::isInMemoryPool ()
26935 : {
26936 0 : typedef unsigned char* TestType;
26937 :
26938 0 : bool found = false;
26939 :
26940 0 : ROSE_ASSERT(this != NULL);
26941 :
26942 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
26943 :
26944 0 : TestType tested = (TestType) ( this ) ;
26945 :
26946 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpOrderedClause::pools.begin();
26947 :
26948 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
26949 : // while (found == false && block < Memory_Block_List.end())
26950 0 : while ( (found == false) && (block != SgOmpOrderedClause::pools.end()) )
26951 : {
26952 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpOrderedClause::pool_size * sizeof(SgOmpOrderedClause) ) ) ;
26953 0 : ++block;
26954 : }
26955 :
26956 : // Special handling for static data
26957 :
26958 :
26959 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
26960 0 : ROSE_ASSERT(found == true);
26961 :
26962 0 : return found;
26963 : }
26964 : /* #line 26965 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
26965 :
26966 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
26967 :
26968 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26969 :
26970 : /* #line 26971 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
26971 :
26972 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
26973 :
26974 : void
26975 0 : SgOmpCollapseClause::checkDataMemberPointersIfInMemoryPool()
26976 : {
26977 : // ------------ checking pointers of SgOmpCollapseClause -------------------
26978 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
26979 :
26980 0 : if ( p_expression != NULL )
26981 : {
26982 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
26983 : {
26984 0 : if ( p_expression->isInMemoryPool() == false )
26985 : {
26986 0 : std::cout << "SgOmpCollapseClause :: ";
26987 0 : std::cout << " p_expression is not in memory pool of ";
26988 0 : std::cout << p_expression->class_name() << std::endl;
26989 : }
26990 : }
26991 : else
26992 : {
26993 0 : std::cout << "SgOmpCollapseClause :: " << std::flush;
26994 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
26995 0 : std::cout << " not valid " << std::endl;
26996 : }
26997 : }
26998 :
26999 0 : if ( p_startOfConstruct != NULL )
27000 : {
27001 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27002 : {
27003 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
27004 : {
27005 0 : std::cout << "SgOmpCollapseClause :: ";
27006 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
27007 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
27008 : }
27009 : }
27010 : else
27011 : {
27012 0 : std::cout << "SgOmpCollapseClause :: " << std::flush;
27013 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
27014 0 : std::cout << " not valid " << std::endl;
27015 : }
27016 : }
27017 :
27018 0 : if ( p_endOfConstruct != NULL )
27019 : {
27020 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27021 : {
27022 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
27023 : {
27024 0 : std::cout << "SgOmpCollapseClause :: ";
27025 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
27026 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
27027 : }
27028 : }
27029 : else
27030 : {
27031 0 : std::cout << "SgOmpCollapseClause :: " << std::flush;
27032 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
27033 0 : std::cout << " not valid " << std::endl;
27034 : }
27035 : }
27036 :
27037 0 : if ( p_parent != NULL )
27038 : {
27039 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27040 : {
27041 0 : if ( p_parent->isInMemoryPool() == false )
27042 : {
27043 0 : std::cout << "SgOmpCollapseClause :: ";
27044 0 : std::cout << " p_parent is not in memory pool of ";
27045 0 : std::cout << p_parent->class_name() << std::endl;
27046 : }
27047 : }
27048 : else
27049 : {
27050 0 : std::cout << "SgOmpCollapseClause :: " << std::flush;
27051 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
27052 0 : std::cout << " not valid " << std::endl;
27053 : }
27054 : }
27055 :
27056 :
27057 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27058 :
27059 0 : }
27060 :
27061 :
27062 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
27063 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
27064 : bool
27065 0 : SgOmpCollapseClause::isInMemoryPool ()
27066 : {
27067 0 : typedef unsigned char* TestType;
27068 :
27069 0 : bool found = false;
27070 :
27071 0 : ROSE_ASSERT(this != NULL);
27072 :
27073 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
27074 :
27075 0 : TestType tested = (TestType) ( this ) ;
27076 :
27077 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpCollapseClause::pools.begin();
27078 :
27079 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
27080 : // while (found == false && block < Memory_Block_List.end())
27081 0 : while ( (found == false) && (block != SgOmpCollapseClause::pools.end()) )
27082 : {
27083 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpCollapseClause::pool_size * sizeof(SgOmpCollapseClause) ) ) ;
27084 0 : ++block;
27085 : }
27086 :
27087 : // Special handling for static data
27088 :
27089 :
27090 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
27091 0 : ROSE_ASSERT(found == true);
27092 :
27093 0 : return found;
27094 : }
27095 : /* #line 27096 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
27096 :
27097 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
27098 :
27099 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27100 :
27101 : /* #line 27102 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
27102 :
27103 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27104 :
27105 : void
27106 0 : SgOmpIfClause::checkDataMemberPointersIfInMemoryPool()
27107 : {
27108 : // ------------ checking pointers of SgOmpIfClause -------------------
27109 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
27110 :
27111 0 : if ( p_expression != NULL )
27112 : {
27113 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27114 : {
27115 0 : if ( p_expression->isInMemoryPool() == false )
27116 : {
27117 0 : std::cout << "SgOmpIfClause :: ";
27118 0 : std::cout << " p_expression is not in memory pool of ";
27119 0 : std::cout << p_expression->class_name() << std::endl;
27120 : }
27121 : }
27122 : else
27123 : {
27124 0 : std::cout << "SgOmpIfClause :: " << std::flush;
27125 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
27126 0 : std::cout << " not valid " << std::endl;
27127 : }
27128 : }
27129 :
27130 0 : if ( p_startOfConstruct != NULL )
27131 : {
27132 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27133 : {
27134 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
27135 : {
27136 0 : std::cout << "SgOmpIfClause :: ";
27137 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
27138 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
27139 : }
27140 : }
27141 : else
27142 : {
27143 0 : std::cout << "SgOmpIfClause :: " << std::flush;
27144 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
27145 0 : std::cout << " not valid " << std::endl;
27146 : }
27147 : }
27148 :
27149 0 : if ( p_endOfConstruct != NULL )
27150 : {
27151 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27152 : {
27153 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
27154 : {
27155 0 : std::cout << "SgOmpIfClause :: ";
27156 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
27157 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
27158 : }
27159 : }
27160 : else
27161 : {
27162 0 : std::cout << "SgOmpIfClause :: " << std::flush;
27163 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
27164 0 : std::cout << " not valid " << std::endl;
27165 : }
27166 : }
27167 :
27168 0 : if ( p_parent != NULL )
27169 : {
27170 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27171 : {
27172 0 : if ( p_parent->isInMemoryPool() == false )
27173 : {
27174 0 : std::cout << "SgOmpIfClause :: ";
27175 0 : std::cout << " p_parent is not in memory pool of ";
27176 0 : std::cout << p_parent->class_name() << std::endl;
27177 : }
27178 : }
27179 : else
27180 : {
27181 0 : std::cout << "SgOmpIfClause :: " << std::flush;
27182 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
27183 0 : std::cout << " not valid " << std::endl;
27184 : }
27185 : }
27186 :
27187 :
27188 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27189 :
27190 0 : }
27191 :
27192 :
27193 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
27194 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
27195 : bool
27196 0 : SgOmpIfClause::isInMemoryPool ()
27197 : {
27198 0 : typedef unsigned char* TestType;
27199 :
27200 0 : bool found = false;
27201 :
27202 0 : ROSE_ASSERT(this != NULL);
27203 :
27204 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
27205 :
27206 0 : TestType tested = (TestType) ( this ) ;
27207 :
27208 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpIfClause::pools.begin();
27209 :
27210 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
27211 : // while (found == false && block < Memory_Block_List.end())
27212 0 : while ( (found == false) && (block != SgOmpIfClause::pools.end()) )
27213 : {
27214 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpIfClause::pool_size * sizeof(SgOmpIfClause) ) ) ;
27215 0 : ++block;
27216 : }
27217 :
27218 : // Special handling for static data
27219 :
27220 :
27221 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
27222 0 : ROSE_ASSERT(found == true);
27223 :
27224 0 : return found;
27225 : }
27226 : /* #line 27227 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
27227 :
27228 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
27229 :
27230 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27231 :
27232 : /* #line 27233 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
27233 :
27234 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27235 :
27236 : void
27237 0 : SgUpirNumUnitsField::checkDataMemberPointersIfInMemoryPool()
27238 : {
27239 : // ------------ checking pointers of SgUpirNumUnitsField -------------------
27240 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
27241 :
27242 0 : if ( p_expression != NULL )
27243 : {
27244 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27245 : {
27246 0 : if ( p_expression->isInMemoryPool() == false )
27247 : {
27248 0 : std::cout << "SgUpirNumUnitsField :: ";
27249 0 : std::cout << " p_expression is not in memory pool of ";
27250 0 : std::cout << p_expression->class_name() << std::endl;
27251 : }
27252 : }
27253 : else
27254 : {
27255 0 : std::cout << "SgUpirNumUnitsField :: " << std::flush;
27256 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
27257 0 : std::cout << " not valid " << std::endl;
27258 : }
27259 : }
27260 :
27261 0 : if ( p_startOfConstruct != NULL )
27262 : {
27263 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27264 : {
27265 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
27266 : {
27267 0 : std::cout << "SgUpirNumUnitsField :: ";
27268 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
27269 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
27270 : }
27271 : }
27272 : else
27273 : {
27274 0 : std::cout << "SgUpirNumUnitsField :: " << std::flush;
27275 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
27276 0 : std::cout << " not valid " << std::endl;
27277 : }
27278 : }
27279 :
27280 0 : if ( p_endOfConstruct != NULL )
27281 : {
27282 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27283 : {
27284 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
27285 : {
27286 0 : std::cout << "SgUpirNumUnitsField :: ";
27287 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
27288 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
27289 : }
27290 : }
27291 : else
27292 : {
27293 0 : std::cout << "SgUpirNumUnitsField :: " << std::flush;
27294 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
27295 0 : std::cout << " not valid " << std::endl;
27296 : }
27297 : }
27298 :
27299 0 : if ( p_parent != NULL )
27300 : {
27301 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27302 : {
27303 0 : if ( p_parent->isInMemoryPool() == false )
27304 : {
27305 0 : std::cout << "SgUpirNumUnitsField :: ";
27306 0 : std::cout << " p_parent is not in memory pool of ";
27307 0 : std::cout << p_parent->class_name() << std::endl;
27308 : }
27309 : }
27310 : else
27311 : {
27312 0 : std::cout << "SgUpirNumUnitsField :: " << std::flush;
27313 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
27314 0 : std::cout << " not valid " << std::endl;
27315 : }
27316 : }
27317 :
27318 :
27319 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27320 :
27321 0 : }
27322 :
27323 :
27324 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
27325 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
27326 : bool
27327 0 : SgUpirNumUnitsField::isInMemoryPool ()
27328 : {
27329 0 : typedef unsigned char* TestType;
27330 :
27331 0 : bool found = false;
27332 :
27333 0 : ROSE_ASSERT(this != NULL);
27334 :
27335 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
27336 :
27337 0 : TestType tested = (TestType) ( this ) ;
27338 :
27339 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirNumUnitsField::pools.begin();
27340 :
27341 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
27342 : // while (found == false && block < Memory_Block_List.end())
27343 0 : while ( (found == false) && (block != SgUpirNumUnitsField::pools.end()) )
27344 : {
27345 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirNumUnitsField::pool_size * sizeof(SgUpirNumUnitsField) ) ) ;
27346 0 : ++block;
27347 : }
27348 :
27349 : // Special handling for static data
27350 :
27351 :
27352 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
27353 0 : ROSE_ASSERT(found == true);
27354 :
27355 0 : return found;
27356 : }
27357 : /* #line 27358 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
27358 :
27359 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
27360 :
27361 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27362 :
27363 : /* #line 27364 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
27364 :
27365 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27366 :
27367 : void
27368 0 : SgOmpNumTeamsClause::checkDataMemberPointersIfInMemoryPool()
27369 : {
27370 : // ------------ checking pointers of SgOmpNumTeamsClause -------------------
27371 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
27372 :
27373 0 : if ( p_expression != NULL )
27374 : {
27375 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27376 : {
27377 0 : if ( p_expression->isInMemoryPool() == false )
27378 : {
27379 0 : std::cout << "SgOmpNumTeamsClause :: ";
27380 0 : std::cout << " p_expression is not in memory pool of ";
27381 0 : std::cout << p_expression->class_name() << std::endl;
27382 : }
27383 : }
27384 : else
27385 : {
27386 0 : std::cout << "SgOmpNumTeamsClause :: " << std::flush;
27387 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
27388 0 : std::cout << " not valid " << std::endl;
27389 : }
27390 : }
27391 :
27392 0 : if ( p_startOfConstruct != NULL )
27393 : {
27394 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27395 : {
27396 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
27397 : {
27398 0 : std::cout << "SgOmpNumTeamsClause :: ";
27399 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
27400 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
27401 : }
27402 : }
27403 : else
27404 : {
27405 0 : std::cout << "SgOmpNumTeamsClause :: " << std::flush;
27406 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
27407 0 : std::cout << " not valid " << std::endl;
27408 : }
27409 : }
27410 :
27411 0 : if ( p_endOfConstruct != NULL )
27412 : {
27413 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27414 : {
27415 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
27416 : {
27417 0 : std::cout << "SgOmpNumTeamsClause :: ";
27418 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
27419 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
27420 : }
27421 : }
27422 : else
27423 : {
27424 0 : std::cout << "SgOmpNumTeamsClause :: " << std::flush;
27425 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
27426 0 : std::cout << " not valid " << std::endl;
27427 : }
27428 : }
27429 :
27430 0 : if ( p_parent != NULL )
27431 : {
27432 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27433 : {
27434 0 : if ( p_parent->isInMemoryPool() == false )
27435 : {
27436 0 : std::cout << "SgOmpNumTeamsClause :: ";
27437 0 : std::cout << " p_parent is not in memory pool of ";
27438 0 : std::cout << p_parent->class_name() << std::endl;
27439 : }
27440 : }
27441 : else
27442 : {
27443 0 : std::cout << "SgOmpNumTeamsClause :: " << std::flush;
27444 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
27445 0 : std::cout << " not valid " << std::endl;
27446 : }
27447 : }
27448 :
27449 :
27450 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27451 :
27452 0 : }
27453 :
27454 :
27455 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
27456 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
27457 : bool
27458 0 : SgOmpNumTeamsClause::isInMemoryPool ()
27459 : {
27460 0 : typedef unsigned char* TestType;
27461 :
27462 0 : bool found = false;
27463 :
27464 0 : ROSE_ASSERT(this != NULL);
27465 :
27466 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
27467 :
27468 0 : TestType tested = (TestType) ( this ) ;
27469 :
27470 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpNumTeamsClause::pools.begin();
27471 :
27472 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
27473 : // while (found == false && block < Memory_Block_List.end())
27474 0 : while ( (found == false) && (block != SgOmpNumTeamsClause::pools.end()) )
27475 : {
27476 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpNumTeamsClause::pool_size * sizeof(SgOmpNumTeamsClause) ) ) ;
27477 0 : ++block;
27478 : }
27479 :
27480 : // Special handling for static data
27481 :
27482 :
27483 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
27484 0 : ROSE_ASSERT(found == true);
27485 :
27486 0 : return found;
27487 : }
27488 : /* #line 27489 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
27489 :
27490 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
27491 :
27492 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27493 :
27494 : /* #line 27495 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
27495 :
27496 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27497 :
27498 : void
27499 0 : SgOmpThreadLimitClause::checkDataMemberPointersIfInMemoryPool()
27500 : {
27501 : // ------------ checking pointers of SgOmpThreadLimitClause -------------------
27502 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
27503 :
27504 0 : if ( p_expression != NULL )
27505 : {
27506 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27507 : {
27508 0 : if ( p_expression->isInMemoryPool() == false )
27509 : {
27510 0 : std::cout << "SgOmpThreadLimitClause :: ";
27511 0 : std::cout << " p_expression is not in memory pool of ";
27512 0 : std::cout << p_expression->class_name() << std::endl;
27513 : }
27514 : }
27515 : else
27516 : {
27517 0 : std::cout << "SgOmpThreadLimitClause :: " << std::flush;
27518 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
27519 0 : std::cout << " not valid " << std::endl;
27520 : }
27521 : }
27522 :
27523 0 : if ( p_startOfConstruct != NULL )
27524 : {
27525 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27526 : {
27527 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
27528 : {
27529 0 : std::cout << "SgOmpThreadLimitClause :: ";
27530 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
27531 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
27532 : }
27533 : }
27534 : else
27535 : {
27536 0 : std::cout << "SgOmpThreadLimitClause :: " << std::flush;
27537 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
27538 0 : std::cout << " not valid " << std::endl;
27539 : }
27540 : }
27541 :
27542 0 : if ( p_endOfConstruct != NULL )
27543 : {
27544 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27545 : {
27546 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
27547 : {
27548 0 : std::cout << "SgOmpThreadLimitClause :: ";
27549 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
27550 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
27551 : }
27552 : }
27553 : else
27554 : {
27555 0 : std::cout << "SgOmpThreadLimitClause :: " << std::flush;
27556 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
27557 0 : std::cout << " not valid " << std::endl;
27558 : }
27559 : }
27560 :
27561 0 : if ( p_parent != NULL )
27562 : {
27563 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27564 : {
27565 0 : if ( p_parent->isInMemoryPool() == false )
27566 : {
27567 0 : std::cout << "SgOmpThreadLimitClause :: ";
27568 0 : std::cout << " p_parent is not in memory pool of ";
27569 0 : std::cout << p_parent->class_name() << std::endl;
27570 : }
27571 : }
27572 : else
27573 : {
27574 0 : std::cout << "SgOmpThreadLimitClause :: " << std::flush;
27575 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
27576 0 : std::cout << " not valid " << std::endl;
27577 : }
27578 : }
27579 :
27580 :
27581 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27582 :
27583 0 : }
27584 :
27585 :
27586 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
27587 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
27588 : bool
27589 0 : SgOmpThreadLimitClause::isInMemoryPool ()
27590 : {
27591 0 : typedef unsigned char* TestType;
27592 :
27593 0 : bool found = false;
27594 :
27595 0 : ROSE_ASSERT(this != NULL);
27596 :
27597 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
27598 :
27599 0 : TestType tested = (TestType) ( this ) ;
27600 :
27601 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpThreadLimitClause::pools.begin();
27602 :
27603 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
27604 : // while (found == false && block < Memory_Block_List.end())
27605 0 : while ( (found == false) && (block != SgOmpThreadLimitClause::pools.end()) )
27606 : {
27607 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpThreadLimitClause::pool_size * sizeof(SgOmpThreadLimitClause) ) ) ;
27608 0 : ++block;
27609 : }
27610 :
27611 : // Special handling for static data
27612 :
27613 :
27614 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
27615 0 : ROSE_ASSERT(found == true);
27616 :
27617 0 : return found;
27618 : }
27619 : /* #line 27620 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
27620 :
27621 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
27622 :
27623 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27624 :
27625 : /* #line 27626 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
27626 :
27627 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27628 :
27629 : void
27630 0 : SgOmpDeviceClause::checkDataMemberPointersIfInMemoryPool()
27631 : {
27632 : // ------------ checking pointers of SgOmpDeviceClause -------------------
27633 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
27634 :
27635 0 : if ( p_expression != NULL )
27636 : {
27637 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27638 : {
27639 0 : if ( p_expression->isInMemoryPool() == false )
27640 : {
27641 0 : std::cout << "SgOmpDeviceClause :: ";
27642 0 : std::cout << " p_expression is not in memory pool of ";
27643 0 : std::cout << p_expression->class_name() << std::endl;
27644 : }
27645 : }
27646 : else
27647 : {
27648 0 : std::cout << "SgOmpDeviceClause :: " << std::flush;
27649 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
27650 0 : std::cout << " not valid " << std::endl;
27651 : }
27652 : }
27653 :
27654 0 : if ( p_startOfConstruct != NULL )
27655 : {
27656 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27657 : {
27658 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
27659 : {
27660 0 : std::cout << "SgOmpDeviceClause :: ";
27661 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
27662 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
27663 : }
27664 : }
27665 : else
27666 : {
27667 0 : std::cout << "SgOmpDeviceClause :: " << std::flush;
27668 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
27669 0 : std::cout << " not valid " << std::endl;
27670 : }
27671 : }
27672 :
27673 0 : if ( p_endOfConstruct != NULL )
27674 : {
27675 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27676 : {
27677 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
27678 : {
27679 0 : std::cout << "SgOmpDeviceClause :: ";
27680 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
27681 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
27682 : }
27683 : }
27684 : else
27685 : {
27686 0 : std::cout << "SgOmpDeviceClause :: " << std::flush;
27687 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
27688 0 : std::cout << " not valid " << std::endl;
27689 : }
27690 : }
27691 :
27692 0 : if ( p_parent != NULL )
27693 : {
27694 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27695 : {
27696 0 : if ( p_parent->isInMemoryPool() == false )
27697 : {
27698 0 : std::cout << "SgOmpDeviceClause :: ";
27699 0 : std::cout << " p_parent is not in memory pool of ";
27700 0 : std::cout << p_parent->class_name() << std::endl;
27701 : }
27702 : }
27703 : else
27704 : {
27705 0 : std::cout << "SgOmpDeviceClause :: " << std::flush;
27706 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
27707 0 : std::cout << " not valid " << std::endl;
27708 : }
27709 : }
27710 :
27711 :
27712 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27713 :
27714 0 : }
27715 :
27716 :
27717 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
27718 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
27719 : bool
27720 0 : SgOmpDeviceClause::isInMemoryPool ()
27721 : {
27722 0 : typedef unsigned char* TestType;
27723 :
27724 0 : bool found = false;
27725 :
27726 0 : ROSE_ASSERT(this != NULL);
27727 :
27728 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
27729 :
27730 0 : TestType tested = (TestType) ( this ) ;
27731 :
27732 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDeviceClause::pools.begin();
27733 :
27734 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
27735 : // while (found == false && block < Memory_Block_List.end())
27736 0 : while ( (found == false) && (block != SgOmpDeviceClause::pools.end()) )
27737 : {
27738 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDeviceClause::pool_size * sizeof(SgOmpDeviceClause) ) ) ;
27739 0 : ++block;
27740 : }
27741 :
27742 : // Special handling for static data
27743 :
27744 :
27745 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
27746 0 : ROSE_ASSERT(found == true);
27747 :
27748 0 : return found;
27749 : }
27750 : /* #line 27751 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
27751 :
27752 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
27753 :
27754 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27755 :
27756 : /* #line 27757 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
27757 :
27758 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27759 :
27760 : void
27761 0 : SgOmpHintClause::checkDataMemberPointersIfInMemoryPool()
27762 : {
27763 : // ------------ checking pointers of SgOmpHintClause -------------------
27764 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
27765 :
27766 0 : if ( p_expression != NULL )
27767 : {
27768 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27769 : {
27770 0 : if ( p_expression->isInMemoryPool() == false )
27771 : {
27772 0 : std::cout << "SgOmpHintClause :: ";
27773 0 : std::cout << " p_expression is not in memory pool of ";
27774 0 : std::cout << p_expression->class_name() << std::endl;
27775 : }
27776 : }
27777 : else
27778 : {
27779 0 : std::cout << "SgOmpHintClause :: " << std::flush;
27780 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
27781 0 : std::cout << " not valid " << std::endl;
27782 : }
27783 : }
27784 :
27785 0 : if ( p_startOfConstruct != NULL )
27786 : {
27787 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27788 : {
27789 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
27790 : {
27791 0 : std::cout << "SgOmpHintClause :: ";
27792 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
27793 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
27794 : }
27795 : }
27796 : else
27797 : {
27798 0 : std::cout << "SgOmpHintClause :: " << std::flush;
27799 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
27800 0 : std::cout << " not valid " << std::endl;
27801 : }
27802 : }
27803 :
27804 0 : if ( p_endOfConstruct != NULL )
27805 : {
27806 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27807 : {
27808 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
27809 : {
27810 0 : std::cout << "SgOmpHintClause :: ";
27811 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
27812 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
27813 : }
27814 : }
27815 : else
27816 : {
27817 0 : std::cout << "SgOmpHintClause :: " << std::flush;
27818 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
27819 0 : std::cout << " not valid " << std::endl;
27820 : }
27821 : }
27822 :
27823 0 : if ( p_parent != NULL )
27824 : {
27825 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27826 : {
27827 0 : if ( p_parent->isInMemoryPool() == false )
27828 : {
27829 0 : std::cout << "SgOmpHintClause :: ";
27830 0 : std::cout << " p_parent is not in memory pool of ";
27831 0 : std::cout << p_parent->class_name() << std::endl;
27832 : }
27833 : }
27834 : else
27835 : {
27836 0 : std::cout << "SgOmpHintClause :: " << std::flush;
27837 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
27838 0 : std::cout << " not valid " << std::endl;
27839 : }
27840 : }
27841 :
27842 :
27843 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27844 :
27845 0 : }
27846 :
27847 :
27848 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
27849 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
27850 : bool
27851 0 : SgOmpHintClause::isInMemoryPool ()
27852 : {
27853 0 : typedef unsigned char* TestType;
27854 :
27855 0 : bool found = false;
27856 :
27857 0 : ROSE_ASSERT(this != NULL);
27858 :
27859 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
27860 :
27861 0 : TestType tested = (TestType) ( this ) ;
27862 :
27863 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpHintClause::pools.begin();
27864 :
27865 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
27866 : // while (found == false && block < Memory_Block_List.end())
27867 0 : while ( (found == false) && (block != SgOmpHintClause::pools.end()) )
27868 : {
27869 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpHintClause::pool_size * sizeof(SgOmpHintClause) ) ) ;
27870 0 : ++block;
27871 : }
27872 :
27873 : // Special handling for static data
27874 :
27875 :
27876 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
27877 0 : ROSE_ASSERT(found == true);
27878 :
27879 0 : return found;
27880 : }
27881 : /* #line 27882 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
27882 :
27883 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
27884 :
27885 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27886 :
27887 : /* #line 27888 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
27888 :
27889 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27890 :
27891 : void
27892 0 : SgOmpGrainsizeClause::checkDataMemberPointersIfInMemoryPool()
27893 : {
27894 : // ------------ checking pointers of SgOmpGrainsizeClause -------------------
27895 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
27896 :
27897 0 : if ( p_expression != NULL )
27898 : {
27899 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27900 : {
27901 0 : if ( p_expression->isInMemoryPool() == false )
27902 : {
27903 0 : std::cout << "SgOmpGrainsizeClause :: ";
27904 0 : std::cout << " p_expression is not in memory pool of ";
27905 0 : std::cout << p_expression->class_name() << std::endl;
27906 : }
27907 : }
27908 : else
27909 : {
27910 0 : std::cout << "SgOmpGrainsizeClause :: " << std::flush;
27911 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
27912 0 : std::cout << " not valid " << std::endl;
27913 : }
27914 : }
27915 :
27916 0 : if ( p_startOfConstruct != NULL )
27917 : {
27918 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27919 : {
27920 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
27921 : {
27922 0 : std::cout << "SgOmpGrainsizeClause :: ";
27923 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
27924 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
27925 : }
27926 : }
27927 : else
27928 : {
27929 0 : std::cout << "SgOmpGrainsizeClause :: " << std::flush;
27930 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
27931 0 : std::cout << " not valid " << std::endl;
27932 : }
27933 : }
27934 :
27935 0 : if ( p_endOfConstruct != NULL )
27936 : {
27937 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27938 : {
27939 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
27940 : {
27941 0 : std::cout << "SgOmpGrainsizeClause :: ";
27942 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
27943 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
27944 : }
27945 : }
27946 : else
27947 : {
27948 0 : std::cout << "SgOmpGrainsizeClause :: " << std::flush;
27949 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
27950 0 : std::cout << " not valid " << std::endl;
27951 : }
27952 : }
27953 :
27954 0 : if ( p_parent != NULL )
27955 : {
27956 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
27957 : {
27958 0 : if ( p_parent->isInMemoryPool() == false )
27959 : {
27960 0 : std::cout << "SgOmpGrainsizeClause :: ";
27961 0 : std::cout << " p_parent is not in memory pool of ";
27962 0 : std::cout << p_parent->class_name() << std::endl;
27963 : }
27964 : }
27965 : else
27966 : {
27967 0 : std::cout << "SgOmpGrainsizeClause :: " << std::flush;
27968 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
27969 0 : std::cout << " not valid " << std::endl;
27970 : }
27971 : }
27972 :
27973 :
27974 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
27975 :
27976 0 : }
27977 :
27978 :
27979 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
27980 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
27981 : bool
27982 0 : SgOmpGrainsizeClause::isInMemoryPool ()
27983 : {
27984 0 : typedef unsigned char* TestType;
27985 :
27986 0 : bool found = false;
27987 :
27988 0 : ROSE_ASSERT(this != NULL);
27989 :
27990 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
27991 :
27992 0 : TestType tested = (TestType) ( this ) ;
27993 :
27994 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpGrainsizeClause::pools.begin();
27995 :
27996 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
27997 : // while (found == false && block < Memory_Block_List.end())
27998 0 : while ( (found == false) && (block != SgOmpGrainsizeClause::pools.end()) )
27999 : {
28000 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpGrainsizeClause::pool_size * sizeof(SgOmpGrainsizeClause) ) ) ;
28001 0 : ++block;
28002 : }
28003 :
28004 : // Special handling for static data
28005 :
28006 :
28007 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
28008 0 : ROSE_ASSERT(found == true);
28009 :
28010 0 : return found;
28011 : }
28012 : /* #line 28013 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
28013 :
28014 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
28015 :
28016 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28017 :
28018 : /* #line 28019 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
28019 :
28020 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28021 :
28022 : void
28023 0 : SgOmpNumTasksClause::checkDataMemberPointersIfInMemoryPool()
28024 : {
28025 : // ------------ checking pointers of SgOmpNumTasksClause -------------------
28026 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
28027 :
28028 0 : if ( p_expression != NULL )
28029 : {
28030 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28031 : {
28032 0 : if ( p_expression->isInMemoryPool() == false )
28033 : {
28034 0 : std::cout << "SgOmpNumTasksClause :: ";
28035 0 : std::cout << " p_expression is not in memory pool of ";
28036 0 : std::cout << p_expression->class_name() << std::endl;
28037 : }
28038 : }
28039 : else
28040 : {
28041 0 : std::cout << "SgOmpNumTasksClause :: " << std::flush;
28042 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
28043 0 : std::cout << " not valid " << std::endl;
28044 : }
28045 : }
28046 :
28047 0 : if ( p_startOfConstruct != NULL )
28048 : {
28049 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28050 : {
28051 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
28052 : {
28053 0 : std::cout << "SgOmpNumTasksClause :: ";
28054 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
28055 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
28056 : }
28057 : }
28058 : else
28059 : {
28060 0 : std::cout << "SgOmpNumTasksClause :: " << std::flush;
28061 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
28062 0 : std::cout << " not valid " << std::endl;
28063 : }
28064 : }
28065 :
28066 0 : if ( p_endOfConstruct != NULL )
28067 : {
28068 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28069 : {
28070 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
28071 : {
28072 0 : std::cout << "SgOmpNumTasksClause :: ";
28073 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
28074 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
28075 : }
28076 : }
28077 : else
28078 : {
28079 0 : std::cout << "SgOmpNumTasksClause :: " << std::flush;
28080 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
28081 0 : std::cout << " not valid " << std::endl;
28082 : }
28083 : }
28084 :
28085 0 : if ( p_parent != NULL )
28086 : {
28087 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28088 : {
28089 0 : if ( p_parent->isInMemoryPool() == false )
28090 : {
28091 0 : std::cout << "SgOmpNumTasksClause :: ";
28092 0 : std::cout << " p_parent is not in memory pool of ";
28093 0 : std::cout << p_parent->class_name() << std::endl;
28094 : }
28095 : }
28096 : else
28097 : {
28098 0 : std::cout << "SgOmpNumTasksClause :: " << std::flush;
28099 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
28100 0 : std::cout << " not valid " << std::endl;
28101 : }
28102 : }
28103 :
28104 :
28105 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28106 :
28107 0 : }
28108 :
28109 :
28110 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
28111 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
28112 : bool
28113 0 : SgOmpNumTasksClause::isInMemoryPool ()
28114 : {
28115 0 : typedef unsigned char* TestType;
28116 :
28117 0 : bool found = false;
28118 :
28119 0 : ROSE_ASSERT(this != NULL);
28120 :
28121 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
28122 :
28123 0 : TestType tested = (TestType) ( this ) ;
28124 :
28125 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpNumTasksClause::pools.begin();
28126 :
28127 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
28128 : // while (found == false && block < Memory_Block_List.end())
28129 0 : while ( (found == false) && (block != SgOmpNumTasksClause::pools.end()) )
28130 : {
28131 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpNumTasksClause::pool_size * sizeof(SgOmpNumTasksClause) ) ) ;
28132 0 : ++block;
28133 : }
28134 :
28135 : // Special handling for static data
28136 :
28137 :
28138 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
28139 0 : ROSE_ASSERT(found == true);
28140 :
28141 0 : return found;
28142 : }
28143 : /* #line 28144 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
28144 :
28145 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
28146 :
28147 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28148 :
28149 : /* #line 28150 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
28150 :
28151 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28152 :
28153 : void
28154 0 : SgOmpDetachClause::checkDataMemberPointersIfInMemoryPool()
28155 : {
28156 : // ------------ checking pointers of SgOmpDetachClause -------------------
28157 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
28158 :
28159 0 : if ( p_expression != NULL )
28160 : {
28161 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28162 : {
28163 0 : if ( p_expression->isInMemoryPool() == false )
28164 : {
28165 0 : std::cout << "SgOmpDetachClause :: ";
28166 0 : std::cout << " p_expression is not in memory pool of ";
28167 0 : std::cout << p_expression->class_name() << std::endl;
28168 : }
28169 : }
28170 : else
28171 : {
28172 0 : std::cout << "SgOmpDetachClause :: " << std::flush;
28173 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
28174 0 : std::cout << " not valid " << std::endl;
28175 : }
28176 : }
28177 :
28178 0 : if ( p_startOfConstruct != NULL )
28179 : {
28180 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28181 : {
28182 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
28183 : {
28184 0 : std::cout << "SgOmpDetachClause :: ";
28185 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
28186 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
28187 : }
28188 : }
28189 : else
28190 : {
28191 0 : std::cout << "SgOmpDetachClause :: " << std::flush;
28192 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
28193 0 : std::cout << " not valid " << std::endl;
28194 : }
28195 : }
28196 :
28197 0 : if ( p_endOfConstruct != NULL )
28198 : {
28199 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28200 : {
28201 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
28202 : {
28203 0 : std::cout << "SgOmpDetachClause :: ";
28204 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
28205 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
28206 : }
28207 : }
28208 : else
28209 : {
28210 0 : std::cout << "SgOmpDetachClause :: " << std::flush;
28211 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
28212 0 : std::cout << " not valid " << std::endl;
28213 : }
28214 : }
28215 :
28216 0 : if ( p_parent != NULL )
28217 : {
28218 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28219 : {
28220 0 : if ( p_parent->isInMemoryPool() == false )
28221 : {
28222 0 : std::cout << "SgOmpDetachClause :: ";
28223 0 : std::cout << " p_parent is not in memory pool of ";
28224 0 : std::cout << p_parent->class_name() << std::endl;
28225 : }
28226 : }
28227 : else
28228 : {
28229 0 : std::cout << "SgOmpDetachClause :: " << std::flush;
28230 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
28231 0 : std::cout << " not valid " << std::endl;
28232 : }
28233 : }
28234 :
28235 :
28236 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28237 :
28238 0 : }
28239 :
28240 :
28241 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
28242 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
28243 : bool
28244 0 : SgOmpDetachClause::isInMemoryPool ()
28245 : {
28246 0 : typedef unsigned char* TestType;
28247 :
28248 0 : bool found = false;
28249 :
28250 0 : ROSE_ASSERT(this != NULL);
28251 :
28252 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
28253 :
28254 0 : TestType tested = (TestType) ( this ) ;
28255 :
28256 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDetachClause::pools.begin();
28257 :
28258 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
28259 : // while (found == false && block < Memory_Block_List.end())
28260 0 : while ( (found == false) && (block != SgOmpDetachClause::pools.end()) )
28261 : {
28262 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDetachClause::pool_size * sizeof(SgOmpDetachClause) ) ) ;
28263 0 : ++block;
28264 : }
28265 :
28266 : // Special handling for static data
28267 :
28268 :
28269 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
28270 0 : ROSE_ASSERT(found == true);
28271 :
28272 0 : return found;
28273 : }
28274 : /* #line 28275 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
28275 :
28276 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
28277 :
28278 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28279 :
28280 : /* #line 28281 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
28281 :
28282 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28283 :
28284 : void
28285 0 : SgOmpSafelenClause::checkDataMemberPointersIfInMemoryPool()
28286 : {
28287 : // ------------ checking pointers of SgOmpSafelenClause -------------------
28288 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
28289 :
28290 0 : if ( p_expression != NULL )
28291 : {
28292 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28293 : {
28294 0 : if ( p_expression->isInMemoryPool() == false )
28295 : {
28296 0 : std::cout << "SgOmpSafelenClause :: ";
28297 0 : std::cout << " p_expression is not in memory pool of ";
28298 0 : std::cout << p_expression->class_name() << std::endl;
28299 : }
28300 : }
28301 : else
28302 : {
28303 0 : std::cout << "SgOmpSafelenClause :: " << std::flush;
28304 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
28305 0 : std::cout << " not valid " << std::endl;
28306 : }
28307 : }
28308 :
28309 0 : if ( p_startOfConstruct != NULL )
28310 : {
28311 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28312 : {
28313 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
28314 : {
28315 0 : std::cout << "SgOmpSafelenClause :: ";
28316 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
28317 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
28318 : }
28319 : }
28320 : else
28321 : {
28322 0 : std::cout << "SgOmpSafelenClause :: " << std::flush;
28323 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
28324 0 : std::cout << " not valid " << std::endl;
28325 : }
28326 : }
28327 :
28328 0 : if ( p_endOfConstruct != NULL )
28329 : {
28330 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28331 : {
28332 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
28333 : {
28334 0 : std::cout << "SgOmpSafelenClause :: ";
28335 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
28336 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
28337 : }
28338 : }
28339 : else
28340 : {
28341 0 : std::cout << "SgOmpSafelenClause :: " << std::flush;
28342 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
28343 0 : std::cout << " not valid " << std::endl;
28344 : }
28345 : }
28346 :
28347 0 : if ( p_parent != NULL )
28348 : {
28349 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28350 : {
28351 0 : if ( p_parent->isInMemoryPool() == false )
28352 : {
28353 0 : std::cout << "SgOmpSafelenClause :: ";
28354 0 : std::cout << " p_parent is not in memory pool of ";
28355 0 : std::cout << p_parent->class_name() << std::endl;
28356 : }
28357 : }
28358 : else
28359 : {
28360 0 : std::cout << "SgOmpSafelenClause :: " << std::flush;
28361 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
28362 0 : std::cout << " not valid " << std::endl;
28363 : }
28364 : }
28365 :
28366 :
28367 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28368 :
28369 0 : }
28370 :
28371 :
28372 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
28373 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
28374 : bool
28375 0 : SgOmpSafelenClause::isInMemoryPool ()
28376 : {
28377 0 : typedef unsigned char* TestType;
28378 :
28379 0 : bool found = false;
28380 :
28381 0 : ROSE_ASSERT(this != NULL);
28382 :
28383 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
28384 :
28385 0 : TestType tested = (TestType) ( this ) ;
28386 :
28387 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpSafelenClause::pools.begin();
28388 :
28389 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
28390 : // while (found == false && block < Memory_Block_List.end())
28391 0 : while ( (found == false) && (block != SgOmpSafelenClause::pools.end()) )
28392 : {
28393 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpSafelenClause::pool_size * sizeof(SgOmpSafelenClause) ) ) ;
28394 0 : ++block;
28395 : }
28396 :
28397 : // Special handling for static data
28398 :
28399 :
28400 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
28401 0 : ROSE_ASSERT(found == true);
28402 :
28403 0 : return found;
28404 : }
28405 : /* #line 28406 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
28406 :
28407 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
28408 :
28409 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28410 :
28411 : /* #line 28412 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
28412 :
28413 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28414 :
28415 : void
28416 0 : SgOmpSimdlenClause::checkDataMemberPointersIfInMemoryPool()
28417 : {
28418 : // ------------ checking pointers of SgOmpSimdlenClause -------------------
28419 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
28420 :
28421 0 : if ( p_expression != NULL )
28422 : {
28423 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28424 : {
28425 0 : if ( p_expression->isInMemoryPool() == false )
28426 : {
28427 0 : std::cout << "SgOmpSimdlenClause :: ";
28428 0 : std::cout << " p_expression is not in memory pool of ";
28429 0 : std::cout << p_expression->class_name() << std::endl;
28430 : }
28431 : }
28432 : else
28433 : {
28434 0 : std::cout << "SgOmpSimdlenClause :: " << std::flush;
28435 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
28436 0 : std::cout << " not valid " << std::endl;
28437 : }
28438 : }
28439 :
28440 0 : if ( p_startOfConstruct != NULL )
28441 : {
28442 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28443 : {
28444 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
28445 : {
28446 0 : std::cout << "SgOmpSimdlenClause :: ";
28447 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
28448 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
28449 : }
28450 : }
28451 : else
28452 : {
28453 0 : std::cout << "SgOmpSimdlenClause :: " << std::flush;
28454 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
28455 0 : std::cout << " not valid " << std::endl;
28456 : }
28457 : }
28458 :
28459 0 : if ( p_endOfConstruct != NULL )
28460 : {
28461 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28462 : {
28463 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
28464 : {
28465 0 : std::cout << "SgOmpSimdlenClause :: ";
28466 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
28467 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
28468 : }
28469 : }
28470 : else
28471 : {
28472 0 : std::cout << "SgOmpSimdlenClause :: " << std::flush;
28473 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
28474 0 : std::cout << " not valid " << std::endl;
28475 : }
28476 : }
28477 :
28478 0 : if ( p_parent != NULL )
28479 : {
28480 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28481 : {
28482 0 : if ( p_parent->isInMemoryPool() == false )
28483 : {
28484 0 : std::cout << "SgOmpSimdlenClause :: ";
28485 0 : std::cout << " p_parent is not in memory pool of ";
28486 0 : std::cout << p_parent->class_name() << std::endl;
28487 : }
28488 : }
28489 : else
28490 : {
28491 0 : std::cout << "SgOmpSimdlenClause :: " << std::flush;
28492 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
28493 0 : std::cout << " not valid " << std::endl;
28494 : }
28495 : }
28496 :
28497 :
28498 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28499 :
28500 0 : }
28501 :
28502 :
28503 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
28504 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
28505 : bool
28506 0 : SgOmpSimdlenClause::isInMemoryPool ()
28507 : {
28508 0 : typedef unsigned char* TestType;
28509 :
28510 0 : bool found = false;
28511 :
28512 0 : ROSE_ASSERT(this != NULL);
28513 :
28514 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
28515 :
28516 0 : TestType tested = (TestType) ( this ) ;
28517 :
28518 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpSimdlenClause::pools.begin();
28519 :
28520 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
28521 : // while (found == false && block < Memory_Block_List.end())
28522 0 : while ( (found == false) && (block != SgOmpSimdlenClause::pools.end()) )
28523 : {
28524 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpSimdlenClause::pool_size * sizeof(SgOmpSimdlenClause) ) ) ;
28525 0 : ++block;
28526 : }
28527 :
28528 : // Special handling for static data
28529 :
28530 :
28531 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
28532 0 : ROSE_ASSERT(found == true);
28533 :
28534 0 : return found;
28535 : }
28536 : /* #line 28537 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
28537 :
28538 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
28539 :
28540 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28541 :
28542 : /* #line 28543 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
28543 :
28544 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28545 :
28546 : void
28547 0 : SgOmpFinalClause::checkDataMemberPointersIfInMemoryPool()
28548 : {
28549 : // ------------ checking pointers of SgOmpFinalClause -------------------
28550 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
28551 :
28552 0 : if ( p_expression != NULL )
28553 : {
28554 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28555 : {
28556 0 : if ( p_expression->isInMemoryPool() == false )
28557 : {
28558 0 : std::cout << "SgOmpFinalClause :: ";
28559 0 : std::cout << " p_expression is not in memory pool of ";
28560 0 : std::cout << p_expression->class_name() << std::endl;
28561 : }
28562 : }
28563 : else
28564 : {
28565 0 : std::cout << "SgOmpFinalClause :: " << std::flush;
28566 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
28567 0 : std::cout << " not valid " << std::endl;
28568 : }
28569 : }
28570 :
28571 0 : if ( p_startOfConstruct != NULL )
28572 : {
28573 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28574 : {
28575 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
28576 : {
28577 0 : std::cout << "SgOmpFinalClause :: ";
28578 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
28579 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
28580 : }
28581 : }
28582 : else
28583 : {
28584 0 : std::cout << "SgOmpFinalClause :: " << std::flush;
28585 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
28586 0 : std::cout << " not valid " << std::endl;
28587 : }
28588 : }
28589 :
28590 0 : if ( p_endOfConstruct != NULL )
28591 : {
28592 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28593 : {
28594 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
28595 : {
28596 0 : std::cout << "SgOmpFinalClause :: ";
28597 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
28598 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
28599 : }
28600 : }
28601 : else
28602 : {
28603 0 : std::cout << "SgOmpFinalClause :: " << std::flush;
28604 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
28605 0 : std::cout << " not valid " << std::endl;
28606 : }
28607 : }
28608 :
28609 0 : if ( p_parent != NULL )
28610 : {
28611 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28612 : {
28613 0 : if ( p_parent->isInMemoryPool() == false )
28614 : {
28615 0 : std::cout << "SgOmpFinalClause :: ";
28616 0 : std::cout << " p_parent is not in memory pool of ";
28617 0 : std::cout << p_parent->class_name() << std::endl;
28618 : }
28619 : }
28620 : else
28621 : {
28622 0 : std::cout << "SgOmpFinalClause :: " << std::flush;
28623 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
28624 0 : std::cout << " not valid " << std::endl;
28625 : }
28626 : }
28627 :
28628 :
28629 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28630 :
28631 0 : }
28632 :
28633 :
28634 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
28635 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
28636 : bool
28637 0 : SgOmpFinalClause::isInMemoryPool ()
28638 : {
28639 0 : typedef unsigned char* TestType;
28640 :
28641 0 : bool found = false;
28642 :
28643 0 : ROSE_ASSERT(this != NULL);
28644 :
28645 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
28646 :
28647 0 : TestType tested = (TestType) ( this ) ;
28648 :
28649 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpFinalClause::pools.begin();
28650 :
28651 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
28652 : // while (found == false && block < Memory_Block_List.end())
28653 0 : while ( (found == false) && (block != SgOmpFinalClause::pools.end()) )
28654 : {
28655 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpFinalClause::pool_size * sizeof(SgOmpFinalClause) ) ) ;
28656 0 : ++block;
28657 : }
28658 :
28659 : // Special handling for static data
28660 :
28661 :
28662 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
28663 0 : ROSE_ASSERT(found == true);
28664 :
28665 0 : return found;
28666 : }
28667 : /* #line 28668 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
28668 :
28669 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
28670 :
28671 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28672 :
28673 : /* #line 28674 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
28674 :
28675 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28676 :
28677 : void
28678 0 : SgOmpPriorityClause::checkDataMemberPointersIfInMemoryPool()
28679 : {
28680 : // ------------ checking pointers of SgOmpPriorityClause -------------------
28681 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
28682 :
28683 0 : if ( p_expression != NULL )
28684 : {
28685 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28686 : {
28687 0 : if ( p_expression->isInMemoryPool() == false )
28688 : {
28689 0 : std::cout << "SgOmpPriorityClause :: ";
28690 0 : std::cout << " p_expression is not in memory pool of ";
28691 0 : std::cout << p_expression->class_name() << std::endl;
28692 : }
28693 : }
28694 : else
28695 : {
28696 0 : std::cout << "SgOmpPriorityClause :: " << std::flush;
28697 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
28698 0 : std::cout << " not valid " << std::endl;
28699 : }
28700 : }
28701 :
28702 0 : if ( p_startOfConstruct != NULL )
28703 : {
28704 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28705 : {
28706 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
28707 : {
28708 0 : std::cout << "SgOmpPriorityClause :: ";
28709 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
28710 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
28711 : }
28712 : }
28713 : else
28714 : {
28715 0 : std::cout << "SgOmpPriorityClause :: " << std::flush;
28716 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
28717 0 : std::cout << " not valid " << std::endl;
28718 : }
28719 : }
28720 :
28721 0 : if ( p_endOfConstruct != NULL )
28722 : {
28723 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28724 : {
28725 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
28726 : {
28727 0 : std::cout << "SgOmpPriorityClause :: ";
28728 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
28729 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
28730 : }
28731 : }
28732 : else
28733 : {
28734 0 : std::cout << "SgOmpPriorityClause :: " << std::flush;
28735 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
28736 0 : std::cout << " not valid " << std::endl;
28737 : }
28738 : }
28739 :
28740 0 : if ( p_parent != NULL )
28741 : {
28742 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28743 : {
28744 0 : if ( p_parent->isInMemoryPool() == false )
28745 : {
28746 0 : std::cout << "SgOmpPriorityClause :: ";
28747 0 : std::cout << " p_parent is not in memory pool of ";
28748 0 : std::cout << p_parent->class_name() << std::endl;
28749 : }
28750 : }
28751 : else
28752 : {
28753 0 : std::cout << "SgOmpPriorityClause :: " << std::flush;
28754 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
28755 0 : std::cout << " not valid " << std::endl;
28756 : }
28757 : }
28758 :
28759 :
28760 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28761 :
28762 0 : }
28763 :
28764 :
28765 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
28766 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
28767 : bool
28768 0 : SgOmpPriorityClause::isInMemoryPool ()
28769 : {
28770 0 : typedef unsigned char* TestType;
28771 :
28772 0 : bool found = false;
28773 :
28774 0 : ROSE_ASSERT(this != NULL);
28775 :
28776 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
28777 :
28778 0 : TestType tested = (TestType) ( this ) ;
28779 :
28780 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpPriorityClause::pools.begin();
28781 :
28782 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
28783 : // while (found == false && block < Memory_Block_List.end())
28784 0 : while ( (found == false) && (block != SgOmpPriorityClause::pools.end()) )
28785 : {
28786 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpPriorityClause::pool_size * sizeof(SgOmpPriorityClause) ) ) ;
28787 0 : ++block;
28788 : }
28789 :
28790 : // Special handling for static data
28791 :
28792 :
28793 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
28794 0 : ROSE_ASSERT(found == true);
28795 :
28796 0 : return found;
28797 : }
28798 : /* #line 28799 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
28799 :
28800 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
28801 :
28802 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28803 :
28804 : /* #line 28805 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
28805 :
28806 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28807 :
28808 : void
28809 0 : SgOmpPartialClause::checkDataMemberPointersIfInMemoryPool()
28810 : {
28811 : // ------------ checking pointers of SgOmpPartialClause -------------------
28812 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
28813 :
28814 0 : if ( p_expression != NULL )
28815 : {
28816 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28817 : {
28818 0 : if ( p_expression->isInMemoryPool() == false )
28819 : {
28820 0 : std::cout << "SgOmpPartialClause :: ";
28821 0 : std::cout << " p_expression is not in memory pool of ";
28822 0 : std::cout << p_expression->class_name() << std::endl;
28823 : }
28824 : }
28825 : else
28826 : {
28827 0 : std::cout << "SgOmpPartialClause :: " << std::flush;
28828 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
28829 0 : std::cout << " not valid " << std::endl;
28830 : }
28831 : }
28832 :
28833 0 : if ( p_startOfConstruct != NULL )
28834 : {
28835 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28836 : {
28837 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
28838 : {
28839 0 : std::cout << "SgOmpPartialClause :: ";
28840 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
28841 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
28842 : }
28843 : }
28844 : else
28845 : {
28846 0 : std::cout << "SgOmpPartialClause :: " << std::flush;
28847 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
28848 0 : std::cout << " not valid " << std::endl;
28849 : }
28850 : }
28851 :
28852 0 : if ( p_endOfConstruct != NULL )
28853 : {
28854 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28855 : {
28856 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
28857 : {
28858 0 : std::cout << "SgOmpPartialClause :: ";
28859 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
28860 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
28861 : }
28862 : }
28863 : else
28864 : {
28865 0 : std::cout << "SgOmpPartialClause :: " << std::flush;
28866 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
28867 0 : std::cout << " not valid " << std::endl;
28868 : }
28869 : }
28870 :
28871 0 : if ( p_parent != NULL )
28872 : {
28873 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28874 : {
28875 0 : if ( p_parent->isInMemoryPool() == false )
28876 : {
28877 0 : std::cout << "SgOmpPartialClause :: ";
28878 0 : std::cout << " p_parent is not in memory pool of ";
28879 0 : std::cout << p_parent->class_name() << std::endl;
28880 : }
28881 : }
28882 : else
28883 : {
28884 0 : std::cout << "SgOmpPartialClause :: " << std::flush;
28885 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
28886 0 : std::cout << " not valid " << std::endl;
28887 : }
28888 : }
28889 :
28890 :
28891 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28892 :
28893 0 : }
28894 :
28895 :
28896 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
28897 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
28898 : bool
28899 0 : SgOmpPartialClause::isInMemoryPool ()
28900 : {
28901 0 : typedef unsigned char* TestType;
28902 :
28903 0 : bool found = false;
28904 :
28905 0 : ROSE_ASSERT(this != NULL);
28906 :
28907 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
28908 :
28909 0 : TestType tested = (TestType) ( this ) ;
28910 :
28911 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpPartialClause::pools.begin();
28912 :
28913 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
28914 : // while (found == false && block < Memory_Block_List.end())
28915 0 : while ( (found == false) && (block != SgOmpPartialClause::pools.end()) )
28916 : {
28917 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpPartialClause::pool_size * sizeof(SgOmpPartialClause) ) ) ;
28918 0 : ++block;
28919 : }
28920 :
28921 : // Special handling for static data
28922 :
28923 :
28924 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
28925 0 : ROSE_ASSERT(found == true);
28926 :
28927 0 : return found;
28928 : }
28929 : /* #line 28930 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
28930 :
28931 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
28932 :
28933 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28934 :
28935 : /* #line 28936 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
28936 :
28937 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
28938 :
28939 : void
28940 0 : SgOmpSizesClause::checkDataMemberPointersIfInMemoryPool()
28941 : {
28942 : // ------------ checking pointers of SgOmpSizesClause -------------------
28943 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
28944 :
28945 0 : if ( p_expression != NULL )
28946 : {
28947 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28948 : {
28949 0 : if ( p_expression->isInMemoryPool() == false )
28950 : {
28951 0 : std::cout << "SgOmpSizesClause :: ";
28952 0 : std::cout << " p_expression is not in memory pool of ";
28953 0 : std::cout << p_expression->class_name() << std::endl;
28954 : }
28955 : }
28956 : else
28957 : {
28958 0 : std::cout << "SgOmpSizesClause :: " << std::flush;
28959 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
28960 0 : std::cout << " not valid " << std::endl;
28961 : }
28962 : }
28963 :
28964 0 : if ( p_startOfConstruct != NULL )
28965 : {
28966 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28967 : {
28968 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
28969 : {
28970 0 : std::cout << "SgOmpSizesClause :: ";
28971 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
28972 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
28973 : }
28974 : }
28975 : else
28976 : {
28977 0 : std::cout << "SgOmpSizesClause :: " << std::flush;
28978 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
28979 0 : std::cout << " not valid " << std::endl;
28980 : }
28981 : }
28982 :
28983 0 : if ( p_endOfConstruct != NULL )
28984 : {
28985 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
28986 : {
28987 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
28988 : {
28989 0 : std::cout << "SgOmpSizesClause :: ";
28990 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
28991 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
28992 : }
28993 : }
28994 : else
28995 : {
28996 0 : std::cout << "SgOmpSizesClause :: " << std::flush;
28997 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
28998 0 : std::cout << " not valid " << std::endl;
28999 : }
29000 : }
29001 :
29002 0 : if ( p_parent != NULL )
29003 : {
29004 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29005 : {
29006 0 : if ( p_parent->isInMemoryPool() == false )
29007 : {
29008 0 : std::cout << "SgOmpSizesClause :: ";
29009 0 : std::cout << " p_parent is not in memory pool of ";
29010 0 : std::cout << p_parent->class_name() << std::endl;
29011 : }
29012 : }
29013 : else
29014 : {
29015 0 : std::cout << "SgOmpSizesClause :: " << std::flush;
29016 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
29017 0 : std::cout << " not valid " << std::endl;
29018 : }
29019 : }
29020 :
29021 :
29022 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29023 :
29024 0 : }
29025 :
29026 :
29027 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
29028 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
29029 : bool
29030 0 : SgOmpSizesClause::isInMemoryPool ()
29031 : {
29032 0 : typedef unsigned char* TestType;
29033 :
29034 0 : bool found = false;
29035 :
29036 0 : ROSE_ASSERT(this != NULL);
29037 :
29038 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
29039 :
29040 0 : TestType tested = (TestType) ( this ) ;
29041 :
29042 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpSizesClause::pools.begin();
29043 :
29044 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
29045 : // while (found == false && block < Memory_Block_List.end())
29046 0 : while ( (found == false) && (block != SgOmpSizesClause::pools.end()) )
29047 : {
29048 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpSizesClause::pool_size * sizeof(SgOmpSizesClause) ) ) ;
29049 0 : ++block;
29050 : }
29051 :
29052 : // Special handling for static data
29053 :
29054 :
29055 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
29056 0 : ROSE_ASSERT(found == true);
29057 :
29058 0 : return found;
29059 : }
29060 : /* #line 29061 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
29061 :
29062 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
29063 :
29064 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29065 :
29066 : /* #line 29067 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
29067 :
29068 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29069 :
29070 : void
29071 0 : SgOmpInbranchClause::checkDataMemberPointersIfInMemoryPool()
29072 : {
29073 : // ------------ checking pointers of SgOmpInbranchClause -------------------
29074 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
29075 :
29076 0 : if ( p_startOfConstruct != NULL )
29077 : {
29078 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29079 : {
29080 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
29081 : {
29082 0 : std::cout << "SgOmpInbranchClause :: ";
29083 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
29084 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
29085 : }
29086 : }
29087 : else
29088 : {
29089 0 : std::cout << "SgOmpInbranchClause :: " << std::flush;
29090 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
29091 0 : std::cout << " not valid " << std::endl;
29092 : }
29093 : }
29094 :
29095 0 : if ( p_endOfConstruct != NULL )
29096 : {
29097 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29098 : {
29099 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
29100 : {
29101 0 : std::cout << "SgOmpInbranchClause :: ";
29102 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
29103 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
29104 : }
29105 : }
29106 : else
29107 : {
29108 0 : std::cout << "SgOmpInbranchClause :: " << std::flush;
29109 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
29110 0 : std::cout << " not valid " << std::endl;
29111 : }
29112 : }
29113 :
29114 0 : if ( p_parent != NULL )
29115 : {
29116 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29117 : {
29118 0 : if ( p_parent->isInMemoryPool() == false )
29119 : {
29120 0 : std::cout << "SgOmpInbranchClause :: ";
29121 0 : std::cout << " p_parent is not in memory pool of ";
29122 0 : std::cout << p_parent->class_name() << std::endl;
29123 : }
29124 : }
29125 : else
29126 : {
29127 0 : std::cout << "SgOmpInbranchClause :: " << std::flush;
29128 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
29129 0 : std::cout << " not valid " << std::endl;
29130 : }
29131 : }
29132 :
29133 :
29134 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29135 :
29136 0 : }
29137 :
29138 :
29139 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
29140 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
29141 : bool
29142 0 : SgOmpInbranchClause::isInMemoryPool ()
29143 : {
29144 0 : typedef unsigned char* TestType;
29145 :
29146 0 : bool found = false;
29147 :
29148 0 : ROSE_ASSERT(this != NULL);
29149 :
29150 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
29151 :
29152 0 : TestType tested = (TestType) ( this ) ;
29153 :
29154 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpInbranchClause::pools.begin();
29155 :
29156 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
29157 : // while (found == false && block < Memory_Block_List.end())
29158 0 : while ( (found == false) && (block != SgOmpInbranchClause::pools.end()) )
29159 : {
29160 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpInbranchClause::pool_size * sizeof(SgOmpInbranchClause) ) ) ;
29161 0 : ++block;
29162 : }
29163 :
29164 : // Special handling for static data
29165 :
29166 :
29167 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
29168 0 : ROSE_ASSERT(found == true);
29169 :
29170 0 : return found;
29171 : }
29172 : /* #line 29173 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
29173 :
29174 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
29175 :
29176 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29177 :
29178 : /* #line 29179 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
29179 :
29180 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29181 :
29182 : void
29183 0 : SgOmpNotinbranchClause::checkDataMemberPointersIfInMemoryPool()
29184 : {
29185 : // ------------ checking pointers of SgOmpNotinbranchClause -------------------
29186 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
29187 :
29188 0 : if ( p_startOfConstruct != NULL )
29189 : {
29190 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29191 : {
29192 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
29193 : {
29194 0 : std::cout << "SgOmpNotinbranchClause :: ";
29195 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
29196 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
29197 : }
29198 : }
29199 : else
29200 : {
29201 0 : std::cout << "SgOmpNotinbranchClause :: " << std::flush;
29202 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
29203 0 : std::cout << " not valid " << std::endl;
29204 : }
29205 : }
29206 :
29207 0 : if ( p_endOfConstruct != NULL )
29208 : {
29209 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29210 : {
29211 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
29212 : {
29213 0 : std::cout << "SgOmpNotinbranchClause :: ";
29214 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
29215 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
29216 : }
29217 : }
29218 : else
29219 : {
29220 0 : std::cout << "SgOmpNotinbranchClause :: " << std::flush;
29221 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
29222 0 : std::cout << " not valid " << std::endl;
29223 : }
29224 : }
29225 :
29226 0 : if ( p_parent != NULL )
29227 : {
29228 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29229 : {
29230 0 : if ( p_parent->isInMemoryPool() == false )
29231 : {
29232 0 : std::cout << "SgOmpNotinbranchClause :: ";
29233 0 : std::cout << " p_parent is not in memory pool of ";
29234 0 : std::cout << p_parent->class_name() << std::endl;
29235 : }
29236 : }
29237 : else
29238 : {
29239 0 : std::cout << "SgOmpNotinbranchClause :: " << std::flush;
29240 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
29241 0 : std::cout << " not valid " << std::endl;
29242 : }
29243 : }
29244 :
29245 :
29246 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29247 :
29248 0 : }
29249 :
29250 :
29251 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
29252 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
29253 : bool
29254 0 : SgOmpNotinbranchClause::isInMemoryPool ()
29255 : {
29256 0 : typedef unsigned char* TestType;
29257 :
29258 0 : bool found = false;
29259 :
29260 0 : ROSE_ASSERT(this != NULL);
29261 :
29262 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
29263 :
29264 0 : TestType tested = (TestType) ( this ) ;
29265 :
29266 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpNotinbranchClause::pools.begin();
29267 :
29268 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
29269 : // while (found == false && block < Memory_Block_List.end())
29270 0 : while ( (found == false) && (block != SgOmpNotinbranchClause::pools.end()) )
29271 : {
29272 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpNotinbranchClause::pool_size * sizeof(SgOmpNotinbranchClause) ) ) ;
29273 0 : ++block;
29274 : }
29275 :
29276 : // Special handling for static data
29277 :
29278 :
29279 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
29280 0 : ROSE_ASSERT(found == true);
29281 :
29282 0 : return found;
29283 : }
29284 : /* #line 29285 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
29285 :
29286 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
29287 :
29288 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29289 :
29290 : /* #line 29291 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
29291 :
29292 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29293 :
29294 : void
29295 0 : SgOmpDefaultmapClause::checkDataMemberPointersIfInMemoryPool()
29296 : {
29297 : // ------------ checking pointers of SgOmpDefaultmapClause -------------------
29298 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
29299 :
29300 0 : if ( p_startOfConstruct != NULL )
29301 : {
29302 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29303 : {
29304 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
29305 : {
29306 0 : std::cout << "SgOmpDefaultmapClause :: ";
29307 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
29308 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
29309 : }
29310 : }
29311 : else
29312 : {
29313 0 : std::cout << "SgOmpDefaultmapClause :: " << std::flush;
29314 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
29315 0 : std::cout << " not valid " << std::endl;
29316 : }
29317 : }
29318 :
29319 0 : if ( p_endOfConstruct != NULL )
29320 : {
29321 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29322 : {
29323 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
29324 : {
29325 0 : std::cout << "SgOmpDefaultmapClause :: ";
29326 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
29327 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
29328 : }
29329 : }
29330 : else
29331 : {
29332 0 : std::cout << "SgOmpDefaultmapClause :: " << std::flush;
29333 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
29334 0 : std::cout << " not valid " << std::endl;
29335 : }
29336 : }
29337 :
29338 0 : if ( p_parent != NULL )
29339 : {
29340 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29341 : {
29342 0 : if ( p_parent->isInMemoryPool() == false )
29343 : {
29344 0 : std::cout << "SgOmpDefaultmapClause :: ";
29345 0 : std::cout << " p_parent is not in memory pool of ";
29346 0 : std::cout << p_parent->class_name() << std::endl;
29347 : }
29348 : }
29349 : else
29350 : {
29351 0 : std::cout << "SgOmpDefaultmapClause :: " << std::flush;
29352 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
29353 0 : std::cout << " not valid " << std::endl;
29354 : }
29355 : }
29356 :
29357 :
29358 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29359 :
29360 0 : }
29361 :
29362 :
29363 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
29364 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
29365 : bool
29366 0 : SgOmpDefaultmapClause::isInMemoryPool ()
29367 : {
29368 0 : typedef unsigned char* TestType;
29369 :
29370 0 : bool found = false;
29371 :
29372 0 : ROSE_ASSERT(this != NULL);
29373 :
29374 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
29375 :
29376 0 : TestType tested = (TestType) ( this ) ;
29377 :
29378 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDefaultmapClause::pools.begin();
29379 :
29380 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
29381 : // while (found == false && block < Memory_Block_List.end())
29382 0 : while ( (found == false) && (block != SgOmpDefaultmapClause::pools.end()) )
29383 : {
29384 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDefaultmapClause::pool_size * sizeof(SgOmpDefaultmapClause) ) ) ;
29385 0 : ++block;
29386 : }
29387 :
29388 : // Special handling for static data
29389 :
29390 :
29391 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
29392 0 : ROSE_ASSERT(found == true);
29393 :
29394 0 : return found;
29395 : }
29396 : /* #line 29397 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
29397 :
29398 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
29399 :
29400 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29401 :
29402 : /* #line 29403 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
29403 :
29404 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29405 :
29406 : void
29407 0 : SgOmpAtomicDefaultMemOrderClause::checkDataMemberPointersIfInMemoryPool()
29408 : {
29409 : // ------------ checking pointers of SgOmpAtomicDefaultMemOrderClause -------------------
29410 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
29411 :
29412 0 : if ( p_startOfConstruct != NULL )
29413 : {
29414 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29415 : {
29416 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
29417 : {
29418 0 : std::cout << "SgOmpAtomicDefaultMemOrderClause :: ";
29419 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
29420 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
29421 : }
29422 : }
29423 : else
29424 : {
29425 0 : std::cout << "SgOmpAtomicDefaultMemOrderClause :: " << std::flush;
29426 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
29427 0 : std::cout << " not valid " << std::endl;
29428 : }
29429 : }
29430 :
29431 0 : if ( p_endOfConstruct != NULL )
29432 : {
29433 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29434 : {
29435 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
29436 : {
29437 0 : std::cout << "SgOmpAtomicDefaultMemOrderClause :: ";
29438 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
29439 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
29440 : }
29441 : }
29442 : else
29443 : {
29444 0 : std::cout << "SgOmpAtomicDefaultMemOrderClause :: " << std::flush;
29445 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
29446 0 : std::cout << " not valid " << std::endl;
29447 : }
29448 : }
29449 :
29450 0 : if ( p_parent != NULL )
29451 : {
29452 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29453 : {
29454 0 : if ( p_parent->isInMemoryPool() == false )
29455 : {
29456 0 : std::cout << "SgOmpAtomicDefaultMemOrderClause :: ";
29457 0 : std::cout << " p_parent is not in memory pool of ";
29458 0 : std::cout << p_parent->class_name() << std::endl;
29459 : }
29460 : }
29461 : else
29462 : {
29463 0 : std::cout << "SgOmpAtomicDefaultMemOrderClause :: " << std::flush;
29464 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
29465 0 : std::cout << " not valid " << std::endl;
29466 : }
29467 : }
29468 :
29469 :
29470 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29471 :
29472 0 : }
29473 :
29474 :
29475 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
29476 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
29477 : bool
29478 0 : SgOmpAtomicDefaultMemOrderClause::isInMemoryPool ()
29479 : {
29480 0 : typedef unsigned char* TestType;
29481 :
29482 0 : bool found = false;
29483 :
29484 0 : ROSE_ASSERT(this != NULL);
29485 :
29486 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
29487 :
29488 0 : TestType tested = (TestType) ( this ) ;
29489 :
29490 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpAtomicDefaultMemOrderClause::pools.begin();
29491 :
29492 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
29493 : // while (found == false && block < Memory_Block_List.end())
29494 0 : while ( (found == false) && (block != SgOmpAtomicDefaultMemOrderClause::pools.end()) )
29495 : {
29496 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpAtomicDefaultMemOrderClause::pool_size * sizeof(SgOmpAtomicDefaultMemOrderClause) ) ) ;
29497 0 : ++block;
29498 : }
29499 :
29500 : // Special handling for static data
29501 :
29502 :
29503 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
29504 0 : ROSE_ASSERT(found == true);
29505 :
29506 0 : return found;
29507 : }
29508 : /* #line 29509 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
29509 :
29510 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
29511 :
29512 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29513 :
29514 : /* #line 29515 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
29515 :
29516 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29517 :
29518 : void
29519 0 : SgOmpExtImplementationDefinedRequirementClause::checkDataMemberPointersIfInMemoryPool()
29520 : {
29521 : // ------------ checking pointers of SgOmpExtImplementationDefinedRequirementClause -------------------
29522 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
29523 :
29524 0 : if ( p_implementation_defined_requirement != NULL )
29525 : {
29526 0 : if ( p_implementation_defined_requirement->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29527 : {
29528 0 : if ( p_implementation_defined_requirement->isInMemoryPool() == false )
29529 : {
29530 0 : std::cout << "SgOmpExtImplementationDefinedRequirementClause :: ";
29531 0 : std::cout << " p_implementation_defined_requirement is not in memory pool of ";
29532 0 : std::cout << p_implementation_defined_requirement->class_name() << std::endl;
29533 : }
29534 : }
29535 : else
29536 : {
29537 0 : std::cout << "SgOmpExtImplementationDefinedRequirementClause :: " << std::flush;
29538 0 : std::cout << "SgExpression* p_implementation_defined_requirement = " << p_implementation_defined_requirement << " --> " << std::flush;
29539 0 : std::cout << " not valid " << std::endl;
29540 : }
29541 : }
29542 :
29543 0 : if ( p_startOfConstruct != NULL )
29544 : {
29545 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29546 : {
29547 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
29548 : {
29549 0 : std::cout << "SgOmpExtImplementationDefinedRequirementClause :: ";
29550 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
29551 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
29552 : }
29553 : }
29554 : else
29555 : {
29556 0 : std::cout << "SgOmpExtImplementationDefinedRequirementClause :: " << std::flush;
29557 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
29558 0 : std::cout << " not valid " << std::endl;
29559 : }
29560 : }
29561 :
29562 0 : if ( p_endOfConstruct != NULL )
29563 : {
29564 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29565 : {
29566 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
29567 : {
29568 0 : std::cout << "SgOmpExtImplementationDefinedRequirementClause :: ";
29569 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
29570 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
29571 : }
29572 : }
29573 : else
29574 : {
29575 0 : std::cout << "SgOmpExtImplementationDefinedRequirementClause :: " << std::flush;
29576 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
29577 0 : std::cout << " not valid " << std::endl;
29578 : }
29579 : }
29580 :
29581 0 : if ( p_parent != NULL )
29582 : {
29583 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29584 : {
29585 0 : if ( p_parent->isInMemoryPool() == false )
29586 : {
29587 0 : std::cout << "SgOmpExtImplementationDefinedRequirementClause :: ";
29588 0 : std::cout << " p_parent is not in memory pool of ";
29589 0 : std::cout << p_parent->class_name() << std::endl;
29590 : }
29591 : }
29592 : else
29593 : {
29594 0 : std::cout << "SgOmpExtImplementationDefinedRequirementClause :: " << std::flush;
29595 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
29596 0 : std::cout << " not valid " << std::endl;
29597 : }
29598 : }
29599 :
29600 :
29601 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29602 :
29603 0 : }
29604 :
29605 :
29606 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
29607 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
29608 : bool
29609 0 : SgOmpExtImplementationDefinedRequirementClause::isInMemoryPool ()
29610 : {
29611 0 : typedef unsigned char* TestType;
29612 :
29613 0 : bool found = false;
29614 :
29615 0 : ROSE_ASSERT(this != NULL);
29616 :
29617 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
29618 :
29619 0 : TestType tested = (TestType) ( this ) ;
29620 :
29621 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpExtImplementationDefinedRequirementClause::pools.begin();
29622 :
29623 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
29624 : // while (found == false && block < Memory_Block_List.end())
29625 0 : while ( (found == false) && (block != SgOmpExtImplementationDefinedRequirementClause::pools.end()) )
29626 : {
29627 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpExtImplementationDefinedRequirementClause::pool_size * sizeof(SgOmpExtImplementationDefinedRequirementClause) ) ) ;
29628 0 : ++block;
29629 : }
29630 :
29631 : // Special handling for static data
29632 :
29633 :
29634 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
29635 0 : ROSE_ASSERT(found == true);
29636 :
29637 0 : return found;
29638 : }
29639 : /* #line 29640 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
29640 :
29641 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
29642 :
29643 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29644 :
29645 : /* #line 29646 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
29646 :
29647 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29648 :
29649 : void
29650 0 : SgOmpUsesAllocatorsDefination::checkDataMemberPointersIfInMemoryPool()
29651 : {
29652 : // ------------ checking pointers of SgOmpUsesAllocatorsDefination -------------------
29653 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
29654 :
29655 0 : if ( p_user_defined_allocator != NULL )
29656 : {
29657 0 : if ( p_user_defined_allocator->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29658 : {
29659 0 : if ( p_user_defined_allocator->isInMemoryPool() == false )
29660 : {
29661 0 : std::cout << "SgOmpUsesAllocatorsDefination :: ";
29662 0 : std::cout << " p_user_defined_allocator is not in memory pool of ";
29663 0 : std::cout << p_user_defined_allocator->class_name() << std::endl;
29664 : }
29665 : }
29666 : else
29667 : {
29668 0 : std::cout << "SgOmpUsesAllocatorsDefination :: " << std::flush;
29669 0 : std::cout << "SgExpression* p_user_defined_allocator = " << p_user_defined_allocator << " --> " << std::flush;
29670 0 : std::cout << " not valid " << std::endl;
29671 : }
29672 : }
29673 :
29674 0 : if ( p_allocator_traits_array != NULL )
29675 : {
29676 0 : if ( p_allocator_traits_array->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29677 : {
29678 0 : if ( p_allocator_traits_array->isInMemoryPool() == false )
29679 : {
29680 0 : std::cout << "SgOmpUsesAllocatorsDefination :: ";
29681 0 : std::cout << " p_allocator_traits_array is not in memory pool of ";
29682 0 : std::cout << p_allocator_traits_array->class_name() << std::endl;
29683 : }
29684 : }
29685 : else
29686 : {
29687 0 : std::cout << "SgOmpUsesAllocatorsDefination :: " << std::flush;
29688 0 : std::cout << "SgExpression* p_allocator_traits_array = " << p_allocator_traits_array << " --> " << std::flush;
29689 0 : std::cout << " not valid " << std::endl;
29690 : }
29691 : }
29692 :
29693 0 : if ( p_startOfConstruct != NULL )
29694 : {
29695 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29696 : {
29697 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
29698 : {
29699 0 : std::cout << "SgOmpUsesAllocatorsDefination :: ";
29700 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
29701 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
29702 : }
29703 : }
29704 : else
29705 : {
29706 0 : std::cout << "SgOmpUsesAllocatorsDefination :: " << std::flush;
29707 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
29708 0 : std::cout << " not valid " << std::endl;
29709 : }
29710 : }
29711 :
29712 0 : if ( p_endOfConstruct != NULL )
29713 : {
29714 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29715 : {
29716 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
29717 : {
29718 0 : std::cout << "SgOmpUsesAllocatorsDefination :: ";
29719 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
29720 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
29721 : }
29722 : }
29723 : else
29724 : {
29725 0 : std::cout << "SgOmpUsesAllocatorsDefination :: " << std::flush;
29726 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
29727 0 : std::cout << " not valid " << std::endl;
29728 : }
29729 : }
29730 :
29731 0 : if ( p_parent != NULL )
29732 : {
29733 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29734 : {
29735 0 : if ( p_parent->isInMemoryPool() == false )
29736 : {
29737 0 : std::cout << "SgOmpUsesAllocatorsDefination :: ";
29738 0 : std::cout << " p_parent is not in memory pool of ";
29739 0 : std::cout << p_parent->class_name() << std::endl;
29740 : }
29741 : }
29742 : else
29743 : {
29744 0 : std::cout << "SgOmpUsesAllocatorsDefination :: " << std::flush;
29745 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
29746 0 : std::cout << " not valid " << std::endl;
29747 : }
29748 : }
29749 :
29750 :
29751 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29752 :
29753 0 : }
29754 :
29755 :
29756 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
29757 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
29758 : bool
29759 0 : SgOmpUsesAllocatorsDefination::isInMemoryPool ()
29760 : {
29761 0 : typedef unsigned char* TestType;
29762 :
29763 0 : bool found = false;
29764 :
29765 0 : ROSE_ASSERT(this != NULL);
29766 :
29767 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
29768 :
29769 0 : TestType tested = (TestType) ( this ) ;
29770 :
29771 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpUsesAllocatorsDefination::pools.begin();
29772 :
29773 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
29774 : // while (found == false && block < Memory_Block_List.end())
29775 0 : while ( (found == false) && (block != SgOmpUsesAllocatorsDefination::pools.end()) )
29776 : {
29777 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpUsesAllocatorsDefination::pool_size * sizeof(SgOmpUsesAllocatorsDefination) ) ) ;
29778 0 : ++block;
29779 : }
29780 :
29781 : // Special handling for static data
29782 :
29783 :
29784 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
29785 0 : ROSE_ASSERT(found == true);
29786 :
29787 0 : return found;
29788 : }
29789 : /* #line 29790 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
29790 :
29791 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
29792 :
29793 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29794 :
29795 : /* #line 29796 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
29796 :
29797 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29798 :
29799 : void
29800 0 : SgOmpVariablesClause::checkDataMemberPointersIfInMemoryPool()
29801 : {
29802 : // ------------ checking pointers of SgOmpVariablesClause -------------------
29803 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
29804 :
29805 0 : if ( p_variables != NULL )
29806 : {
29807 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29808 : {
29809 0 : if ( p_variables->isInMemoryPool() == false )
29810 : {
29811 0 : std::cout << "SgOmpVariablesClause :: ";
29812 0 : std::cout << " p_variables is not in memory pool of ";
29813 0 : std::cout << p_variables->class_name() << std::endl;
29814 : }
29815 : }
29816 : else
29817 : {
29818 0 : std::cout << "SgOmpVariablesClause :: " << std::flush;
29819 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
29820 0 : std::cout << " not valid " << std::endl;
29821 : }
29822 : }
29823 :
29824 0 : if ( p_startOfConstruct != NULL )
29825 : {
29826 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29827 : {
29828 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
29829 : {
29830 0 : std::cout << "SgOmpVariablesClause :: ";
29831 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
29832 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
29833 : }
29834 : }
29835 : else
29836 : {
29837 0 : std::cout << "SgOmpVariablesClause :: " << std::flush;
29838 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
29839 0 : std::cout << " not valid " << std::endl;
29840 : }
29841 : }
29842 :
29843 0 : if ( p_endOfConstruct != NULL )
29844 : {
29845 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29846 : {
29847 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
29848 : {
29849 0 : std::cout << "SgOmpVariablesClause :: ";
29850 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
29851 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
29852 : }
29853 : }
29854 : else
29855 : {
29856 0 : std::cout << "SgOmpVariablesClause :: " << std::flush;
29857 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
29858 0 : std::cout << " not valid " << std::endl;
29859 : }
29860 : }
29861 :
29862 0 : if ( p_parent != NULL )
29863 : {
29864 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29865 : {
29866 0 : if ( p_parent->isInMemoryPool() == false )
29867 : {
29868 0 : std::cout << "SgOmpVariablesClause :: ";
29869 0 : std::cout << " p_parent is not in memory pool of ";
29870 0 : std::cout << p_parent->class_name() << std::endl;
29871 : }
29872 : }
29873 : else
29874 : {
29875 0 : std::cout << "SgOmpVariablesClause :: " << std::flush;
29876 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
29877 0 : std::cout << " not valid " << std::endl;
29878 : }
29879 : }
29880 :
29881 :
29882 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29883 :
29884 0 : }
29885 :
29886 :
29887 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
29888 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
29889 : bool
29890 0 : SgOmpVariablesClause::isInMemoryPool ()
29891 : {
29892 0 : typedef unsigned char* TestType;
29893 :
29894 0 : bool found = false;
29895 :
29896 0 : ROSE_ASSERT(this != NULL);
29897 :
29898 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
29899 :
29900 0 : TestType tested = (TestType) ( this ) ;
29901 :
29902 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpVariablesClause::pools.begin();
29903 :
29904 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
29905 : // while (found == false && block < Memory_Block_List.end())
29906 0 : while ( (found == false) && (block != SgOmpVariablesClause::pools.end()) )
29907 : {
29908 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpVariablesClause::pool_size * sizeof(SgOmpVariablesClause) ) ) ;
29909 0 : ++block;
29910 : }
29911 :
29912 : // Special handling for static data
29913 :
29914 :
29915 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
29916 0 : ROSE_ASSERT(found == true);
29917 :
29918 0 : return found;
29919 : }
29920 : /* #line 29921 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
29921 :
29922 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
29923 :
29924 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29925 :
29926 : /* #line 29927 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
29927 :
29928 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
29929 :
29930 : void
29931 0 : SgOmpCopyprivateClause::checkDataMemberPointersIfInMemoryPool()
29932 : {
29933 : // ------------ checking pointers of SgOmpCopyprivateClause -------------------
29934 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
29935 :
29936 0 : if ( p_variables != NULL )
29937 : {
29938 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29939 : {
29940 0 : if ( p_variables->isInMemoryPool() == false )
29941 : {
29942 0 : std::cout << "SgOmpCopyprivateClause :: ";
29943 0 : std::cout << " p_variables is not in memory pool of ";
29944 0 : std::cout << p_variables->class_name() << std::endl;
29945 : }
29946 : }
29947 : else
29948 : {
29949 0 : std::cout << "SgOmpCopyprivateClause :: " << std::flush;
29950 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
29951 0 : std::cout << " not valid " << std::endl;
29952 : }
29953 : }
29954 :
29955 0 : if ( p_startOfConstruct != NULL )
29956 : {
29957 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29958 : {
29959 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
29960 : {
29961 0 : std::cout << "SgOmpCopyprivateClause :: ";
29962 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
29963 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
29964 : }
29965 : }
29966 : else
29967 : {
29968 0 : std::cout << "SgOmpCopyprivateClause :: " << std::flush;
29969 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
29970 0 : std::cout << " not valid " << std::endl;
29971 : }
29972 : }
29973 :
29974 0 : if ( p_endOfConstruct != NULL )
29975 : {
29976 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29977 : {
29978 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
29979 : {
29980 0 : std::cout << "SgOmpCopyprivateClause :: ";
29981 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
29982 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
29983 : }
29984 : }
29985 : else
29986 : {
29987 0 : std::cout << "SgOmpCopyprivateClause :: " << std::flush;
29988 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
29989 0 : std::cout << " not valid " << std::endl;
29990 : }
29991 : }
29992 :
29993 0 : if ( p_parent != NULL )
29994 : {
29995 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
29996 : {
29997 0 : if ( p_parent->isInMemoryPool() == false )
29998 : {
29999 0 : std::cout << "SgOmpCopyprivateClause :: ";
30000 0 : std::cout << " p_parent is not in memory pool of ";
30001 0 : std::cout << p_parent->class_name() << std::endl;
30002 : }
30003 : }
30004 : else
30005 : {
30006 0 : std::cout << "SgOmpCopyprivateClause :: " << std::flush;
30007 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
30008 0 : std::cout << " not valid " << std::endl;
30009 : }
30010 : }
30011 :
30012 :
30013 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30014 :
30015 0 : }
30016 :
30017 :
30018 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
30019 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
30020 : bool
30021 0 : SgOmpCopyprivateClause::isInMemoryPool ()
30022 : {
30023 0 : typedef unsigned char* TestType;
30024 :
30025 0 : bool found = false;
30026 :
30027 0 : ROSE_ASSERT(this != NULL);
30028 :
30029 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
30030 :
30031 0 : TestType tested = (TestType) ( this ) ;
30032 :
30033 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpCopyprivateClause::pools.begin();
30034 :
30035 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
30036 : // while (found == false && block < Memory_Block_List.end())
30037 0 : while ( (found == false) && (block != SgOmpCopyprivateClause::pools.end()) )
30038 : {
30039 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpCopyprivateClause::pool_size * sizeof(SgOmpCopyprivateClause) ) ) ;
30040 0 : ++block;
30041 : }
30042 :
30043 : // Special handling for static data
30044 :
30045 :
30046 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
30047 0 : ROSE_ASSERT(found == true);
30048 :
30049 0 : return found;
30050 : }
30051 : /* #line 30052 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
30052 :
30053 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
30054 :
30055 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30056 :
30057 : /* #line 30058 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
30058 :
30059 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30060 :
30061 : void
30062 0 : SgOmpPrivateClause::checkDataMemberPointersIfInMemoryPool()
30063 : {
30064 : // ------------ checking pointers of SgOmpPrivateClause -------------------
30065 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30066 :
30067 0 : if ( p_variables != NULL )
30068 : {
30069 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30070 : {
30071 0 : if ( p_variables->isInMemoryPool() == false )
30072 : {
30073 0 : std::cout << "SgOmpPrivateClause :: ";
30074 0 : std::cout << " p_variables is not in memory pool of ";
30075 0 : std::cout << p_variables->class_name() << std::endl;
30076 : }
30077 : }
30078 : else
30079 : {
30080 0 : std::cout << "SgOmpPrivateClause :: " << std::flush;
30081 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
30082 0 : std::cout << " not valid " << std::endl;
30083 : }
30084 : }
30085 :
30086 0 : if ( p_startOfConstruct != NULL )
30087 : {
30088 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30089 : {
30090 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
30091 : {
30092 0 : std::cout << "SgOmpPrivateClause :: ";
30093 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
30094 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
30095 : }
30096 : }
30097 : else
30098 : {
30099 0 : std::cout << "SgOmpPrivateClause :: " << std::flush;
30100 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
30101 0 : std::cout << " not valid " << std::endl;
30102 : }
30103 : }
30104 :
30105 0 : if ( p_endOfConstruct != NULL )
30106 : {
30107 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30108 : {
30109 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
30110 : {
30111 0 : std::cout << "SgOmpPrivateClause :: ";
30112 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
30113 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
30114 : }
30115 : }
30116 : else
30117 : {
30118 0 : std::cout << "SgOmpPrivateClause :: " << std::flush;
30119 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
30120 0 : std::cout << " not valid " << std::endl;
30121 : }
30122 : }
30123 :
30124 0 : if ( p_parent != NULL )
30125 : {
30126 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30127 : {
30128 0 : if ( p_parent->isInMemoryPool() == false )
30129 : {
30130 0 : std::cout << "SgOmpPrivateClause :: ";
30131 0 : std::cout << " p_parent is not in memory pool of ";
30132 0 : std::cout << p_parent->class_name() << std::endl;
30133 : }
30134 : }
30135 : else
30136 : {
30137 0 : std::cout << "SgOmpPrivateClause :: " << std::flush;
30138 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
30139 0 : std::cout << " not valid " << std::endl;
30140 : }
30141 : }
30142 :
30143 :
30144 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30145 :
30146 0 : }
30147 :
30148 :
30149 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
30150 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
30151 : bool
30152 0 : SgOmpPrivateClause::isInMemoryPool ()
30153 : {
30154 0 : typedef unsigned char* TestType;
30155 :
30156 0 : bool found = false;
30157 :
30158 0 : ROSE_ASSERT(this != NULL);
30159 :
30160 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
30161 :
30162 0 : TestType tested = (TestType) ( this ) ;
30163 :
30164 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpPrivateClause::pools.begin();
30165 :
30166 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
30167 : // while (found == false && block < Memory_Block_List.end())
30168 0 : while ( (found == false) && (block != SgOmpPrivateClause::pools.end()) )
30169 : {
30170 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpPrivateClause::pool_size * sizeof(SgOmpPrivateClause) ) ) ;
30171 0 : ++block;
30172 : }
30173 :
30174 : // Special handling for static data
30175 :
30176 :
30177 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
30178 0 : ROSE_ASSERT(found == true);
30179 :
30180 0 : return found;
30181 : }
30182 : /* #line 30183 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
30183 :
30184 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
30185 :
30186 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30187 :
30188 : /* #line 30189 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
30189 :
30190 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30191 :
30192 : void
30193 0 : SgOmpFirstprivateClause::checkDataMemberPointersIfInMemoryPool()
30194 : {
30195 : // ------------ checking pointers of SgOmpFirstprivateClause -------------------
30196 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30197 :
30198 0 : if ( p_variables != NULL )
30199 : {
30200 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30201 : {
30202 0 : if ( p_variables->isInMemoryPool() == false )
30203 : {
30204 0 : std::cout << "SgOmpFirstprivateClause :: ";
30205 0 : std::cout << " p_variables is not in memory pool of ";
30206 0 : std::cout << p_variables->class_name() << std::endl;
30207 : }
30208 : }
30209 : else
30210 : {
30211 0 : std::cout << "SgOmpFirstprivateClause :: " << std::flush;
30212 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
30213 0 : std::cout << " not valid " << std::endl;
30214 : }
30215 : }
30216 :
30217 0 : if ( p_startOfConstruct != NULL )
30218 : {
30219 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30220 : {
30221 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
30222 : {
30223 0 : std::cout << "SgOmpFirstprivateClause :: ";
30224 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
30225 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
30226 : }
30227 : }
30228 : else
30229 : {
30230 0 : std::cout << "SgOmpFirstprivateClause :: " << std::flush;
30231 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
30232 0 : std::cout << " not valid " << std::endl;
30233 : }
30234 : }
30235 :
30236 0 : if ( p_endOfConstruct != NULL )
30237 : {
30238 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30239 : {
30240 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
30241 : {
30242 0 : std::cout << "SgOmpFirstprivateClause :: ";
30243 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
30244 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
30245 : }
30246 : }
30247 : else
30248 : {
30249 0 : std::cout << "SgOmpFirstprivateClause :: " << std::flush;
30250 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
30251 0 : std::cout << " not valid " << std::endl;
30252 : }
30253 : }
30254 :
30255 0 : if ( p_parent != NULL )
30256 : {
30257 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30258 : {
30259 0 : if ( p_parent->isInMemoryPool() == false )
30260 : {
30261 0 : std::cout << "SgOmpFirstprivateClause :: ";
30262 0 : std::cout << " p_parent is not in memory pool of ";
30263 0 : std::cout << p_parent->class_name() << std::endl;
30264 : }
30265 : }
30266 : else
30267 : {
30268 0 : std::cout << "SgOmpFirstprivateClause :: " << std::flush;
30269 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
30270 0 : std::cout << " not valid " << std::endl;
30271 : }
30272 : }
30273 :
30274 :
30275 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30276 :
30277 0 : }
30278 :
30279 :
30280 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
30281 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
30282 : bool
30283 0 : SgOmpFirstprivateClause::isInMemoryPool ()
30284 : {
30285 0 : typedef unsigned char* TestType;
30286 :
30287 0 : bool found = false;
30288 :
30289 0 : ROSE_ASSERT(this != NULL);
30290 :
30291 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
30292 :
30293 0 : TestType tested = (TestType) ( this ) ;
30294 :
30295 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpFirstprivateClause::pools.begin();
30296 :
30297 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
30298 : // while (found == false && block < Memory_Block_List.end())
30299 0 : while ( (found == false) && (block != SgOmpFirstprivateClause::pools.end()) )
30300 : {
30301 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpFirstprivateClause::pool_size * sizeof(SgOmpFirstprivateClause) ) ) ;
30302 0 : ++block;
30303 : }
30304 :
30305 : // Special handling for static data
30306 :
30307 :
30308 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
30309 0 : ROSE_ASSERT(found == true);
30310 :
30311 0 : return found;
30312 : }
30313 : /* #line 30314 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
30314 :
30315 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
30316 :
30317 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30318 :
30319 : /* #line 30320 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
30320 :
30321 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30322 :
30323 : void
30324 0 : SgOmpNontemporalClause::checkDataMemberPointersIfInMemoryPool()
30325 : {
30326 : // ------------ checking pointers of SgOmpNontemporalClause -------------------
30327 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30328 :
30329 0 : if ( p_variables != NULL )
30330 : {
30331 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30332 : {
30333 0 : if ( p_variables->isInMemoryPool() == false )
30334 : {
30335 0 : std::cout << "SgOmpNontemporalClause :: ";
30336 0 : std::cout << " p_variables is not in memory pool of ";
30337 0 : std::cout << p_variables->class_name() << std::endl;
30338 : }
30339 : }
30340 : else
30341 : {
30342 0 : std::cout << "SgOmpNontemporalClause :: " << std::flush;
30343 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
30344 0 : std::cout << " not valid " << std::endl;
30345 : }
30346 : }
30347 :
30348 0 : if ( p_startOfConstruct != NULL )
30349 : {
30350 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30351 : {
30352 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
30353 : {
30354 0 : std::cout << "SgOmpNontemporalClause :: ";
30355 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
30356 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
30357 : }
30358 : }
30359 : else
30360 : {
30361 0 : std::cout << "SgOmpNontemporalClause :: " << std::flush;
30362 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
30363 0 : std::cout << " not valid " << std::endl;
30364 : }
30365 : }
30366 :
30367 0 : if ( p_endOfConstruct != NULL )
30368 : {
30369 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30370 : {
30371 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
30372 : {
30373 0 : std::cout << "SgOmpNontemporalClause :: ";
30374 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
30375 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
30376 : }
30377 : }
30378 : else
30379 : {
30380 0 : std::cout << "SgOmpNontemporalClause :: " << std::flush;
30381 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
30382 0 : std::cout << " not valid " << std::endl;
30383 : }
30384 : }
30385 :
30386 0 : if ( p_parent != NULL )
30387 : {
30388 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30389 : {
30390 0 : if ( p_parent->isInMemoryPool() == false )
30391 : {
30392 0 : std::cout << "SgOmpNontemporalClause :: ";
30393 0 : std::cout << " p_parent is not in memory pool of ";
30394 0 : std::cout << p_parent->class_name() << std::endl;
30395 : }
30396 : }
30397 : else
30398 : {
30399 0 : std::cout << "SgOmpNontemporalClause :: " << std::flush;
30400 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
30401 0 : std::cout << " not valid " << std::endl;
30402 : }
30403 : }
30404 :
30405 :
30406 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30407 :
30408 0 : }
30409 :
30410 :
30411 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
30412 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
30413 : bool
30414 0 : SgOmpNontemporalClause::isInMemoryPool ()
30415 : {
30416 0 : typedef unsigned char* TestType;
30417 :
30418 0 : bool found = false;
30419 :
30420 0 : ROSE_ASSERT(this != NULL);
30421 :
30422 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
30423 :
30424 0 : TestType tested = (TestType) ( this ) ;
30425 :
30426 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpNontemporalClause::pools.begin();
30427 :
30428 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
30429 : // while (found == false && block < Memory_Block_List.end())
30430 0 : while ( (found == false) && (block != SgOmpNontemporalClause::pools.end()) )
30431 : {
30432 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpNontemporalClause::pool_size * sizeof(SgOmpNontemporalClause) ) ) ;
30433 0 : ++block;
30434 : }
30435 :
30436 : // Special handling for static data
30437 :
30438 :
30439 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
30440 0 : ROSE_ASSERT(found == true);
30441 :
30442 0 : return found;
30443 : }
30444 : /* #line 30445 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
30445 :
30446 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
30447 :
30448 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30449 :
30450 : /* #line 30451 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
30451 :
30452 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30453 :
30454 : void
30455 0 : SgOmpInclusiveClause::checkDataMemberPointersIfInMemoryPool()
30456 : {
30457 : // ------------ checking pointers of SgOmpInclusiveClause -------------------
30458 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30459 :
30460 0 : if ( p_variables != NULL )
30461 : {
30462 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30463 : {
30464 0 : if ( p_variables->isInMemoryPool() == false )
30465 : {
30466 0 : std::cout << "SgOmpInclusiveClause :: ";
30467 0 : std::cout << " p_variables is not in memory pool of ";
30468 0 : std::cout << p_variables->class_name() << std::endl;
30469 : }
30470 : }
30471 : else
30472 : {
30473 0 : std::cout << "SgOmpInclusiveClause :: " << std::flush;
30474 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
30475 0 : std::cout << " not valid " << std::endl;
30476 : }
30477 : }
30478 :
30479 0 : if ( p_startOfConstruct != NULL )
30480 : {
30481 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30482 : {
30483 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
30484 : {
30485 0 : std::cout << "SgOmpInclusiveClause :: ";
30486 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
30487 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
30488 : }
30489 : }
30490 : else
30491 : {
30492 0 : std::cout << "SgOmpInclusiveClause :: " << std::flush;
30493 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
30494 0 : std::cout << " not valid " << std::endl;
30495 : }
30496 : }
30497 :
30498 0 : if ( p_endOfConstruct != NULL )
30499 : {
30500 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30501 : {
30502 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
30503 : {
30504 0 : std::cout << "SgOmpInclusiveClause :: ";
30505 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
30506 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
30507 : }
30508 : }
30509 : else
30510 : {
30511 0 : std::cout << "SgOmpInclusiveClause :: " << std::flush;
30512 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
30513 0 : std::cout << " not valid " << std::endl;
30514 : }
30515 : }
30516 :
30517 0 : if ( p_parent != NULL )
30518 : {
30519 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30520 : {
30521 0 : if ( p_parent->isInMemoryPool() == false )
30522 : {
30523 0 : std::cout << "SgOmpInclusiveClause :: ";
30524 0 : std::cout << " p_parent is not in memory pool of ";
30525 0 : std::cout << p_parent->class_name() << std::endl;
30526 : }
30527 : }
30528 : else
30529 : {
30530 0 : std::cout << "SgOmpInclusiveClause :: " << std::flush;
30531 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
30532 0 : std::cout << " not valid " << std::endl;
30533 : }
30534 : }
30535 :
30536 :
30537 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30538 :
30539 0 : }
30540 :
30541 :
30542 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
30543 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
30544 : bool
30545 0 : SgOmpInclusiveClause::isInMemoryPool ()
30546 : {
30547 0 : typedef unsigned char* TestType;
30548 :
30549 0 : bool found = false;
30550 :
30551 0 : ROSE_ASSERT(this != NULL);
30552 :
30553 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
30554 :
30555 0 : TestType tested = (TestType) ( this ) ;
30556 :
30557 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpInclusiveClause::pools.begin();
30558 :
30559 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
30560 : // while (found == false && block < Memory_Block_List.end())
30561 0 : while ( (found == false) && (block != SgOmpInclusiveClause::pools.end()) )
30562 : {
30563 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpInclusiveClause::pool_size * sizeof(SgOmpInclusiveClause) ) ) ;
30564 0 : ++block;
30565 : }
30566 :
30567 : // Special handling for static data
30568 :
30569 :
30570 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
30571 0 : ROSE_ASSERT(found == true);
30572 :
30573 0 : return found;
30574 : }
30575 : /* #line 30576 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
30576 :
30577 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
30578 :
30579 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30580 :
30581 : /* #line 30582 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
30582 :
30583 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30584 :
30585 : void
30586 0 : SgOmpExclusiveClause::checkDataMemberPointersIfInMemoryPool()
30587 : {
30588 : // ------------ checking pointers of SgOmpExclusiveClause -------------------
30589 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30590 :
30591 0 : if ( p_variables != NULL )
30592 : {
30593 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30594 : {
30595 0 : if ( p_variables->isInMemoryPool() == false )
30596 : {
30597 0 : std::cout << "SgOmpExclusiveClause :: ";
30598 0 : std::cout << " p_variables is not in memory pool of ";
30599 0 : std::cout << p_variables->class_name() << std::endl;
30600 : }
30601 : }
30602 : else
30603 : {
30604 0 : std::cout << "SgOmpExclusiveClause :: " << std::flush;
30605 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
30606 0 : std::cout << " not valid " << std::endl;
30607 : }
30608 : }
30609 :
30610 0 : if ( p_startOfConstruct != NULL )
30611 : {
30612 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30613 : {
30614 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
30615 : {
30616 0 : std::cout << "SgOmpExclusiveClause :: ";
30617 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
30618 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
30619 : }
30620 : }
30621 : else
30622 : {
30623 0 : std::cout << "SgOmpExclusiveClause :: " << std::flush;
30624 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
30625 0 : std::cout << " not valid " << std::endl;
30626 : }
30627 : }
30628 :
30629 0 : if ( p_endOfConstruct != NULL )
30630 : {
30631 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30632 : {
30633 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
30634 : {
30635 0 : std::cout << "SgOmpExclusiveClause :: ";
30636 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
30637 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
30638 : }
30639 : }
30640 : else
30641 : {
30642 0 : std::cout << "SgOmpExclusiveClause :: " << std::flush;
30643 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
30644 0 : std::cout << " not valid " << std::endl;
30645 : }
30646 : }
30647 :
30648 0 : if ( p_parent != NULL )
30649 : {
30650 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30651 : {
30652 0 : if ( p_parent->isInMemoryPool() == false )
30653 : {
30654 0 : std::cout << "SgOmpExclusiveClause :: ";
30655 0 : std::cout << " p_parent is not in memory pool of ";
30656 0 : std::cout << p_parent->class_name() << std::endl;
30657 : }
30658 : }
30659 : else
30660 : {
30661 0 : std::cout << "SgOmpExclusiveClause :: " << std::flush;
30662 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
30663 0 : std::cout << " not valid " << std::endl;
30664 : }
30665 : }
30666 :
30667 :
30668 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30669 :
30670 0 : }
30671 :
30672 :
30673 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
30674 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
30675 : bool
30676 0 : SgOmpExclusiveClause::isInMemoryPool ()
30677 : {
30678 0 : typedef unsigned char* TestType;
30679 :
30680 0 : bool found = false;
30681 :
30682 0 : ROSE_ASSERT(this != NULL);
30683 :
30684 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
30685 :
30686 0 : TestType tested = (TestType) ( this ) ;
30687 :
30688 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpExclusiveClause::pools.begin();
30689 :
30690 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
30691 : // while (found == false && block < Memory_Block_List.end())
30692 0 : while ( (found == false) && (block != SgOmpExclusiveClause::pools.end()) )
30693 : {
30694 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpExclusiveClause::pool_size * sizeof(SgOmpExclusiveClause) ) ) ;
30695 0 : ++block;
30696 : }
30697 :
30698 : // Special handling for static data
30699 :
30700 :
30701 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
30702 0 : ROSE_ASSERT(found == true);
30703 :
30704 0 : return found;
30705 : }
30706 : /* #line 30707 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
30707 :
30708 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
30709 :
30710 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30711 :
30712 : /* #line 30713 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
30713 :
30714 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30715 :
30716 : void
30717 0 : SgOmpIsDevicePtrClause::checkDataMemberPointersIfInMemoryPool()
30718 : {
30719 : // ------------ checking pointers of SgOmpIsDevicePtrClause -------------------
30720 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30721 :
30722 0 : if ( p_variables != NULL )
30723 : {
30724 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30725 : {
30726 0 : if ( p_variables->isInMemoryPool() == false )
30727 : {
30728 0 : std::cout << "SgOmpIsDevicePtrClause :: ";
30729 0 : std::cout << " p_variables is not in memory pool of ";
30730 0 : std::cout << p_variables->class_name() << std::endl;
30731 : }
30732 : }
30733 : else
30734 : {
30735 0 : std::cout << "SgOmpIsDevicePtrClause :: " << std::flush;
30736 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
30737 0 : std::cout << " not valid " << std::endl;
30738 : }
30739 : }
30740 :
30741 0 : if ( p_startOfConstruct != NULL )
30742 : {
30743 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30744 : {
30745 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
30746 : {
30747 0 : std::cout << "SgOmpIsDevicePtrClause :: ";
30748 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
30749 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
30750 : }
30751 : }
30752 : else
30753 : {
30754 0 : std::cout << "SgOmpIsDevicePtrClause :: " << std::flush;
30755 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
30756 0 : std::cout << " not valid " << std::endl;
30757 : }
30758 : }
30759 :
30760 0 : if ( p_endOfConstruct != NULL )
30761 : {
30762 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30763 : {
30764 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
30765 : {
30766 0 : std::cout << "SgOmpIsDevicePtrClause :: ";
30767 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
30768 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
30769 : }
30770 : }
30771 : else
30772 : {
30773 0 : std::cout << "SgOmpIsDevicePtrClause :: " << std::flush;
30774 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
30775 0 : std::cout << " not valid " << std::endl;
30776 : }
30777 : }
30778 :
30779 0 : if ( p_parent != NULL )
30780 : {
30781 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30782 : {
30783 0 : if ( p_parent->isInMemoryPool() == false )
30784 : {
30785 0 : std::cout << "SgOmpIsDevicePtrClause :: ";
30786 0 : std::cout << " p_parent is not in memory pool of ";
30787 0 : std::cout << p_parent->class_name() << std::endl;
30788 : }
30789 : }
30790 : else
30791 : {
30792 0 : std::cout << "SgOmpIsDevicePtrClause :: " << std::flush;
30793 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
30794 0 : std::cout << " not valid " << std::endl;
30795 : }
30796 : }
30797 :
30798 :
30799 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30800 :
30801 0 : }
30802 :
30803 :
30804 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
30805 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
30806 : bool
30807 0 : SgOmpIsDevicePtrClause::isInMemoryPool ()
30808 : {
30809 0 : typedef unsigned char* TestType;
30810 :
30811 0 : bool found = false;
30812 :
30813 0 : ROSE_ASSERT(this != NULL);
30814 :
30815 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
30816 :
30817 0 : TestType tested = (TestType) ( this ) ;
30818 :
30819 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpIsDevicePtrClause::pools.begin();
30820 :
30821 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
30822 : // while (found == false && block < Memory_Block_List.end())
30823 0 : while ( (found == false) && (block != SgOmpIsDevicePtrClause::pools.end()) )
30824 : {
30825 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpIsDevicePtrClause::pool_size * sizeof(SgOmpIsDevicePtrClause) ) ) ;
30826 0 : ++block;
30827 : }
30828 :
30829 : // Special handling for static data
30830 :
30831 :
30832 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
30833 0 : ROSE_ASSERT(found == true);
30834 :
30835 0 : return found;
30836 : }
30837 : /* #line 30838 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
30838 :
30839 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
30840 :
30841 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30842 :
30843 : /* #line 30844 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
30844 :
30845 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30846 :
30847 : void
30848 0 : SgOmpUseDevicePtrClause::checkDataMemberPointersIfInMemoryPool()
30849 : {
30850 : // ------------ checking pointers of SgOmpUseDevicePtrClause -------------------
30851 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30852 :
30853 0 : if ( p_variables != NULL )
30854 : {
30855 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30856 : {
30857 0 : if ( p_variables->isInMemoryPool() == false )
30858 : {
30859 0 : std::cout << "SgOmpUseDevicePtrClause :: ";
30860 0 : std::cout << " p_variables is not in memory pool of ";
30861 0 : std::cout << p_variables->class_name() << std::endl;
30862 : }
30863 : }
30864 : else
30865 : {
30866 0 : std::cout << "SgOmpUseDevicePtrClause :: " << std::flush;
30867 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
30868 0 : std::cout << " not valid " << std::endl;
30869 : }
30870 : }
30871 :
30872 0 : if ( p_startOfConstruct != NULL )
30873 : {
30874 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30875 : {
30876 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
30877 : {
30878 0 : std::cout << "SgOmpUseDevicePtrClause :: ";
30879 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
30880 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
30881 : }
30882 : }
30883 : else
30884 : {
30885 0 : std::cout << "SgOmpUseDevicePtrClause :: " << std::flush;
30886 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
30887 0 : std::cout << " not valid " << std::endl;
30888 : }
30889 : }
30890 :
30891 0 : if ( p_endOfConstruct != NULL )
30892 : {
30893 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30894 : {
30895 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
30896 : {
30897 0 : std::cout << "SgOmpUseDevicePtrClause :: ";
30898 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
30899 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
30900 : }
30901 : }
30902 : else
30903 : {
30904 0 : std::cout << "SgOmpUseDevicePtrClause :: " << std::flush;
30905 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
30906 0 : std::cout << " not valid " << std::endl;
30907 : }
30908 : }
30909 :
30910 0 : if ( p_parent != NULL )
30911 : {
30912 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30913 : {
30914 0 : if ( p_parent->isInMemoryPool() == false )
30915 : {
30916 0 : std::cout << "SgOmpUseDevicePtrClause :: ";
30917 0 : std::cout << " p_parent is not in memory pool of ";
30918 0 : std::cout << p_parent->class_name() << std::endl;
30919 : }
30920 : }
30921 : else
30922 : {
30923 0 : std::cout << "SgOmpUseDevicePtrClause :: " << std::flush;
30924 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
30925 0 : std::cout << " not valid " << std::endl;
30926 : }
30927 : }
30928 :
30929 :
30930 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30931 :
30932 0 : }
30933 :
30934 :
30935 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
30936 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
30937 : bool
30938 0 : SgOmpUseDevicePtrClause::isInMemoryPool ()
30939 : {
30940 0 : typedef unsigned char* TestType;
30941 :
30942 0 : bool found = false;
30943 :
30944 0 : ROSE_ASSERT(this != NULL);
30945 :
30946 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
30947 :
30948 0 : TestType tested = (TestType) ( this ) ;
30949 :
30950 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpUseDevicePtrClause::pools.begin();
30951 :
30952 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
30953 : // while (found == false && block < Memory_Block_List.end())
30954 0 : while ( (found == false) && (block != SgOmpUseDevicePtrClause::pools.end()) )
30955 : {
30956 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpUseDevicePtrClause::pool_size * sizeof(SgOmpUseDevicePtrClause) ) ) ;
30957 0 : ++block;
30958 : }
30959 :
30960 : // Special handling for static data
30961 :
30962 :
30963 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
30964 0 : ROSE_ASSERT(found == true);
30965 :
30966 0 : return found;
30967 : }
30968 : /* #line 30969 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
30969 :
30970 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
30971 :
30972 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30973 :
30974 : /* #line 30975 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
30975 :
30976 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
30977 :
30978 : void
30979 0 : SgOmpUseDeviceAddrClause::checkDataMemberPointersIfInMemoryPool()
30980 : {
30981 : // ------------ checking pointers of SgOmpUseDeviceAddrClause -------------------
30982 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30983 :
30984 0 : if ( p_variables != NULL )
30985 : {
30986 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
30987 : {
30988 0 : if ( p_variables->isInMemoryPool() == false )
30989 : {
30990 0 : std::cout << "SgOmpUseDeviceAddrClause :: ";
30991 0 : std::cout << " p_variables is not in memory pool of ";
30992 0 : std::cout << p_variables->class_name() << std::endl;
30993 : }
30994 : }
30995 : else
30996 : {
30997 0 : std::cout << "SgOmpUseDeviceAddrClause :: " << std::flush;
30998 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
30999 0 : std::cout << " not valid " << std::endl;
31000 : }
31001 : }
31002 :
31003 0 : if ( p_startOfConstruct != NULL )
31004 : {
31005 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31006 : {
31007 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
31008 : {
31009 0 : std::cout << "SgOmpUseDeviceAddrClause :: ";
31010 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
31011 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
31012 : }
31013 : }
31014 : else
31015 : {
31016 0 : std::cout << "SgOmpUseDeviceAddrClause :: " << std::flush;
31017 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
31018 0 : std::cout << " not valid " << std::endl;
31019 : }
31020 : }
31021 :
31022 0 : if ( p_endOfConstruct != NULL )
31023 : {
31024 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31025 : {
31026 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
31027 : {
31028 0 : std::cout << "SgOmpUseDeviceAddrClause :: ";
31029 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
31030 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
31031 : }
31032 : }
31033 : else
31034 : {
31035 0 : std::cout << "SgOmpUseDeviceAddrClause :: " << std::flush;
31036 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
31037 0 : std::cout << " not valid " << std::endl;
31038 : }
31039 : }
31040 :
31041 0 : if ( p_parent != NULL )
31042 : {
31043 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31044 : {
31045 0 : if ( p_parent->isInMemoryPool() == false )
31046 : {
31047 0 : std::cout << "SgOmpUseDeviceAddrClause :: ";
31048 0 : std::cout << " p_parent is not in memory pool of ";
31049 0 : std::cout << p_parent->class_name() << std::endl;
31050 : }
31051 : }
31052 : else
31053 : {
31054 0 : std::cout << "SgOmpUseDeviceAddrClause :: " << std::flush;
31055 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
31056 0 : std::cout << " not valid " << std::endl;
31057 : }
31058 : }
31059 :
31060 :
31061 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31062 :
31063 0 : }
31064 :
31065 :
31066 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
31067 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
31068 : bool
31069 0 : SgOmpUseDeviceAddrClause::isInMemoryPool ()
31070 : {
31071 0 : typedef unsigned char* TestType;
31072 :
31073 0 : bool found = false;
31074 :
31075 0 : ROSE_ASSERT(this != NULL);
31076 :
31077 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
31078 :
31079 0 : TestType tested = (TestType) ( this ) ;
31080 :
31081 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpUseDeviceAddrClause::pools.begin();
31082 :
31083 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
31084 : // while (found == false && block < Memory_Block_List.end())
31085 0 : while ( (found == false) && (block != SgOmpUseDeviceAddrClause::pools.end()) )
31086 : {
31087 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpUseDeviceAddrClause::pool_size * sizeof(SgOmpUseDeviceAddrClause) ) ) ;
31088 0 : ++block;
31089 : }
31090 :
31091 : // Special handling for static data
31092 :
31093 :
31094 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
31095 0 : ROSE_ASSERT(found == true);
31096 :
31097 0 : return found;
31098 : }
31099 : /* #line 31100 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
31100 :
31101 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
31102 :
31103 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31104 :
31105 : /* #line 31106 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
31106 :
31107 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31108 :
31109 : void
31110 0 : SgOmpSharedClause::checkDataMemberPointersIfInMemoryPool()
31111 : {
31112 : // ------------ checking pointers of SgOmpSharedClause -------------------
31113 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31114 :
31115 0 : if ( p_variables != NULL )
31116 : {
31117 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31118 : {
31119 0 : if ( p_variables->isInMemoryPool() == false )
31120 : {
31121 0 : std::cout << "SgOmpSharedClause :: ";
31122 0 : std::cout << " p_variables is not in memory pool of ";
31123 0 : std::cout << p_variables->class_name() << std::endl;
31124 : }
31125 : }
31126 : else
31127 : {
31128 0 : std::cout << "SgOmpSharedClause :: " << std::flush;
31129 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
31130 0 : std::cout << " not valid " << std::endl;
31131 : }
31132 : }
31133 :
31134 0 : if ( p_startOfConstruct != NULL )
31135 : {
31136 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31137 : {
31138 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
31139 : {
31140 0 : std::cout << "SgOmpSharedClause :: ";
31141 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
31142 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
31143 : }
31144 : }
31145 : else
31146 : {
31147 0 : std::cout << "SgOmpSharedClause :: " << std::flush;
31148 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
31149 0 : std::cout << " not valid " << std::endl;
31150 : }
31151 : }
31152 :
31153 0 : if ( p_endOfConstruct != NULL )
31154 : {
31155 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31156 : {
31157 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
31158 : {
31159 0 : std::cout << "SgOmpSharedClause :: ";
31160 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
31161 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
31162 : }
31163 : }
31164 : else
31165 : {
31166 0 : std::cout << "SgOmpSharedClause :: " << std::flush;
31167 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
31168 0 : std::cout << " not valid " << std::endl;
31169 : }
31170 : }
31171 :
31172 0 : if ( p_parent != NULL )
31173 : {
31174 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31175 : {
31176 0 : if ( p_parent->isInMemoryPool() == false )
31177 : {
31178 0 : std::cout << "SgOmpSharedClause :: ";
31179 0 : std::cout << " p_parent is not in memory pool of ";
31180 0 : std::cout << p_parent->class_name() << std::endl;
31181 : }
31182 : }
31183 : else
31184 : {
31185 0 : std::cout << "SgOmpSharedClause :: " << std::flush;
31186 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
31187 0 : std::cout << " not valid " << std::endl;
31188 : }
31189 : }
31190 :
31191 :
31192 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31193 :
31194 0 : }
31195 :
31196 :
31197 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
31198 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
31199 : bool
31200 0 : SgOmpSharedClause::isInMemoryPool ()
31201 : {
31202 0 : typedef unsigned char* TestType;
31203 :
31204 0 : bool found = false;
31205 :
31206 0 : ROSE_ASSERT(this != NULL);
31207 :
31208 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
31209 :
31210 0 : TestType tested = (TestType) ( this ) ;
31211 :
31212 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpSharedClause::pools.begin();
31213 :
31214 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
31215 : // while (found == false && block < Memory_Block_List.end())
31216 0 : while ( (found == false) && (block != SgOmpSharedClause::pools.end()) )
31217 : {
31218 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpSharedClause::pool_size * sizeof(SgOmpSharedClause) ) ) ;
31219 0 : ++block;
31220 : }
31221 :
31222 : // Special handling for static data
31223 :
31224 :
31225 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
31226 0 : ROSE_ASSERT(found == true);
31227 :
31228 0 : return found;
31229 : }
31230 : /* #line 31231 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
31231 :
31232 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
31233 :
31234 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31235 :
31236 : /* #line 31237 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
31237 :
31238 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31239 :
31240 : void
31241 0 : SgOmpCopyinClause::checkDataMemberPointersIfInMemoryPool()
31242 : {
31243 : // ------------ checking pointers of SgOmpCopyinClause -------------------
31244 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31245 :
31246 0 : if ( p_variables != NULL )
31247 : {
31248 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31249 : {
31250 0 : if ( p_variables->isInMemoryPool() == false )
31251 : {
31252 0 : std::cout << "SgOmpCopyinClause :: ";
31253 0 : std::cout << " p_variables is not in memory pool of ";
31254 0 : std::cout << p_variables->class_name() << std::endl;
31255 : }
31256 : }
31257 : else
31258 : {
31259 0 : std::cout << "SgOmpCopyinClause :: " << std::flush;
31260 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
31261 0 : std::cout << " not valid " << std::endl;
31262 : }
31263 : }
31264 :
31265 0 : if ( p_startOfConstruct != NULL )
31266 : {
31267 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31268 : {
31269 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
31270 : {
31271 0 : std::cout << "SgOmpCopyinClause :: ";
31272 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
31273 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
31274 : }
31275 : }
31276 : else
31277 : {
31278 0 : std::cout << "SgOmpCopyinClause :: " << std::flush;
31279 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
31280 0 : std::cout << " not valid " << std::endl;
31281 : }
31282 : }
31283 :
31284 0 : if ( p_endOfConstruct != NULL )
31285 : {
31286 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31287 : {
31288 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
31289 : {
31290 0 : std::cout << "SgOmpCopyinClause :: ";
31291 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
31292 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
31293 : }
31294 : }
31295 : else
31296 : {
31297 0 : std::cout << "SgOmpCopyinClause :: " << std::flush;
31298 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
31299 0 : std::cout << " not valid " << std::endl;
31300 : }
31301 : }
31302 :
31303 0 : if ( p_parent != NULL )
31304 : {
31305 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31306 : {
31307 0 : if ( p_parent->isInMemoryPool() == false )
31308 : {
31309 0 : std::cout << "SgOmpCopyinClause :: ";
31310 0 : std::cout << " p_parent is not in memory pool of ";
31311 0 : std::cout << p_parent->class_name() << std::endl;
31312 : }
31313 : }
31314 : else
31315 : {
31316 0 : std::cout << "SgOmpCopyinClause :: " << std::flush;
31317 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
31318 0 : std::cout << " not valid " << std::endl;
31319 : }
31320 : }
31321 :
31322 :
31323 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31324 :
31325 0 : }
31326 :
31327 :
31328 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
31329 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
31330 : bool
31331 0 : SgOmpCopyinClause::isInMemoryPool ()
31332 : {
31333 0 : typedef unsigned char* TestType;
31334 :
31335 0 : bool found = false;
31336 :
31337 0 : ROSE_ASSERT(this != NULL);
31338 :
31339 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
31340 :
31341 0 : TestType tested = (TestType) ( this ) ;
31342 :
31343 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpCopyinClause::pools.begin();
31344 :
31345 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
31346 : // while (found == false && block < Memory_Block_List.end())
31347 0 : while ( (found == false) && (block != SgOmpCopyinClause::pools.end()) )
31348 : {
31349 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpCopyinClause::pool_size * sizeof(SgOmpCopyinClause) ) ) ;
31350 0 : ++block;
31351 : }
31352 :
31353 : // Special handling for static data
31354 :
31355 :
31356 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
31357 0 : ROSE_ASSERT(found == true);
31358 :
31359 0 : return found;
31360 : }
31361 : /* #line 31362 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
31362 :
31363 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
31364 :
31365 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31366 :
31367 : /* #line 31368 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
31368 :
31369 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31370 :
31371 : void
31372 0 : SgOmpLastprivateClause::checkDataMemberPointersIfInMemoryPool()
31373 : {
31374 : // ------------ checking pointers of SgOmpLastprivateClause -------------------
31375 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31376 :
31377 0 : if ( p_variables != NULL )
31378 : {
31379 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31380 : {
31381 0 : if ( p_variables->isInMemoryPool() == false )
31382 : {
31383 0 : std::cout << "SgOmpLastprivateClause :: ";
31384 0 : std::cout << " p_variables is not in memory pool of ";
31385 0 : std::cout << p_variables->class_name() << std::endl;
31386 : }
31387 : }
31388 : else
31389 : {
31390 0 : std::cout << "SgOmpLastprivateClause :: " << std::flush;
31391 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
31392 0 : std::cout << " not valid " << std::endl;
31393 : }
31394 : }
31395 :
31396 0 : if ( p_startOfConstruct != NULL )
31397 : {
31398 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31399 : {
31400 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
31401 : {
31402 0 : std::cout << "SgOmpLastprivateClause :: ";
31403 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
31404 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
31405 : }
31406 : }
31407 : else
31408 : {
31409 0 : std::cout << "SgOmpLastprivateClause :: " << std::flush;
31410 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
31411 0 : std::cout << " not valid " << std::endl;
31412 : }
31413 : }
31414 :
31415 0 : if ( p_endOfConstruct != NULL )
31416 : {
31417 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31418 : {
31419 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
31420 : {
31421 0 : std::cout << "SgOmpLastprivateClause :: ";
31422 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
31423 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
31424 : }
31425 : }
31426 : else
31427 : {
31428 0 : std::cout << "SgOmpLastprivateClause :: " << std::flush;
31429 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
31430 0 : std::cout << " not valid " << std::endl;
31431 : }
31432 : }
31433 :
31434 0 : if ( p_parent != NULL )
31435 : {
31436 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31437 : {
31438 0 : if ( p_parent->isInMemoryPool() == false )
31439 : {
31440 0 : std::cout << "SgOmpLastprivateClause :: ";
31441 0 : std::cout << " p_parent is not in memory pool of ";
31442 0 : std::cout << p_parent->class_name() << std::endl;
31443 : }
31444 : }
31445 : else
31446 : {
31447 0 : std::cout << "SgOmpLastprivateClause :: " << std::flush;
31448 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
31449 0 : std::cout << " not valid " << std::endl;
31450 : }
31451 : }
31452 :
31453 :
31454 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31455 :
31456 0 : }
31457 :
31458 :
31459 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
31460 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
31461 : bool
31462 0 : SgOmpLastprivateClause::isInMemoryPool ()
31463 : {
31464 0 : typedef unsigned char* TestType;
31465 :
31466 0 : bool found = false;
31467 :
31468 0 : ROSE_ASSERT(this != NULL);
31469 :
31470 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
31471 :
31472 0 : TestType tested = (TestType) ( this ) ;
31473 :
31474 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpLastprivateClause::pools.begin();
31475 :
31476 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
31477 : // while (found == false && block < Memory_Block_List.end())
31478 0 : while ( (found == false) && (block != SgOmpLastprivateClause::pools.end()) )
31479 : {
31480 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpLastprivateClause::pool_size * sizeof(SgOmpLastprivateClause) ) ) ;
31481 0 : ++block;
31482 : }
31483 :
31484 : // Special handling for static data
31485 :
31486 :
31487 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
31488 0 : ROSE_ASSERT(found == true);
31489 :
31490 0 : return found;
31491 : }
31492 : /* #line 31493 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
31493 :
31494 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
31495 :
31496 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31497 :
31498 : /* #line 31499 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
31499 :
31500 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31501 :
31502 : void
31503 0 : SgOmpReductionClause::checkDataMemberPointersIfInMemoryPool()
31504 : {
31505 : // ------------ checking pointers of SgOmpReductionClause -------------------
31506 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31507 :
31508 0 : if ( p_user_defined_identifier != NULL )
31509 : {
31510 0 : if ( p_user_defined_identifier->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31511 : {
31512 0 : if ( p_user_defined_identifier->isInMemoryPool() == false )
31513 : {
31514 0 : std::cout << "SgOmpReductionClause :: ";
31515 0 : std::cout << " p_user_defined_identifier is not in memory pool of ";
31516 0 : std::cout << p_user_defined_identifier->class_name() << std::endl;
31517 : }
31518 : }
31519 : else
31520 : {
31521 0 : std::cout << "SgOmpReductionClause :: " << std::flush;
31522 0 : std::cout << "SgExpression* p_user_defined_identifier = " << p_user_defined_identifier << " --> " << std::flush;
31523 0 : std::cout << " not valid " << std::endl;
31524 : }
31525 : }
31526 :
31527 0 : if ( p_variables != NULL )
31528 : {
31529 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31530 : {
31531 0 : if ( p_variables->isInMemoryPool() == false )
31532 : {
31533 0 : std::cout << "SgOmpReductionClause :: ";
31534 0 : std::cout << " p_variables is not in memory pool of ";
31535 0 : std::cout << p_variables->class_name() << std::endl;
31536 : }
31537 : }
31538 : else
31539 : {
31540 0 : std::cout << "SgOmpReductionClause :: " << std::flush;
31541 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
31542 0 : std::cout << " not valid " << std::endl;
31543 : }
31544 : }
31545 :
31546 0 : if ( p_startOfConstruct != NULL )
31547 : {
31548 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31549 : {
31550 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
31551 : {
31552 0 : std::cout << "SgOmpReductionClause :: ";
31553 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
31554 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
31555 : }
31556 : }
31557 : else
31558 : {
31559 0 : std::cout << "SgOmpReductionClause :: " << std::flush;
31560 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
31561 0 : std::cout << " not valid " << std::endl;
31562 : }
31563 : }
31564 :
31565 0 : if ( p_endOfConstruct != NULL )
31566 : {
31567 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31568 : {
31569 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
31570 : {
31571 0 : std::cout << "SgOmpReductionClause :: ";
31572 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
31573 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
31574 : }
31575 : }
31576 : else
31577 : {
31578 0 : std::cout << "SgOmpReductionClause :: " << std::flush;
31579 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
31580 0 : std::cout << " not valid " << std::endl;
31581 : }
31582 : }
31583 :
31584 0 : if ( p_parent != NULL )
31585 : {
31586 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31587 : {
31588 0 : if ( p_parent->isInMemoryPool() == false )
31589 : {
31590 0 : std::cout << "SgOmpReductionClause :: ";
31591 0 : std::cout << " p_parent is not in memory pool of ";
31592 0 : std::cout << p_parent->class_name() << std::endl;
31593 : }
31594 : }
31595 : else
31596 : {
31597 0 : std::cout << "SgOmpReductionClause :: " << std::flush;
31598 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
31599 0 : std::cout << " not valid " << std::endl;
31600 : }
31601 : }
31602 :
31603 :
31604 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31605 :
31606 0 : }
31607 :
31608 :
31609 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
31610 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
31611 : bool
31612 0 : SgOmpReductionClause::isInMemoryPool ()
31613 : {
31614 0 : typedef unsigned char* TestType;
31615 :
31616 0 : bool found = false;
31617 :
31618 0 : ROSE_ASSERT(this != NULL);
31619 :
31620 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
31621 :
31622 0 : TestType tested = (TestType) ( this ) ;
31623 :
31624 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpReductionClause::pools.begin();
31625 :
31626 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
31627 : // while (found == false && block < Memory_Block_List.end())
31628 0 : while ( (found == false) && (block != SgOmpReductionClause::pools.end()) )
31629 : {
31630 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpReductionClause::pool_size * sizeof(SgOmpReductionClause) ) ) ;
31631 0 : ++block;
31632 : }
31633 :
31634 : // Special handling for static data
31635 :
31636 :
31637 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
31638 0 : ROSE_ASSERT(found == true);
31639 :
31640 0 : return found;
31641 : }
31642 : /* #line 31643 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
31643 :
31644 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
31645 :
31646 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31647 :
31648 : /* #line 31649 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
31649 :
31650 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31651 :
31652 : void
31653 0 : SgOmpInReductionClause::checkDataMemberPointersIfInMemoryPool()
31654 : {
31655 : // ------------ checking pointers of SgOmpInReductionClause -------------------
31656 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31657 :
31658 0 : if ( p_user_defined_identifier != NULL )
31659 : {
31660 0 : if ( p_user_defined_identifier->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31661 : {
31662 0 : if ( p_user_defined_identifier->isInMemoryPool() == false )
31663 : {
31664 0 : std::cout << "SgOmpInReductionClause :: ";
31665 0 : std::cout << " p_user_defined_identifier is not in memory pool of ";
31666 0 : std::cout << p_user_defined_identifier->class_name() << std::endl;
31667 : }
31668 : }
31669 : else
31670 : {
31671 0 : std::cout << "SgOmpInReductionClause :: " << std::flush;
31672 0 : std::cout << "SgExpression* p_user_defined_identifier = " << p_user_defined_identifier << " --> " << std::flush;
31673 0 : std::cout << " not valid " << std::endl;
31674 : }
31675 : }
31676 :
31677 0 : if ( p_variables != NULL )
31678 : {
31679 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31680 : {
31681 0 : if ( p_variables->isInMemoryPool() == false )
31682 : {
31683 0 : std::cout << "SgOmpInReductionClause :: ";
31684 0 : std::cout << " p_variables is not in memory pool of ";
31685 0 : std::cout << p_variables->class_name() << std::endl;
31686 : }
31687 : }
31688 : else
31689 : {
31690 0 : std::cout << "SgOmpInReductionClause :: " << std::flush;
31691 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
31692 0 : std::cout << " not valid " << std::endl;
31693 : }
31694 : }
31695 :
31696 0 : if ( p_startOfConstruct != NULL )
31697 : {
31698 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31699 : {
31700 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
31701 : {
31702 0 : std::cout << "SgOmpInReductionClause :: ";
31703 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
31704 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
31705 : }
31706 : }
31707 : else
31708 : {
31709 0 : std::cout << "SgOmpInReductionClause :: " << std::flush;
31710 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
31711 0 : std::cout << " not valid " << std::endl;
31712 : }
31713 : }
31714 :
31715 0 : if ( p_endOfConstruct != NULL )
31716 : {
31717 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31718 : {
31719 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
31720 : {
31721 0 : std::cout << "SgOmpInReductionClause :: ";
31722 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
31723 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
31724 : }
31725 : }
31726 : else
31727 : {
31728 0 : std::cout << "SgOmpInReductionClause :: " << std::flush;
31729 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
31730 0 : std::cout << " not valid " << std::endl;
31731 : }
31732 : }
31733 :
31734 0 : if ( p_parent != NULL )
31735 : {
31736 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31737 : {
31738 0 : if ( p_parent->isInMemoryPool() == false )
31739 : {
31740 0 : std::cout << "SgOmpInReductionClause :: ";
31741 0 : std::cout << " p_parent is not in memory pool of ";
31742 0 : std::cout << p_parent->class_name() << std::endl;
31743 : }
31744 : }
31745 : else
31746 : {
31747 0 : std::cout << "SgOmpInReductionClause :: " << std::flush;
31748 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
31749 0 : std::cout << " not valid " << std::endl;
31750 : }
31751 : }
31752 :
31753 :
31754 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31755 :
31756 0 : }
31757 :
31758 :
31759 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
31760 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
31761 : bool
31762 0 : SgOmpInReductionClause::isInMemoryPool ()
31763 : {
31764 0 : typedef unsigned char* TestType;
31765 :
31766 0 : bool found = false;
31767 :
31768 0 : ROSE_ASSERT(this != NULL);
31769 :
31770 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
31771 :
31772 0 : TestType tested = (TestType) ( this ) ;
31773 :
31774 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpInReductionClause::pools.begin();
31775 :
31776 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
31777 : // while (found == false && block < Memory_Block_List.end())
31778 0 : while ( (found == false) && (block != SgOmpInReductionClause::pools.end()) )
31779 : {
31780 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpInReductionClause::pool_size * sizeof(SgOmpInReductionClause) ) ) ;
31781 0 : ++block;
31782 : }
31783 :
31784 : // Special handling for static data
31785 :
31786 :
31787 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
31788 0 : ROSE_ASSERT(found == true);
31789 :
31790 0 : return found;
31791 : }
31792 : /* #line 31793 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
31793 :
31794 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
31795 :
31796 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31797 :
31798 : /* #line 31799 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
31799 :
31800 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31801 :
31802 : void
31803 0 : SgOmpTaskReductionClause::checkDataMemberPointersIfInMemoryPool()
31804 : {
31805 : // ------------ checking pointers of SgOmpTaskReductionClause -------------------
31806 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31807 :
31808 0 : if ( p_user_defined_identifier != NULL )
31809 : {
31810 0 : if ( p_user_defined_identifier->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31811 : {
31812 0 : if ( p_user_defined_identifier->isInMemoryPool() == false )
31813 : {
31814 0 : std::cout << "SgOmpTaskReductionClause :: ";
31815 0 : std::cout << " p_user_defined_identifier is not in memory pool of ";
31816 0 : std::cout << p_user_defined_identifier->class_name() << std::endl;
31817 : }
31818 : }
31819 : else
31820 : {
31821 0 : std::cout << "SgOmpTaskReductionClause :: " << std::flush;
31822 0 : std::cout << "SgExpression* p_user_defined_identifier = " << p_user_defined_identifier << " --> " << std::flush;
31823 0 : std::cout << " not valid " << std::endl;
31824 : }
31825 : }
31826 :
31827 0 : if ( p_variables != NULL )
31828 : {
31829 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31830 : {
31831 0 : if ( p_variables->isInMemoryPool() == false )
31832 : {
31833 0 : std::cout << "SgOmpTaskReductionClause :: ";
31834 0 : std::cout << " p_variables is not in memory pool of ";
31835 0 : std::cout << p_variables->class_name() << std::endl;
31836 : }
31837 : }
31838 : else
31839 : {
31840 0 : std::cout << "SgOmpTaskReductionClause :: " << std::flush;
31841 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
31842 0 : std::cout << " not valid " << std::endl;
31843 : }
31844 : }
31845 :
31846 0 : if ( p_startOfConstruct != NULL )
31847 : {
31848 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31849 : {
31850 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
31851 : {
31852 0 : std::cout << "SgOmpTaskReductionClause :: ";
31853 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
31854 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
31855 : }
31856 : }
31857 : else
31858 : {
31859 0 : std::cout << "SgOmpTaskReductionClause :: " << std::flush;
31860 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
31861 0 : std::cout << " not valid " << std::endl;
31862 : }
31863 : }
31864 :
31865 0 : if ( p_endOfConstruct != NULL )
31866 : {
31867 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31868 : {
31869 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
31870 : {
31871 0 : std::cout << "SgOmpTaskReductionClause :: ";
31872 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
31873 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
31874 : }
31875 : }
31876 : else
31877 : {
31878 0 : std::cout << "SgOmpTaskReductionClause :: " << std::flush;
31879 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
31880 0 : std::cout << " not valid " << std::endl;
31881 : }
31882 : }
31883 :
31884 0 : if ( p_parent != NULL )
31885 : {
31886 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31887 : {
31888 0 : if ( p_parent->isInMemoryPool() == false )
31889 : {
31890 0 : std::cout << "SgOmpTaskReductionClause :: ";
31891 0 : std::cout << " p_parent is not in memory pool of ";
31892 0 : std::cout << p_parent->class_name() << std::endl;
31893 : }
31894 : }
31895 : else
31896 : {
31897 0 : std::cout << "SgOmpTaskReductionClause :: " << std::flush;
31898 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
31899 0 : std::cout << " not valid " << std::endl;
31900 : }
31901 : }
31902 :
31903 :
31904 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31905 :
31906 0 : }
31907 :
31908 :
31909 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
31910 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
31911 : bool
31912 0 : SgOmpTaskReductionClause::isInMemoryPool ()
31913 : {
31914 0 : typedef unsigned char* TestType;
31915 :
31916 0 : bool found = false;
31917 :
31918 0 : ROSE_ASSERT(this != NULL);
31919 :
31920 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
31921 :
31922 0 : TestType tested = (TestType) ( this ) ;
31923 :
31924 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTaskReductionClause::pools.begin();
31925 :
31926 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
31927 : // while (found == false && block < Memory_Block_List.end())
31928 0 : while ( (found == false) && (block != SgOmpTaskReductionClause::pools.end()) )
31929 : {
31930 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTaskReductionClause::pool_size * sizeof(SgOmpTaskReductionClause) ) ) ;
31931 0 : ++block;
31932 : }
31933 :
31934 : // Special handling for static data
31935 :
31936 :
31937 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
31938 0 : ROSE_ASSERT(found == true);
31939 :
31940 0 : return found;
31941 : }
31942 : /* #line 31943 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
31943 :
31944 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
31945 :
31946 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31947 :
31948 : /* #line 31949 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
31949 :
31950 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
31951 :
31952 : void
31953 0 : SgOmpMapClause::checkDataMemberPointersIfInMemoryPool()
31954 : {
31955 : // ------------ checking pointers of SgOmpMapClause -------------------
31956 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31957 :
31958 0 : if ( p_variables != NULL )
31959 : {
31960 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31961 : {
31962 0 : if ( p_variables->isInMemoryPool() == false )
31963 : {
31964 0 : std::cout << "SgOmpMapClause :: ";
31965 0 : std::cout << " p_variables is not in memory pool of ";
31966 0 : std::cout << p_variables->class_name() << std::endl;
31967 : }
31968 : }
31969 : else
31970 : {
31971 0 : std::cout << "SgOmpMapClause :: " << std::flush;
31972 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
31973 0 : std::cout << " not valid " << std::endl;
31974 : }
31975 : }
31976 :
31977 0 : if ( p_startOfConstruct != NULL )
31978 : {
31979 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31980 : {
31981 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
31982 : {
31983 0 : std::cout << "SgOmpMapClause :: ";
31984 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
31985 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
31986 : }
31987 : }
31988 : else
31989 : {
31990 0 : std::cout << "SgOmpMapClause :: " << std::flush;
31991 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
31992 0 : std::cout << " not valid " << std::endl;
31993 : }
31994 : }
31995 :
31996 0 : if ( p_endOfConstruct != NULL )
31997 : {
31998 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
31999 : {
32000 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
32001 : {
32002 0 : std::cout << "SgOmpMapClause :: ";
32003 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
32004 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
32005 : }
32006 : }
32007 : else
32008 : {
32009 0 : std::cout << "SgOmpMapClause :: " << std::flush;
32010 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
32011 0 : std::cout << " not valid " << std::endl;
32012 : }
32013 : }
32014 :
32015 0 : if ( p_parent != NULL )
32016 : {
32017 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32018 : {
32019 0 : if ( p_parent->isInMemoryPool() == false )
32020 : {
32021 0 : std::cout << "SgOmpMapClause :: ";
32022 0 : std::cout << " p_parent is not in memory pool of ";
32023 0 : std::cout << p_parent->class_name() << std::endl;
32024 : }
32025 : }
32026 : else
32027 : {
32028 0 : std::cout << "SgOmpMapClause :: " << std::flush;
32029 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
32030 0 : std::cout << " not valid " << std::endl;
32031 : }
32032 : }
32033 :
32034 :
32035 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32036 :
32037 0 : }
32038 :
32039 :
32040 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
32041 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
32042 : bool
32043 0 : SgOmpMapClause::isInMemoryPool ()
32044 : {
32045 0 : typedef unsigned char* TestType;
32046 :
32047 0 : bool found = false;
32048 :
32049 0 : ROSE_ASSERT(this != NULL);
32050 :
32051 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
32052 :
32053 0 : TestType tested = (TestType) ( this ) ;
32054 :
32055 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpMapClause::pools.begin();
32056 :
32057 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
32058 : // while (found == false && block < Memory_Block_List.end())
32059 0 : while ( (found == false) && (block != SgOmpMapClause::pools.end()) )
32060 : {
32061 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpMapClause::pool_size * sizeof(SgOmpMapClause) ) ) ;
32062 0 : ++block;
32063 : }
32064 :
32065 : // Special handling for static data
32066 :
32067 :
32068 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
32069 0 : ROSE_ASSERT(found == true);
32070 :
32071 0 : return found;
32072 : }
32073 : /* #line 32074 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
32074 :
32075 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
32076 :
32077 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32078 :
32079 : /* #line 32080 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
32080 :
32081 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32082 :
32083 : void
32084 0 : SgOmpAllocateClause::checkDataMemberPointersIfInMemoryPool()
32085 : {
32086 : // ------------ checking pointers of SgOmpAllocateClause -------------------
32087 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32088 :
32089 0 : if ( p_user_defined_modifier != NULL )
32090 : {
32091 0 : if ( p_user_defined_modifier->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32092 : {
32093 0 : if ( p_user_defined_modifier->isInMemoryPool() == false )
32094 : {
32095 0 : std::cout << "SgOmpAllocateClause :: ";
32096 0 : std::cout << " p_user_defined_modifier is not in memory pool of ";
32097 0 : std::cout << p_user_defined_modifier->class_name() << std::endl;
32098 : }
32099 : }
32100 : else
32101 : {
32102 0 : std::cout << "SgOmpAllocateClause :: " << std::flush;
32103 0 : std::cout << "SgExpression* p_user_defined_modifier = " << p_user_defined_modifier << " --> " << std::flush;
32104 0 : std::cout << " not valid " << std::endl;
32105 : }
32106 : }
32107 :
32108 0 : if ( p_variables != NULL )
32109 : {
32110 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32111 : {
32112 0 : if ( p_variables->isInMemoryPool() == false )
32113 : {
32114 0 : std::cout << "SgOmpAllocateClause :: ";
32115 0 : std::cout << " p_variables is not in memory pool of ";
32116 0 : std::cout << p_variables->class_name() << std::endl;
32117 : }
32118 : }
32119 : else
32120 : {
32121 0 : std::cout << "SgOmpAllocateClause :: " << std::flush;
32122 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
32123 0 : std::cout << " not valid " << std::endl;
32124 : }
32125 : }
32126 :
32127 0 : if ( p_startOfConstruct != NULL )
32128 : {
32129 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32130 : {
32131 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
32132 : {
32133 0 : std::cout << "SgOmpAllocateClause :: ";
32134 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
32135 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
32136 : }
32137 : }
32138 : else
32139 : {
32140 0 : std::cout << "SgOmpAllocateClause :: " << std::flush;
32141 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
32142 0 : std::cout << " not valid " << std::endl;
32143 : }
32144 : }
32145 :
32146 0 : if ( p_endOfConstruct != NULL )
32147 : {
32148 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32149 : {
32150 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
32151 : {
32152 0 : std::cout << "SgOmpAllocateClause :: ";
32153 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
32154 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
32155 : }
32156 : }
32157 : else
32158 : {
32159 0 : std::cout << "SgOmpAllocateClause :: " << std::flush;
32160 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
32161 0 : std::cout << " not valid " << std::endl;
32162 : }
32163 : }
32164 :
32165 0 : if ( p_parent != NULL )
32166 : {
32167 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32168 : {
32169 0 : if ( p_parent->isInMemoryPool() == false )
32170 : {
32171 0 : std::cout << "SgOmpAllocateClause :: ";
32172 0 : std::cout << " p_parent is not in memory pool of ";
32173 0 : std::cout << p_parent->class_name() << std::endl;
32174 : }
32175 : }
32176 : else
32177 : {
32178 0 : std::cout << "SgOmpAllocateClause :: " << std::flush;
32179 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
32180 0 : std::cout << " not valid " << std::endl;
32181 : }
32182 : }
32183 :
32184 :
32185 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32186 :
32187 0 : }
32188 :
32189 :
32190 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
32191 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
32192 : bool
32193 0 : SgOmpAllocateClause::isInMemoryPool ()
32194 : {
32195 0 : typedef unsigned char* TestType;
32196 :
32197 0 : bool found = false;
32198 :
32199 0 : ROSE_ASSERT(this != NULL);
32200 :
32201 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
32202 :
32203 0 : TestType tested = (TestType) ( this ) ;
32204 :
32205 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpAllocateClause::pools.begin();
32206 :
32207 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
32208 : // while (found == false && block < Memory_Block_List.end())
32209 0 : while ( (found == false) && (block != SgOmpAllocateClause::pools.end()) )
32210 : {
32211 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpAllocateClause::pool_size * sizeof(SgOmpAllocateClause) ) ) ;
32212 0 : ++block;
32213 : }
32214 :
32215 : // Special handling for static data
32216 :
32217 :
32218 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
32219 0 : ROSE_ASSERT(found == true);
32220 :
32221 0 : return found;
32222 : }
32223 : /* #line 32224 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
32224 :
32225 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
32226 :
32227 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32228 :
32229 : /* #line 32230 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
32230 :
32231 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32232 :
32233 : void
32234 0 : SgOmpUniformClause::checkDataMemberPointersIfInMemoryPool()
32235 : {
32236 : // ------------ checking pointers of SgOmpUniformClause -------------------
32237 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32238 :
32239 0 : if ( p_variables != NULL )
32240 : {
32241 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32242 : {
32243 0 : if ( p_variables->isInMemoryPool() == false )
32244 : {
32245 0 : std::cout << "SgOmpUniformClause :: ";
32246 0 : std::cout << " p_variables is not in memory pool of ";
32247 0 : std::cout << p_variables->class_name() << std::endl;
32248 : }
32249 : }
32250 : else
32251 : {
32252 0 : std::cout << "SgOmpUniformClause :: " << std::flush;
32253 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
32254 0 : std::cout << " not valid " << std::endl;
32255 : }
32256 : }
32257 :
32258 0 : if ( p_startOfConstruct != NULL )
32259 : {
32260 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32261 : {
32262 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
32263 : {
32264 0 : std::cout << "SgOmpUniformClause :: ";
32265 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
32266 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
32267 : }
32268 : }
32269 : else
32270 : {
32271 0 : std::cout << "SgOmpUniformClause :: " << std::flush;
32272 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
32273 0 : std::cout << " not valid " << std::endl;
32274 : }
32275 : }
32276 :
32277 0 : if ( p_endOfConstruct != NULL )
32278 : {
32279 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32280 : {
32281 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
32282 : {
32283 0 : std::cout << "SgOmpUniformClause :: ";
32284 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
32285 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
32286 : }
32287 : }
32288 : else
32289 : {
32290 0 : std::cout << "SgOmpUniformClause :: " << std::flush;
32291 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
32292 0 : std::cout << " not valid " << std::endl;
32293 : }
32294 : }
32295 :
32296 0 : if ( p_parent != NULL )
32297 : {
32298 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32299 : {
32300 0 : if ( p_parent->isInMemoryPool() == false )
32301 : {
32302 0 : std::cout << "SgOmpUniformClause :: ";
32303 0 : std::cout << " p_parent is not in memory pool of ";
32304 0 : std::cout << p_parent->class_name() << std::endl;
32305 : }
32306 : }
32307 : else
32308 : {
32309 0 : std::cout << "SgOmpUniformClause :: " << std::flush;
32310 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
32311 0 : std::cout << " not valid " << std::endl;
32312 : }
32313 : }
32314 :
32315 :
32316 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32317 :
32318 0 : }
32319 :
32320 :
32321 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
32322 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
32323 : bool
32324 0 : SgOmpUniformClause::isInMemoryPool ()
32325 : {
32326 0 : typedef unsigned char* TestType;
32327 :
32328 0 : bool found = false;
32329 :
32330 0 : ROSE_ASSERT(this != NULL);
32331 :
32332 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
32333 :
32334 0 : TestType tested = (TestType) ( this ) ;
32335 :
32336 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpUniformClause::pools.begin();
32337 :
32338 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
32339 : // while (found == false && block < Memory_Block_List.end())
32340 0 : while ( (found == false) && (block != SgOmpUniformClause::pools.end()) )
32341 : {
32342 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpUniformClause::pool_size * sizeof(SgOmpUniformClause) ) ) ;
32343 0 : ++block;
32344 : }
32345 :
32346 : // Special handling for static data
32347 :
32348 :
32349 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
32350 0 : ROSE_ASSERT(found == true);
32351 :
32352 0 : return found;
32353 : }
32354 : /* #line 32355 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
32355 :
32356 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
32357 :
32358 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32359 :
32360 : /* #line 32361 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
32361 :
32362 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32363 :
32364 : void
32365 0 : SgOmpAlignedClause::checkDataMemberPointersIfInMemoryPool()
32366 : {
32367 : // ------------ checking pointers of SgOmpAlignedClause -------------------
32368 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32369 :
32370 0 : if ( p_alignment != NULL )
32371 : {
32372 0 : if ( p_alignment->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32373 : {
32374 0 : if ( p_alignment->isInMemoryPool() == false )
32375 : {
32376 0 : std::cout << "SgOmpAlignedClause :: ";
32377 0 : std::cout << " p_alignment is not in memory pool of ";
32378 0 : std::cout << p_alignment->class_name() << std::endl;
32379 : }
32380 : }
32381 : else
32382 : {
32383 0 : std::cout << "SgOmpAlignedClause :: " << std::flush;
32384 0 : std::cout << "SgExpression* p_alignment = " << p_alignment << " --> " << std::flush;
32385 0 : std::cout << " not valid " << std::endl;
32386 : }
32387 : }
32388 :
32389 0 : if ( p_variables != NULL )
32390 : {
32391 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32392 : {
32393 0 : if ( p_variables->isInMemoryPool() == false )
32394 : {
32395 0 : std::cout << "SgOmpAlignedClause :: ";
32396 0 : std::cout << " p_variables is not in memory pool of ";
32397 0 : std::cout << p_variables->class_name() << std::endl;
32398 : }
32399 : }
32400 : else
32401 : {
32402 0 : std::cout << "SgOmpAlignedClause :: " << std::flush;
32403 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
32404 0 : std::cout << " not valid " << std::endl;
32405 : }
32406 : }
32407 :
32408 0 : if ( p_startOfConstruct != NULL )
32409 : {
32410 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32411 : {
32412 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
32413 : {
32414 0 : std::cout << "SgOmpAlignedClause :: ";
32415 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
32416 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
32417 : }
32418 : }
32419 : else
32420 : {
32421 0 : std::cout << "SgOmpAlignedClause :: " << std::flush;
32422 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
32423 0 : std::cout << " not valid " << std::endl;
32424 : }
32425 : }
32426 :
32427 0 : if ( p_endOfConstruct != NULL )
32428 : {
32429 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32430 : {
32431 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
32432 : {
32433 0 : std::cout << "SgOmpAlignedClause :: ";
32434 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
32435 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
32436 : }
32437 : }
32438 : else
32439 : {
32440 0 : std::cout << "SgOmpAlignedClause :: " << std::flush;
32441 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
32442 0 : std::cout << " not valid " << std::endl;
32443 : }
32444 : }
32445 :
32446 0 : if ( p_parent != NULL )
32447 : {
32448 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32449 : {
32450 0 : if ( p_parent->isInMemoryPool() == false )
32451 : {
32452 0 : std::cout << "SgOmpAlignedClause :: ";
32453 0 : std::cout << " p_parent is not in memory pool of ";
32454 0 : std::cout << p_parent->class_name() << std::endl;
32455 : }
32456 : }
32457 : else
32458 : {
32459 0 : std::cout << "SgOmpAlignedClause :: " << std::flush;
32460 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
32461 0 : std::cout << " not valid " << std::endl;
32462 : }
32463 : }
32464 :
32465 :
32466 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32467 :
32468 0 : }
32469 :
32470 :
32471 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
32472 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
32473 : bool
32474 0 : SgOmpAlignedClause::isInMemoryPool ()
32475 : {
32476 0 : typedef unsigned char* TestType;
32477 :
32478 0 : bool found = false;
32479 :
32480 0 : ROSE_ASSERT(this != NULL);
32481 :
32482 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
32483 :
32484 0 : TestType tested = (TestType) ( this ) ;
32485 :
32486 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpAlignedClause::pools.begin();
32487 :
32488 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
32489 : // while (found == false && block < Memory_Block_List.end())
32490 0 : while ( (found == false) && (block != SgOmpAlignedClause::pools.end()) )
32491 : {
32492 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpAlignedClause::pool_size * sizeof(SgOmpAlignedClause) ) ) ;
32493 0 : ++block;
32494 : }
32495 :
32496 : // Special handling for static data
32497 :
32498 :
32499 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
32500 0 : ROSE_ASSERT(found == true);
32501 :
32502 0 : return found;
32503 : }
32504 : /* #line 32505 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
32505 :
32506 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
32507 :
32508 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32509 :
32510 : /* #line 32511 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
32511 :
32512 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32513 :
32514 : void
32515 0 : SgOmpLinearClause::checkDataMemberPointersIfInMemoryPool()
32516 : {
32517 : // ------------ checking pointers of SgOmpLinearClause -------------------
32518 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32519 :
32520 0 : if ( p_step != NULL )
32521 : {
32522 0 : if ( p_step->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32523 : {
32524 0 : if ( p_step->isInMemoryPool() == false )
32525 : {
32526 0 : std::cout << "SgOmpLinearClause :: ";
32527 0 : std::cout << " p_step is not in memory pool of ";
32528 0 : std::cout << p_step->class_name() << std::endl;
32529 : }
32530 : }
32531 : else
32532 : {
32533 0 : std::cout << "SgOmpLinearClause :: " << std::flush;
32534 0 : std::cout << "SgExpression* p_step = " << p_step << " --> " << std::flush;
32535 0 : std::cout << " not valid " << std::endl;
32536 : }
32537 : }
32538 :
32539 0 : if ( p_variables != NULL )
32540 : {
32541 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32542 : {
32543 0 : if ( p_variables->isInMemoryPool() == false )
32544 : {
32545 0 : std::cout << "SgOmpLinearClause :: ";
32546 0 : std::cout << " p_variables is not in memory pool of ";
32547 0 : std::cout << p_variables->class_name() << std::endl;
32548 : }
32549 : }
32550 : else
32551 : {
32552 0 : std::cout << "SgOmpLinearClause :: " << std::flush;
32553 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
32554 0 : std::cout << " not valid " << std::endl;
32555 : }
32556 : }
32557 :
32558 0 : if ( p_startOfConstruct != NULL )
32559 : {
32560 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32561 : {
32562 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
32563 : {
32564 0 : std::cout << "SgOmpLinearClause :: ";
32565 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
32566 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
32567 : }
32568 : }
32569 : else
32570 : {
32571 0 : std::cout << "SgOmpLinearClause :: " << std::flush;
32572 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
32573 0 : std::cout << " not valid " << std::endl;
32574 : }
32575 : }
32576 :
32577 0 : if ( p_endOfConstruct != NULL )
32578 : {
32579 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32580 : {
32581 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
32582 : {
32583 0 : std::cout << "SgOmpLinearClause :: ";
32584 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
32585 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
32586 : }
32587 : }
32588 : else
32589 : {
32590 0 : std::cout << "SgOmpLinearClause :: " << std::flush;
32591 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
32592 0 : std::cout << " not valid " << std::endl;
32593 : }
32594 : }
32595 :
32596 0 : if ( p_parent != NULL )
32597 : {
32598 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32599 : {
32600 0 : if ( p_parent->isInMemoryPool() == false )
32601 : {
32602 0 : std::cout << "SgOmpLinearClause :: ";
32603 0 : std::cout << " p_parent is not in memory pool of ";
32604 0 : std::cout << p_parent->class_name() << std::endl;
32605 : }
32606 : }
32607 : else
32608 : {
32609 0 : std::cout << "SgOmpLinearClause :: " << std::flush;
32610 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
32611 0 : std::cout << " not valid " << std::endl;
32612 : }
32613 : }
32614 :
32615 :
32616 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32617 :
32618 0 : }
32619 :
32620 :
32621 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
32622 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
32623 : bool
32624 0 : SgOmpLinearClause::isInMemoryPool ()
32625 : {
32626 0 : typedef unsigned char* TestType;
32627 :
32628 0 : bool found = false;
32629 :
32630 0 : ROSE_ASSERT(this != NULL);
32631 :
32632 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
32633 :
32634 0 : TestType tested = (TestType) ( this ) ;
32635 :
32636 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpLinearClause::pools.begin();
32637 :
32638 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
32639 : // while (found == false && block < Memory_Block_List.end())
32640 0 : while ( (found == false) && (block != SgOmpLinearClause::pools.end()) )
32641 : {
32642 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpLinearClause::pool_size * sizeof(SgOmpLinearClause) ) ) ;
32643 0 : ++block;
32644 : }
32645 :
32646 : // Special handling for static data
32647 :
32648 :
32649 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
32650 0 : ROSE_ASSERT(found == true);
32651 :
32652 0 : return found;
32653 : }
32654 : /* #line 32655 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
32655 :
32656 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
32657 :
32658 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32659 :
32660 : /* #line 32661 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
32661 :
32662 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32663 :
32664 : void
32665 0 : SgOmpDependClause::checkDataMemberPointersIfInMemoryPool()
32666 : {
32667 : // ------------ checking pointers of SgOmpDependClause -------------------
32668 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32669 :
32670 0 : if ( p_variables != NULL )
32671 : {
32672 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32673 : {
32674 0 : if ( p_variables->isInMemoryPool() == false )
32675 : {
32676 0 : std::cout << "SgOmpDependClause :: ";
32677 0 : std::cout << " p_variables is not in memory pool of ";
32678 0 : std::cout << p_variables->class_name() << std::endl;
32679 : }
32680 : }
32681 : else
32682 : {
32683 0 : std::cout << "SgOmpDependClause :: " << std::flush;
32684 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
32685 0 : std::cout << " not valid " << std::endl;
32686 : }
32687 : }
32688 :
32689 0 : if ( p_startOfConstruct != NULL )
32690 : {
32691 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32692 : {
32693 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
32694 : {
32695 0 : std::cout << "SgOmpDependClause :: ";
32696 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
32697 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
32698 : }
32699 : }
32700 : else
32701 : {
32702 0 : std::cout << "SgOmpDependClause :: " << std::flush;
32703 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
32704 0 : std::cout << " not valid " << std::endl;
32705 : }
32706 : }
32707 :
32708 0 : if ( p_endOfConstruct != NULL )
32709 : {
32710 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32711 : {
32712 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
32713 : {
32714 0 : std::cout << "SgOmpDependClause :: ";
32715 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
32716 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
32717 : }
32718 : }
32719 : else
32720 : {
32721 0 : std::cout << "SgOmpDependClause :: " << std::flush;
32722 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
32723 0 : std::cout << " not valid " << std::endl;
32724 : }
32725 : }
32726 :
32727 0 : if ( p_parent != NULL )
32728 : {
32729 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32730 : {
32731 0 : if ( p_parent->isInMemoryPool() == false )
32732 : {
32733 0 : std::cout << "SgOmpDependClause :: ";
32734 0 : std::cout << " p_parent is not in memory pool of ";
32735 0 : std::cout << p_parent->class_name() << std::endl;
32736 : }
32737 : }
32738 : else
32739 : {
32740 0 : std::cout << "SgOmpDependClause :: " << std::flush;
32741 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
32742 0 : std::cout << " not valid " << std::endl;
32743 : }
32744 : }
32745 :
32746 :
32747 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32748 :
32749 0 : }
32750 :
32751 :
32752 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
32753 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
32754 : bool
32755 0 : SgOmpDependClause::isInMemoryPool ()
32756 : {
32757 0 : typedef unsigned char* TestType;
32758 :
32759 0 : bool found = false;
32760 :
32761 0 : ROSE_ASSERT(this != NULL);
32762 :
32763 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
32764 :
32765 0 : TestType tested = (TestType) ( this ) ;
32766 :
32767 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDependClause::pools.begin();
32768 :
32769 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
32770 : // while (found == false && block < Memory_Block_List.end())
32771 0 : while ( (found == false) && (block != SgOmpDependClause::pools.end()) )
32772 : {
32773 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDependClause::pool_size * sizeof(SgOmpDependClause) ) ) ;
32774 0 : ++block;
32775 : }
32776 :
32777 : // Special handling for static data
32778 :
32779 :
32780 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
32781 0 : ROSE_ASSERT(found == true);
32782 :
32783 0 : return found;
32784 : }
32785 : /* #line 32786 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
32786 :
32787 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
32788 :
32789 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32790 :
32791 : /* #line 32792 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
32792 :
32793 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32794 :
32795 : void
32796 0 : SgOmpAffinityClause::checkDataMemberPointersIfInMemoryPool()
32797 : {
32798 : // ------------ checking pointers of SgOmpAffinityClause -------------------
32799 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32800 :
32801 0 : if ( p_variables != NULL )
32802 : {
32803 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32804 : {
32805 0 : if ( p_variables->isInMemoryPool() == false )
32806 : {
32807 0 : std::cout << "SgOmpAffinityClause :: ";
32808 0 : std::cout << " p_variables is not in memory pool of ";
32809 0 : std::cout << p_variables->class_name() << std::endl;
32810 : }
32811 : }
32812 : else
32813 : {
32814 0 : std::cout << "SgOmpAffinityClause :: " << std::flush;
32815 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
32816 0 : std::cout << " not valid " << std::endl;
32817 : }
32818 : }
32819 :
32820 0 : if ( p_startOfConstruct != NULL )
32821 : {
32822 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32823 : {
32824 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
32825 : {
32826 0 : std::cout << "SgOmpAffinityClause :: ";
32827 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
32828 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
32829 : }
32830 : }
32831 : else
32832 : {
32833 0 : std::cout << "SgOmpAffinityClause :: " << std::flush;
32834 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
32835 0 : std::cout << " not valid " << std::endl;
32836 : }
32837 : }
32838 :
32839 0 : if ( p_endOfConstruct != NULL )
32840 : {
32841 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32842 : {
32843 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
32844 : {
32845 0 : std::cout << "SgOmpAffinityClause :: ";
32846 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
32847 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
32848 : }
32849 : }
32850 : else
32851 : {
32852 0 : std::cout << "SgOmpAffinityClause :: " << std::flush;
32853 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
32854 0 : std::cout << " not valid " << std::endl;
32855 : }
32856 : }
32857 :
32858 0 : if ( p_parent != NULL )
32859 : {
32860 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32861 : {
32862 0 : if ( p_parent->isInMemoryPool() == false )
32863 : {
32864 0 : std::cout << "SgOmpAffinityClause :: ";
32865 0 : std::cout << " p_parent is not in memory pool of ";
32866 0 : std::cout << p_parent->class_name() << std::endl;
32867 : }
32868 : }
32869 : else
32870 : {
32871 0 : std::cout << "SgOmpAffinityClause :: " << std::flush;
32872 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
32873 0 : std::cout << " not valid " << std::endl;
32874 : }
32875 : }
32876 :
32877 :
32878 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32879 :
32880 0 : }
32881 :
32882 :
32883 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
32884 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
32885 : bool
32886 0 : SgOmpAffinityClause::isInMemoryPool ()
32887 : {
32888 0 : typedef unsigned char* TestType;
32889 :
32890 0 : bool found = false;
32891 :
32892 0 : ROSE_ASSERT(this != NULL);
32893 :
32894 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
32895 :
32896 0 : TestType tested = (TestType) ( this ) ;
32897 :
32898 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpAffinityClause::pools.begin();
32899 :
32900 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
32901 : // while (found == false && block < Memory_Block_List.end())
32902 0 : while ( (found == false) && (block != SgOmpAffinityClause::pools.end()) )
32903 : {
32904 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpAffinityClause::pool_size * sizeof(SgOmpAffinityClause) ) ) ;
32905 0 : ++block;
32906 : }
32907 :
32908 : // Special handling for static data
32909 :
32910 :
32911 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
32912 0 : ROSE_ASSERT(found == true);
32913 :
32914 0 : return found;
32915 : }
32916 : /* #line 32917 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
32917 :
32918 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
32919 :
32920 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32921 :
32922 : /* #line 32923 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
32923 :
32924 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
32925 :
32926 : void
32927 0 : SgOmpToClause::checkDataMemberPointersIfInMemoryPool()
32928 : {
32929 : // ------------ checking pointers of SgOmpToClause -------------------
32930 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32931 :
32932 0 : if ( p_mapper_identifier != NULL )
32933 : {
32934 0 : if ( p_mapper_identifier->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32935 : {
32936 0 : if ( p_mapper_identifier->isInMemoryPool() == false )
32937 : {
32938 0 : std::cout << "SgOmpToClause :: ";
32939 0 : std::cout << " p_mapper_identifier is not in memory pool of ";
32940 0 : std::cout << p_mapper_identifier->class_name() << std::endl;
32941 : }
32942 : }
32943 : else
32944 : {
32945 0 : std::cout << "SgOmpToClause :: " << std::flush;
32946 0 : std::cout << "SgExpression* p_mapper_identifier = " << p_mapper_identifier << " --> " << std::flush;
32947 0 : std::cout << " not valid " << std::endl;
32948 : }
32949 : }
32950 :
32951 0 : if ( p_variables != NULL )
32952 : {
32953 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32954 : {
32955 0 : if ( p_variables->isInMemoryPool() == false )
32956 : {
32957 0 : std::cout << "SgOmpToClause :: ";
32958 0 : std::cout << " p_variables is not in memory pool of ";
32959 0 : std::cout << p_variables->class_name() << std::endl;
32960 : }
32961 : }
32962 : else
32963 : {
32964 0 : std::cout << "SgOmpToClause :: " << std::flush;
32965 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
32966 0 : std::cout << " not valid " << std::endl;
32967 : }
32968 : }
32969 :
32970 0 : if ( p_startOfConstruct != NULL )
32971 : {
32972 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32973 : {
32974 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
32975 : {
32976 0 : std::cout << "SgOmpToClause :: ";
32977 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
32978 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
32979 : }
32980 : }
32981 : else
32982 : {
32983 0 : std::cout << "SgOmpToClause :: " << std::flush;
32984 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
32985 0 : std::cout << " not valid " << std::endl;
32986 : }
32987 : }
32988 :
32989 0 : if ( p_endOfConstruct != NULL )
32990 : {
32991 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
32992 : {
32993 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
32994 : {
32995 0 : std::cout << "SgOmpToClause :: ";
32996 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
32997 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
32998 : }
32999 : }
33000 : else
33001 : {
33002 0 : std::cout << "SgOmpToClause :: " << std::flush;
33003 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
33004 0 : std::cout << " not valid " << std::endl;
33005 : }
33006 : }
33007 :
33008 0 : if ( p_parent != NULL )
33009 : {
33010 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33011 : {
33012 0 : if ( p_parent->isInMemoryPool() == false )
33013 : {
33014 0 : std::cout << "SgOmpToClause :: ";
33015 0 : std::cout << " p_parent is not in memory pool of ";
33016 0 : std::cout << p_parent->class_name() << std::endl;
33017 : }
33018 : }
33019 : else
33020 : {
33021 0 : std::cout << "SgOmpToClause :: " << std::flush;
33022 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
33023 0 : std::cout << " not valid " << std::endl;
33024 : }
33025 : }
33026 :
33027 :
33028 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33029 :
33030 0 : }
33031 :
33032 :
33033 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
33034 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
33035 : bool
33036 0 : SgOmpToClause::isInMemoryPool ()
33037 : {
33038 0 : typedef unsigned char* TestType;
33039 :
33040 0 : bool found = false;
33041 :
33042 0 : ROSE_ASSERT(this != NULL);
33043 :
33044 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
33045 :
33046 0 : TestType tested = (TestType) ( this ) ;
33047 :
33048 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpToClause::pools.begin();
33049 :
33050 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
33051 : // while (found == false && block < Memory_Block_List.end())
33052 0 : while ( (found == false) && (block != SgOmpToClause::pools.end()) )
33053 : {
33054 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpToClause::pool_size * sizeof(SgOmpToClause) ) ) ;
33055 0 : ++block;
33056 : }
33057 :
33058 : // Special handling for static data
33059 :
33060 :
33061 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
33062 0 : ROSE_ASSERT(found == true);
33063 :
33064 0 : return found;
33065 : }
33066 : /* #line 33067 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
33067 :
33068 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
33069 :
33070 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33071 :
33072 : /* #line 33073 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
33073 :
33074 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33075 :
33076 : void
33077 0 : SgOmpFromClause::checkDataMemberPointersIfInMemoryPool()
33078 : {
33079 : // ------------ checking pointers of SgOmpFromClause -------------------
33080 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33081 :
33082 0 : if ( p_mapper_identifier != NULL )
33083 : {
33084 0 : if ( p_mapper_identifier->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33085 : {
33086 0 : if ( p_mapper_identifier->isInMemoryPool() == false )
33087 : {
33088 0 : std::cout << "SgOmpFromClause :: ";
33089 0 : std::cout << " p_mapper_identifier is not in memory pool of ";
33090 0 : std::cout << p_mapper_identifier->class_name() << std::endl;
33091 : }
33092 : }
33093 : else
33094 : {
33095 0 : std::cout << "SgOmpFromClause :: " << std::flush;
33096 0 : std::cout << "SgExpression* p_mapper_identifier = " << p_mapper_identifier << " --> " << std::flush;
33097 0 : std::cout << " not valid " << std::endl;
33098 : }
33099 : }
33100 :
33101 0 : if ( p_variables != NULL )
33102 : {
33103 0 : if ( p_variables->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33104 : {
33105 0 : if ( p_variables->isInMemoryPool() == false )
33106 : {
33107 0 : std::cout << "SgOmpFromClause :: ";
33108 0 : std::cout << " p_variables is not in memory pool of ";
33109 0 : std::cout << p_variables->class_name() << std::endl;
33110 : }
33111 : }
33112 : else
33113 : {
33114 0 : std::cout << "SgOmpFromClause :: " << std::flush;
33115 0 : std::cout << "SgExprListExp* p_variables = " << p_variables << " --> " << std::flush;
33116 0 : std::cout << " not valid " << std::endl;
33117 : }
33118 : }
33119 :
33120 0 : if ( p_startOfConstruct != NULL )
33121 : {
33122 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33123 : {
33124 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
33125 : {
33126 0 : std::cout << "SgOmpFromClause :: ";
33127 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
33128 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
33129 : }
33130 : }
33131 : else
33132 : {
33133 0 : std::cout << "SgOmpFromClause :: " << std::flush;
33134 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
33135 0 : std::cout << " not valid " << std::endl;
33136 : }
33137 : }
33138 :
33139 0 : if ( p_endOfConstruct != NULL )
33140 : {
33141 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33142 : {
33143 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
33144 : {
33145 0 : std::cout << "SgOmpFromClause :: ";
33146 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
33147 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
33148 : }
33149 : }
33150 : else
33151 : {
33152 0 : std::cout << "SgOmpFromClause :: " << std::flush;
33153 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
33154 0 : std::cout << " not valid " << std::endl;
33155 : }
33156 : }
33157 :
33158 0 : if ( p_parent != NULL )
33159 : {
33160 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33161 : {
33162 0 : if ( p_parent->isInMemoryPool() == false )
33163 : {
33164 0 : std::cout << "SgOmpFromClause :: ";
33165 0 : std::cout << " p_parent is not in memory pool of ";
33166 0 : std::cout << p_parent->class_name() << std::endl;
33167 : }
33168 : }
33169 : else
33170 : {
33171 0 : std::cout << "SgOmpFromClause :: " << std::flush;
33172 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
33173 0 : std::cout << " not valid " << std::endl;
33174 : }
33175 : }
33176 :
33177 :
33178 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33179 :
33180 0 : }
33181 :
33182 :
33183 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
33184 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
33185 : bool
33186 0 : SgOmpFromClause::isInMemoryPool ()
33187 : {
33188 0 : typedef unsigned char* TestType;
33189 :
33190 0 : bool found = false;
33191 :
33192 0 : ROSE_ASSERT(this != NULL);
33193 :
33194 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
33195 :
33196 0 : TestType tested = (TestType) ( this ) ;
33197 :
33198 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpFromClause::pools.begin();
33199 :
33200 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
33201 : // while (found == false && block < Memory_Block_List.end())
33202 0 : while ( (found == false) && (block != SgOmpFromClause::pools.end()) )
33203 : {
33204 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpFromClause::pool_size * sizeof(SgOmpFromClause) ) ) ;
33205 0 : ++block;
33206 : }
33207 :
33208 : // Special handling for static data
33209 :
33210 :
33211 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
33212 0 : ROSE_ASSERT(found == true);
33213 :
33214 0 : return found;
33215 : }
33216 : /* #line 33217 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
33217 :
33218 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
33219 :
33220 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33221 :
33222 : /* #line 33223 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
33223 :
33224 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33225 :
33226 : void
33227 0 : SgOmpScheduleClause::checkDataMemberPointersIfInMemoryPool()
33228 : {
33229 : // ------------ checking pointers of SgOmpScheduleClause -------------------
33230 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33231 :
33232 0 : if ( p_chunk_size != NULL )
33233 : {
33234 0 : if ( p_chunk_size->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33235 : {
33236 0 : if ( p_chunk_size->isInMemoryPool() == false )
33237 : {
33238 0 : std::cout << "SgOmpScheduleClause :: ";
33239 0 : std::cout << " p_chunk_size is not in memory pool of ";
33240 0 : std::cout << p_chunk_size->class_name() << std::endl;
33241 : }
33242 : }
33243 : else
33244 : {
33245 0 : std::cout << "SgOmpScheduleClause :: " << std::flush;
33246 0 : std::cout << "SgExpression* p_chunk_size = " << p_chunk_size << " --> " << std::flush;
33247 0 : std::cout << " not valid " << std::endl;
33248 : }
33249 : }
33250 :
33251 0 : if ( p_startOfConstruct != NULL )
33252 : {
33253 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33254 : {
33255 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
33256 : {
33257 0 : std::cout << "SgOmpScheduleClause :: ";
33258 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
33259 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
33260 : }
33261 : }
33262 : else
33263 : {
33264 0 : std::cout << "SgOmpScheduleClause :: " << std::flush;
33265 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
33266 0 : std::cout << " not valid " << std::endl;
33267 : }
33268 : }
33269 :
33270 0 : if ( p_endOfConstruct != NULL )
33271 : {
33272 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33273 : {
33274 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
33275 : {
33276 0 : std::cout << "SgOmpScheduleClause :: ";
33277 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
33278 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
33279 : }
33280 : }
33281 : else
33282 : {
33283 0 : std::cout << "SgOmpScheduleClause :: " << std::flush;
33284 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
33285 0 : std::cout << " not valid " << std::endl;
33286 : }
33287 : }
33288 :
33289 0 : if ( p_parent != NULL )
33290 : {
33291 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33292 : {
33293 0 : if ( p_parent->isInMemoryPool() == false )
33294 : {
33295 0 : std::cout << "SgOmpScheduleClause :: ";
33296 0 : std::cout << " p_parent is not in memory pool of ";
33297 0 : std::cout << p_parent->class_name() << std::endl;
33298 : }
33299 : }
33300 : else
33301 : {
33302 0 : std::cout << "SgOmpScheduleClause :: " << std::flush;
33303 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
33304 0 : std::cout << " not valid " << std::endl;
33305 : }
33306 : }
33307 :
33308 :
33309 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33310 :
33311 0 : }
33312 :
33313 :
33314 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
33315 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
33316 : bool
33317 0 : SgOmpScheduleClause::isInMemoryPool ()
33318 : {
33319 0 : typedef unsigned char* TestType;
33320 :
33321 0 : bool found = false;
33322 :
33323 0 : ROSE_ASSERT(this != NULL);
33324 :
33325 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
33326 :
33327 0 : TestType tested = (TestType) ( this ) ;
33328 :
33329 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpScheduleClause::pools.begin();
33330 :
33331 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
33332 : // while (found == false && block < Memory_Block_List.end())
33333 0 : while ( (found == false) && (block != SgOmpScheduleClause::pools.end()) )
33334 : {
33335 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpScheduleClause::pool_size * sizeof(SgOmpScheduleClause) ) ) ;
33336 0 : ++block;
33337 : }
33338 :
33339 : // Special handling for static data
33340 :
33341 :
33342 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
33343 0 : ROSE_ASSERT(found == true);
33344 :
33345 0 : return found;
33346 : }
33347 : /* #line 33348 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
33348 :
33349 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
33350 :
33351 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33352 :
33353 : /* #line 33354 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
33354 :
33355 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33356 :
33357 : void
33358 0 : SgOmpMergeableClause::checkDataMemberPointersIfInMemoryPool()
33359 : {
33360 : // ------------ checking pointers of SgOmpMergeableClause -------------------
33361 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33362 :
33363 0 : if ( p_startOfConstruct != NULL )
33364 : {
33365 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33366 : {
33367 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
33368 : {
33369 0 : std::cout << "SgOmpMergeableClause :: ";
33370 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
33371 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
33372 : }
33373 : }
33374 : else
33375 : {
33376 0 : std::cout << "SgOmpMergeableClause :: " << std::flush;
33377 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
33378 0 : std::cout << " not valid " << std::endl;
33379 : }
33380 : }
33381 :
33382 0 : if ( p_endOfConstruct != NULL )
33383 : {
33384 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33385 : {
33386 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
33387 : {
33388 0 : std::cout << "SgOmpMergeableClause :: ";
33389 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
33390 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
33391 : }
33392 : }
33393 : else
33394 : {
33395 0 : std::cout << "SgOmpMergeableClause :: " << std::flush;
33396 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
33397 0 : std::cout << " not valid " << std::endl;
33398 : }
33399 : }
33400 :
33401 0 : if ( p_parent != NULL )
33402 : {
33403 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33404 : {
33405 0 : if ( p_parent->isInMemoryPool() == false )
33406 : {
33407 0 : std::cout << "SgOmpMergeableClause :: ";
33408 0 : std::cout << " p_parent is not in memory pool of ";
33409 0 : std::cout << p_parent->class_name() << std::endl;
33410 : }
33411 : }
33412 : else
33413 : {
33414 0 : std::cout << "SgOmpMergeableClause :: " << std::flush;
33415 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
33416 0 : std::cout << " not valid " << std::endl;
33417 : }
33418 : }
33419 :
33420 :
33421 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33422 :
33423 0 : }
33424 :
33425 :
33426 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
33427 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
33428 : bool
33429 0 : SgOmpMergeableClause::isInMemoryPool ()
33430 : {
33431 0 : typedef unsigned char* TestType;
33432 :
33433 0 : bool found = false;
33434 :
33435 0 : ROSE_ASSERT(this != NULL);
33436 :
33437 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
33438 :
33439 0 : TestType tested = (TestType) ( this ) ;
33440 :
33441 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpMergeableClause::pools.begin();
33442 :
33443 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
33444 : // while (found == false && block < Memory_Block_List.end())
33445 0 : while ( (found == false) && (block != SgOmpMergeableClause::pools.end()) )
33446 : {
33447 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpMergeableClause::pool_size * sizeof(SgOmpMergeableClause) ) ) ;
33448 0 : ++block;
33449 : }
33450 :
33451 : // Special handling for static data
33452 :
33453 :
33454 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
33455 0 : ROSE_ASSERT(found == true);
33456 :
33457 0 : return found;
33458 : }
33459 : /* #line 33460 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
33460 :
33461 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
33462 :
33463 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33464 :
33465 : /* #line 33466 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
33466 :
33467 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33468 :
33469 : void
33470 0 : SgOmpWhenClause::checkDataMemberPointersIfInMemoryPool()
33471 : {
33472 : // ------------ checking pointers of SgOmpWhenClause -------------------
33473 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33474 :
33475 0 : if ( p_user_condition != NULL )
33476 : {
33477 0 : if ( p_user_condition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33478 : {
33479 0 : if ( p_user_condition->isInMemoryPool() == false )
33480 : {
33481 0 : std::cout << "SgOmpWhenClause :: ";
33482 0 : std::cout << " p_user_condition is not in memory pool of ";
33483 0 : std::cout << p_user_condition->class_name() << std::endl;
33484 : }
33485 : }
33486 : else
33487 : {
33488 0 : std::cout << "SgOmpWhenClause :: " << std::flush;
33489 0 : std::cout << "SgExpression* p_user_condition = " << p_user_condition << " --> " << std::flush;
33490 0 : std::cout << " not valid " << std::endl;
33491 : }
33492 : }
33493 :
33494 0 : if ( p_user_condition_score != NULL )
33495 : {
33496 0 : if ( p_user_condition_score->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33497 : {
33498 0 : if ( p_user_condition_score->isInMemoryPool() == false )
33499 : {
33500 0 : std::cout << "SgOmpWhenClause :: ";
33501 0 : std::cout << " p_user_condition_score is not in memory pool of ";
33502 0 : std::cout << p_user_condition_score->class_name() << std::endl;
33503 : }
33504 : }
33505 : else
33506 : {
33507 0 : std::cout << "SgOmpWhenClause :: " << std::flush;
33508 0 : std::cout << "SgExpression* p_user_condition_score = " << p_user_condition_score << " --> " << std::flush;
33509 0 : std::cout << " not valid " << std::endl;
33510 : }
33511 : }
33512 :
33513 0 : if ( p_device_arch != NULL )
33514 : {
33515 0 : if ( p_device_arch->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33516 : {
33517 0 : if ( p_device_arch->isInMemoryPool() == false )
33518 : {
33519 0 : std::cout << "SgOmpWhenClause :: ";
33520 0 : std::cout << " p_device_arch is not in memory pool of ";
33521 0 : std::cout << p_device_arch->class_name() << std::endl;
33522 : }
33523 : }
33524 : else
33525 : {
33526 0 : std::cout << "SgOmpWhenClause :: " << std::flush;
33527 0 : std::cout << "SgExpression* p_device_arch = " << p_device_arch << " --> " << std::flush;
33528 0 : std::cout << " not valid " << std::endl;
33529 : }
33530 : }
33531 :
33532 0 : if ( p_device_isa != NULL )
33533 : {
33534 0 : if ( p_device_isa->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33535 : {
33536 0 : if ( p_device_isa->isInMemoryPool() == false )
33537 : {
33538 0 : std::cout << "SgOmpWhenClause :: ";
33539 0 : std::cout << " p_device_isa is not in memory pool of ";
33540 0 : std::cout << p_device_isa->class_name() << std::endl;
33541 : }
33542 : }
33543 : else
33544 : {
33545 0 : std::cout << "SgOmpWhenClause :: " << std::flush;
33546 0 : std::cout << "SgExpression* p_device_isa = " << p_device_isa << " --> " << std::flush;
33547 0 : std::cout << " not valid " << std::endl;
33548 : }
33549 : }
33550 :
33551 0 : if ( p_implementation_user_defined != NULL )
33552 : {
33553 0 : if ( p_implementation_user_defined->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33554 : {
33555 0 : if ( p_implementation_user_defined->isInMemoryPool() == false )
33556 : {
33557 0 : std::cout << "SgOmpWhenClause :: ";
33558 0 : std::cout << " p_implementation_user_defined is not in memory pool of ";
33559 0 : std::cout << p_implementation_user_defined->class_name() << std::endl;
33560 : }
33561 : }
33562 : else
33563 : {
33564 0 : std::cout << "SgOmpWhenClause :: " << std::flush;
33565 0 : std::cout << "SgExpression* p_implementation_user_defined = " << p_implementation_user_defined << " --> " << std::flush;
33566 0 : std::cout << " not valid " << std::endl;
33567 : }
33568 : }
33569 :
33570 0 : if ( p_implementation_extension != NULL )
33571 : {
33572 0 : if ( p_implementation_extension->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33573 : {
33574 0 : if ( p_implementation_extension->isInMemoryPool() == false )
33575 : {
33576 0 : std::cout << "SgOmpWhenClause :: ";
33577 0 : std::cout << " p_implementation_extension is not in memory pool of ";
33578 0 : std::cout << p_implementation_extension->class_name() << std::endl;
33579 : }
33580 : }
33581 : else
33582 : {
33583 0 : std::cout << "SgOmpWhenClause :: " << std::flush;
33584 0 : std::cout << "SgExpression* p_implementation_extension = " << p_implementation_extension << " --> " << std::flush;
33585 0 : std::cout << " not valid " << std::endl;
33586 : }
33587 : }
33588 :
33589 0 : if ( p_variant_directive != NULL )
33590 : {
33591 0 : if ( p_variant_directive->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33592 : {
33593 0 : if ( p_variant_directive->isInMemoryPool() == false )
33594 : {
33595 0 : std::cout << "SgOmpWhenClause :: ";
33596 0 : std::cout << " p_variant_directive is not in memory pool of ";
33597 0 : std::cout << p_variant_directive->class_name() << std::endl;
33598 : }
33599 : }
33600 : else
33601 : {
33602 0 : std::cout << "SgOmpWhenClause :: " << std::flush;
33603 0 : std::cout << "SgStatement* p_variant_directive = " << p_variant_directive << " --> " << std::flush;
33604 0 : std::cout << " not valid " << std::endl;
33605 : }
33606 : }
33607 :
33608 0 : if ( p_startOfConstruct != NULL )
33609 : {
33610 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33611 : {
33612 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
33613 : {
33614 0 : std::cout << "SgOmpWhenClause :: ";
33615 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
33616 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
33617 : }
33618 : }
33619 : else
33620 : {
33621 0 : std::cout << "SgOmpWhenClause :: " << std::flush;
33622 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
33623 0 : std::cout << " not valid " << std::endl;
33624 : }
33625 : }
33626 :
33627 0 : if ( p_endOfConstruct != NULL )
33628 : {
33629 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33630 : {
33631 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
33632 : {
33633 0 : std::cout << "SgOmpWhenClause :: ";
33634 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
33635 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
33636 : }
33637 : }
33638 : else
33639 : {
33640 0 : std::cout << "SgOmpWhenClause :: " << std::flush;
33641 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
33642 0 : std::cout << " not valid " << std::endl;
33643 : }
33644 : }
33645 :
33646 0 : if ( p_parent != NULL )
33647 : {
33648 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33649 : {
33650 0 : if ( p_parent->isInMemoryPool() == false )
33651 : {
33652 0 : std::cout << "SgOmpWhenClause :: ";
33653 0 : std::cout << " p_parent is not in memory pool of ";
33654 0 : std::cout << p_parent->class_name() << std::endl;
33655 : }
33656 : }
33657 : else
33658 : {
33659 0 : std::cout << "SgOmpWhenClause :: " << std::flush;
33660 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
33661 0 : std::cout << " not valid " << std::endl;
33662 : }
33663 : }
33664 :
33665 :
33666 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33667 :
33668 0 : }
33669 :
33670 :
33671 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
33672 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
33673 : bool
33674 0 : SgOmpWhenClause::isInMemoryPool ()
33675 : {
33676 0 : typedef unsigned char* TestType;
33677 :
33678 0 : bool found = false;
33679 :
33680 0 : ROSE_ASSERT(this != NULL);
33681 :
33682 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
33683 :
33684 0 : TestType tested = (TestType) ( this ) ;
33685 :
33686 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpWhenClause::pools.begin();
33687 :
33688 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
33689 : // while (found == false && block < Memory_Block_List.end())
33690 0 : while ( (found == false) && (block != SgOmpWhenClause::pools.end()) )
33691 : {
33692 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpWhenClause::pool_size * sizeof(SgOmpWhenClause) ) ) ;
33693 0 : ++block;
33694 : }
33695 :
33696 : // Special handling for static data
33697 :
33698 :
33699 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
33700 0 : ROSE_ASSERT(found == true);
33701 :
33702 0 : return found;
33703 : }
33704 : /* #line 33705 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
33705 :
33706 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
33707 :
33708 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33709 :
33710 : /* #line 33711 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
33711 :
33712 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33713 :
33714 : void
33715 0 : SgOmpUsesAllocatorsClause::checkDataMemberPointersIfInMemoryPool()
33716 : {
33717 : // ------------ checking pointers of SgOmpUsesAllocatorsClause -------------------
33718 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33719 :
33720 0 : if ( p_startOfConstruct != NULL )
33721 : {
33722 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33723 : {
33724 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
33725 : {
33726 0 : std::cout << "SgOmpUsesAllocatorsClause :: ";
33727 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
33728 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
33729 : }
33730 : }
33731 : else
33732 : {
33733 0 : std::cout << "SgOmpUsesAllocatorsClause :: " << std::flush;
33734 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
33735 0 : std::cout << " not valid " << std::endl;
33736 : }
33737 : }
33738 :
33739 0 : if ( p_endOfConstruct != NULL )
33740 : {
33741 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33742 : {
33743 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
33744 : {
33745 0 : std::cout << "SgOmpUsesAllocatorsClause :: ";
33746 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
33747 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
33748 : }
33749 : }
33750 : else
33751 : {
33752 0 : std::cout << "SgOmpUsesAllocatorsClause :: " << std::flush;
33753 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
33754 0 : std::cout << " not valid " << std::endl;
33755 : }
33756 : }
33757 :
33758 0 : if ( p_parent != NULL )
33759 : {
33760 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33761 : {
33762 0 : if ( p_parent->isInMemoryPool() == false )
33763 : {
33764 0 : std::cout << "SgOmpUsesAllocatorsClause :: ";
33765 0 : std::cout << " p_parent is not in memory pool of ";
33766 0 : std::cout << p_parent->class_name() << std::endl;
33767 : }
33768 : }
33769 : else
33770 : {
33771 0 : std::cout << "SgOmpUsesAllocatorsClause :: " << std::flush;
33772 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
33773 0 : std::cout << " not valid " << std::endl;
33774 : }
33775 : }
33776 :
33777 :
33778 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33779 :
33780 0 : }
33781 :
33782 :
33783 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
33784 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
33785 : bool
33786 0 : SgOmpUsesAllocatorsClause::isInMemoryPool ()
33787 : {
33788 0 : typedef unsigned char* TestType;
33789 :
33790 0 : bool found = false;
33791 :
33792 0 : ROSE_ASSERT(this != NULL);
33793 :
33794 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
33795 :
33796 0 : TestType tested = (TestType) ( this ) ;
33797 :
33798 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpUsesAllocatorsClause::pools.begin();
33799 :
33800 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
33801 : // while (found == false && block < Memory_Block_List.end())
33802 0 : while ( (found == false) && (block != SgOmpUsesAllocatorsClause::pools.end()) )
33803 : {
33804 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpUsesAllocatorsClause::pool_size * sizeof(SgOmpUsesAllocatorsClause) ) ) ;
33805 0 : ++block;
33806 : }
33807 :
33808 : // Special handling for static data
33809 :
33810 :
33811 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
33812 0 : ROSE_ASSERT(found == true);
33813 :
33814 0 : return found;
33815 : }
33816 : /* #line 33817 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
33817 :
33818 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
33819 :
33820 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33821 :
33822 : /* #line 33823 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
33823 :
33824 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33825 :
33826 : void
33827 0 : SgOmpFullClause::checkDataMemberPointersIfInMemoryPool()
33828 : {
33829 : // ------------ checking pointers of SgOmpFullClause -------------------
33830 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33831 :
33832 0 : if ( p_startOfConstruct != NULL )
33833 : {
33834 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33835 : {
33836 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
33837 : {
33838 0 : std::cout << "SgOmpFullClause :: ";
33839 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
33840 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
33841 : }
33842 : }
33843 : else
33844 : {
33845 0 : std::cout << "SgOmpFullClause :: " << std::flush;
33846 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
33847 0 : std::cout << " not valid " << std::endl;
33848 : }
33849 : }
33850 :
33851 0 : if ( p_endOfConstruct != NULL )
33852 : {
33853 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33854 : {
33855 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
33856 : {
33857 0 : std::cout << "SgOmpFullClause :: ";
33858 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
33859 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
33860 : }
33861 : }
33862 : else
33863 : {
33864 0 : std::cout << "SgOmpFullClause :: " << std::flush;
33865 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
33866 0 : std::cout << " not valid " << std::endl;
33867 : }
33868 : }
33869 :
33870 0 : if ( p_parent != NULL )
33871 : {
33872 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33873 : {
33874 0 : if ( p_parent->isInMemoryPool() == false )
33875 : {
33876 0 : std::cout << "SgOmpFullClause :: ";
33877 0 : std::cout << " p_parent is not in memory pool of ";
33878 0 : std::cout << p_parent->class_name() << std::endl;
33879 : }
33880 : }
33881 : else
33882 : {
33883 0 : std::cout << "SgOmpFullClause :: " << std::flush;
33884 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
33885 0 : std::cout << " not valid " << std::endl;
33886 : }
33887 : }
33888 :
33889 :
33890 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33891 :
33892 0 : }
33893 :
33894 :
33895 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
33896 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
33897 : bool
33898 0 : SgOmpFullClause::isInMemoryPool ()
33899 : {
33900 0 : typedef unsigned char* TestType;
33901 :
33902 0 : bool found = false;
33903 :
33904 0 : ROSE_ASSERT(this != NULL);
33905 :
33906 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
33907 :
33908 0 : TestType tested = (TestType) ( this ) ;
33909 :
33910 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpFullClause::pools.begin();
33911 :
33912 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
33913 : // while (found == false && block < Memory_Block_List.end())
33914 0 : while ( (found == false) && (block != SgOmpFullClause::pools.end()) )
33915 : {
33916 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpFullClause::pool_size * sizeof(SgOmpFullClause) ) ) ;
33917 0 : ++block;
33918 : }
33919 :
33920 : // Special handling for static data
33921 :
33922 :
33923 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
33924 0 : ROSE_ASSERT(found == true);
33925 :
33926 0 : return found;
33927 : }
33928 : /* #line 33929 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
33929 :
33930 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
33931 :
33932 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33933 :
33934 : /* #line 33935 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
33935 :
33936 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
33937 :
33938 : void
33939 0 : SgUpirBranchField::checkDataMemberPointersIfInMemoryPool()
33940 : {
33941 : // ------------ checking pointers of SgUpirBranchField -------------------
33942 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33943 :
33944 0 : if ( p_startOfConstruct != NULL )
33945 : {
33946 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33947 : {
33948 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
33949 : {
33950 0 : std::cout << "SgUpirBranchField :: ";
33951 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
33952 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
33953 : }
33954 : }
33955 : else
33956 : {
33957 0 : std::cout << "SgUpirBranchField :: " << std::flush;
33958 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
33959 0 : std::cout << " not valid " << std::endl;
33960 : }
33961 : }
33962 :
33963 0 : if ( p_endOfConstruct != NULL )
33964 : {
33965 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33966 : {
33967 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
33968 : {
33969 0 : std::cout << "SgUpirBranchField :: ";
33970 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
33971 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
33972 : }
33973 : }
33974 : else
33975 : {
33976 0 : std::cout << "SgUpirBranchField :: " << std::flush;
33977 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
33978 0 : std::cout << " not valid " << std::endl;
33979 : }
33980 : }
33981 :
33982 0 : if ( p_parent != NULL )
33983 : {
33984 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
33985 : {
33986 0 : if ( p_parent->isInMemoryPool() == false )
33987 : {
33988 0 : std::cout << "SgUpirBranchField :: ";
33989 0 : std::cout << " p_parent is not in memory pool of ";
33990 0 : std::cout << p_parent->class_name() << std::endl;
33991 : }
33992 : }
33993 : else
33994 : {
33995 0 : std::cout << "SgUpirBranchField :: " << std::flush;
33996 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
33997 0 : std::cout << " not valid " << std::endl;
33998 : }
33999 : }
34000 :
34001 :
34002 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34003 :
34004 0 : }
34005 :
34006 :
34007 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
34008 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
34009 : bool
34010 0 : SgUpirBranchField::isInMemoryPool ()
34011 : {
34012 0 : typedef unsigned char* TestType;
34013 :
34014 0 : bool found = false;
34015 :
34016 0 : ROSE_ASSERT(this != NULL);
34017 :
34018 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
34019 :
34020 0 : TestType tested = (TestType) ( this ) ;
34021 :
34022 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirBranchField::pools.begin();
34023 :
34024 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
34025 : // while (found == false && block < Memory_Block_List.end())
34026 0 : while ( (found == false) && (block != SgUpirBranchField::pools.end()) )
34027 : {
34028 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirBranchField::pool_size * sizeof(SgUpirBranchField) ) ) ;
34029 0 : ++block;
34030 : }
34031 :
34032 : // Special handling for static data
34033 :
34034 :
34035 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
34036 0 : ROSE_ASSERT(found == true);
34037 :
34038 0 : return found;
34039 : }
34040 : /* #line 34041 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
34041 :
34042 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
34043 :
34044 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34045 :
34046 : /* #line 34047 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
34047 :
34048 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34049 :
34050 : void
34051 0 : SgUpirNestedLevelField::checkDataMemberPointersIfInMemoryPool()
34052 : {
34053 : // ------------ checking pointers of SgUpirNestedLevelField -------------------
34054 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34055 :
34056 0 : if ( p_startOfConstruct != NULL )
34057 : {
34058 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34059 : {
34060 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
34061 : {
34062 0 : std::cout << "SgUpirNestedLevelField :: ";
34063 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
34064 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
34065 : }
34066 : }
34067 : else
34068 : {
34069 0 : std::cout << "SgUpirNestedLevelField :: " << std::flush;
34070 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
34071 0 : std::cout << " not valid " << std::endl;
34072 : }
34073 : }
34074 :
34075 0 : if ( p_endOfConstruct != NULL )
34076 : {
34077 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34078 : {
34079 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
34080 : {
34081 0 : std::cout << "SgUpirNestedLevelField :: ";
34082 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
34083 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
34084 : }
34085 : }
34086 : else
34087 : {
34088 0 : std::cout << "SgUpirNestedLevelField :: " << std::flush;
34089 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
34090 0 : std::cout << " not valid " << std::endl;
34091 : }
34092 : }
34093 :
34094 0 : if ( p_parent != NULL )
34095 : {
34096 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34097 : {
34098 0 : if ( p_parent->isInMemoryPool() == false )
34099 : {
34100 0 : std::cout << "SgUpirNestedLevelField :: ";
34101 0 : std::cout << " p_parent is not in memory pool of ";
34102 0 : std::cout << p_parent->class_name() << std::endl;
34103 : }
34104 : }
34105 : else
34106 : {
34107 0 : std::cout << "SgUpirNestedLevelField :: " << std::flush;
34108 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
34109 0 : std::cout << " not valid " << std::endl;
34110 : }
34111 : }
34112 :
34113 :
34114 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34115 :
34116 0 : }
34117 :
34118 :
34119 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
34120 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
34121 : bool
34122 0 : SgUpirNestedLevelField::isInMemoryPool ()
34123 : {
34124 0 : typedef unsigned char* TestType;
34125 :
34126 0 : bool found = false;
34127 :
34128 0 : ROSE_ASSERT(this != NULL);
34129 :
34130 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
34131 :
34132 0 : TestType tested = (TestType) ( this ) ;
34133 :
34134 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirNestedLevelField::pools.begin();
34135 :
34136 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
34137 : // while (found == false && block < Memory_Block_List.end())
34138 0 : while ( (found == false) && (block != SgUpirNestedLevelField::pools.end()) )
34139 : {
34140 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirNestedLevelField::pool_size * sizeof(SgUpirNestedLevelField) ) ) ;
34141 0 : ++block;
34142 : }
34143 :
34144 : // Special handling for static data
34145 :
34146 :
34147 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
34148 0 : ROSE_ASSERT(found == true);
34149 :
34150 0 : return found;
34151 : }
34152 : /* #line 34153 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
34153 :
34154 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
34155 :
34156 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34157 :
34158 : /* #line 34159 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
34159 :
34160 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34161 :
34162 : void
34163 0 : SgUpirNestedParentField::checkDataMemberPointersIfInMemoryPool()
34164 : {
34165 : // ------------ checking pointers of SgUpirNestedParentField -------------------
34166 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34167 :
34168 0 : if ( p_nested_parent != NULL )
34169 : {
34170 0 : if ( p_nested_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34171 : {
34172 0 : if ( p_nested_parent->isInMemoryPool() == false )
34173 : {
34174 0 : std::cout << "SgUpirNestedParentField :: ";
34175 0 : std::cout << " p_nested_parent is not in memory pool of ";
34176 0 : std::cout << p_nested_parent->class_name() << std::endl;
34177 : }
34178 : }
34179 : else
34180 : {
34181 0 : std::cout << "SgUpirNestedParentField :: " << std::flush;
34182 0 : std::cout << "SgStatement* p_nested_parent = " << p_nested_parent << " --> " << std::flush;
34183 0 : std::cout << " not valid " << std::endl;
34184 : }
34185 : }
34186 :
34187 0 : if ( p_startOfConstruct != NULL )
34188 : {
34189 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34190 : {
34191 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
34192 : {
34193 0 : std::cout << "SgUpirNestedParentField :: ";
34194 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
34195 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
34196 : }
34197 : }
34198 : else
34199 : {
34200 0 : std::cout << "SgUpirNestedParentField :: " << std::flush;
34201 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
34202 0 : std::cout << " not valid " << std::endl;
34203 : }
34204 : }
34205 :
34206 0 : if ( p_endOfConstruct != NULL )
34207 : {
34208 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34209 : {
34210 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
34211 : {
34212 0 : std::cout << "SgUpirNestedParentField :: ";
34213 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
34214 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
34215 : }
34216 : }
34217 : else
34218 : {
34219 0 : std::cout << "SgUpirNestedParentField :: " << std::flush;
34220 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
34221 0 : std::cout << " not valid " << std::endl;
34222 : }
34223 : }
34224 :
34225 0 : if ( p_parent != NULL )
34226 : {
34227 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34228 : {
34229 0 : if ( p_parent->isInMemoryPool() == false )
34230 : {
34231 0 : std::cout << "SgUpirNestedParentField :: ";
34232 0 : std::cout << " p_parent is not in memory pool of ";
34233 0 : std::cout << p_parent->class_name() << std::endl;
34234 : }
34235 : }
34236 : else
34237 : {
34238 0 : std::cout << "SgUpirNestedParentField :: " << std::flush;
34239 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
34240 0 : std::cout << " not valid " << std::endl;
34241 : }
34242 : }
34243 :
34244 :
34245 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34246 :
34247 0 : }
34248 :
34249 :
34250 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
34251 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
34252 : bool
34253 0 : SgUpirNestedParentField::isInMemoryPool ()
34254 : {
34255 0 : typedef unsigned char* TestType;
34256 :
34257 0 : bool found = false;
34258 :
34259 0 : ROSE_ASSERT(this != NULL);
34260 :
34261 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
34262 :
34263 0 : TestType tested = (TestType) ( this ) ;
34264 :
34265 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirNestedParentField::pools.begin();
34266 :
34267 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
34268 : // while (found == false && block < Memory_Block_List.end())
34269 0 : while ( (found == false) && (block != SgUpirNestedParentField::pools.end()) )
34270 : {
34271 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirNestedParentField::pool_size * sizeof(SgUpirNestedParentField) ) ) ;
34272 0 : ++block;
34273 : }
34274 :
34275 : // Special handling for static data
34276 :
34277 :
34278 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
34279 0 : ROSE_ASSERT(found == true);
34280 :
34281 0 : return found;
34282 : }
34283 : /* #line 34284 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
34284 :
34285 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
34286 :
34287 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34288 :
34289 : /* #line 34290 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
34290 :
34291 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34292 :
34293 : void
34294 0 : SgUpirNestedChildField::checkDataMemberPointersIfInMemoryPool()
34295 : {
34296 : // ------------ checking pointers of SgUpirNestedChildField -------------------
34297 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34298 :
34299 0 : if ( p_nested_child != NULL )
34300 : {
34301 0 : if ( p_nested_child->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34302 : {
34303 0 : if ( p_nested_child->isInMemoryPool() == false )
34304 : {
34305 0 : std::cout << "SgUpirNestedChildField :: ";
34306 0 : std::cout << " p_nested_child is not in memory pool of ";
34307 0 : std::cout << p_nested_child->class_name() << std::endl;
34308 : }
34309 : }
34310 : else
34311 : {
34312 0 : std::cout << "SgUpirNestedChildField :: " << std::flush;
34313 0 : std::cout << "SgStatement* p_nested_child = " << p_nested_child << " --> " << std::flush;
34314 0 : std::cout << " not valid " << std::endl;
34315 : }
34316 : }
34317 :
34318 0 : if ( p_startOfConstruct != NULL )
34319 : {
34320 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34321 : {
34322 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
34323 : {
34324 0 : std::cout << "SgUpirNestedChildField :: ";
34325 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
34326 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
34327 : }
34328 : }
34329 : else
34330 : {
34331 0 : std::cout << "SgUpirNestedChildField :: " << std::flush;
34332 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
34333 0 : std::cout << " not valid " << std::endl;
34334 : }
34335 : }
34336 :
34337 0 : if ( p_endOfConstruct != NULL )
34338 : {
34339 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34340 : {
34341 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
34342 : {
34343 0 : std::cout << "SgUpirNestedChildField :: ";
34344 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
34345 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
34346 : }
34347 : }
34348 : else
34349 : {
34350 0 : std::cout << "SgUpirNestedChildField :: " << std::flush;
34351 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
34352 0 : std::cout << " not valid " << std::endl;
34353 : }
34354 : }
34355 :
34356 0 : if ( p_parent != NULL )
34357 : {
34358 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34359 : {
34360 0 : if ( p_parent->isInMemoryPool() == false )
34361 : {
34362 0 : std::cout << "SgUpirNestedChildField :: ";
34363 0 : std::cout << " p_parent is not in memory pool of ";
34364 0 : std::cout << p_parent->class_name() << std::endl;
34365 : }
34366 : }
34367 : else
34368 : {
34369 0 : std::cout << "SgUpirNestedChildField :: " << std::flush;
34370 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
34371 0 : std::cout << " not valid " << std::endl;
34372 : }
34373 : }
34374 :
34375 :
34376 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34377 :
34378 0 : }
34379 :
34380 :
34381 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
34382 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
34383 : bool
34384 0 : SgUpirNestedChildField::isInMemoryPool ()
34385 : {
34386 0 : typedef unsigned char* TestType;
34387 :
34388 0 : bool found = false;
34389 :
34390 0 : ROSE_ASSERT(this != NULL);
34391 :
34392 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
34393 :
34394 0 : TestType tested = (TestType) ( this ) ;
34395 :
34396 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirNestedChildField::pools.begin();
34397 :
34398 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
34399 : // while (found == false && block < Memory_Block_List.end())
34400 0 : while ( (found == false) && (block != SgUpirNestedChildField::pools.end()) )
34401 : {
34402 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirNestedChildField::pool_size * sizeof(SgUpirNestedChildField) ) ) ;
34403 0 : ++block;
34404 : }
34405 :
34406 : // Special handling for static data
34407 :
34408 :
34409 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
34410 0 : ROSE_ASSERT(found == true);
34411 :
34412 0 : return found;
34413 : }
34414 : /* #line 34415 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
34415 :
34416 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
34417 :
34418 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34419 :
34420 : /* #line 34421 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
34421 :
34422 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34423 :
34424 : void
34425 0 : SgUpirSyncField::checkDataMemberPointersIfInMemoryPool()
34426 : {
34427 : // ------------ checking pointers of SgUpirSyncField -------------------
34428 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34429 :
34430 0 : if ( p_sync != NULL )
34431 : {
34432 0 : if ( p_sync->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34433 : {
34434 0 : if ( p_sync->isInMemoryPool() == false )
34435 : {
34436 0 : std::cout << "SgUpirSyncField :: ";
34437 0 : std::cout << " p_sync is not in memory pool of ";
34438 0 : std::cout << p_sync->class_name() << std::endl;
34439 : }
34440 : }
34441 : else
34442 : {
34443 0 : std::cout << "SgUpirSyncField :: " << std::flush;
34444 0 : std::cout << "SgStatement* p_sync = " << p_sync << " --> " << std::flush;
34445 0 : std::cout << " not valid " << std::endl;
34446 : }
34447 : }
34448 :
34449 0 : if ( p_startOfConstruct != NULL )
34450 : {
34451 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34452 : {
34453 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
34454 : {
34455 0 : std::cout << "SgUpirSyncField :: ";
34456 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
34457 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
34458 : }
34459 : }
34460 : else
34461 : {
34462 0 : std::cout << "SgUpirSyncField :: " << std::flush;
34463 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
34464 0 : std::cout << " not valid " << std::endl;
34465 : }
34466 : }
34467 :
34468 0 : if ( p_endOfConstruct != NULL )
34469 : {
34470 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34471 : {
34472 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
34473 : {
34474 0 : std::cout << "SgUpirSyncField :: ";
34475 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
34476 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
34477 : }
34478 : }
34479 : else
34480 : {
34481 0 : std::cout << "SgUpirSyncField :: " << std::flush;
34482 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
34483 0 : std::cout << " not valid " << std::endl;
34484 : }
34485 : }
34486 :
34487 0 : if ( p_parent != NULL )
34488 : {
34489 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34490 : {
34491 0 : if ( p_parent->isInMemoryPool() == false )
34492 : {
34493 0 : std::cout << "SgUpirSyncField :: ";
34494 0 : std::cout << " p_parent is not in memory pool of ";
34495 0 : std::cout << p_parent->class_name() << std::endl;
34496 : }
34497 : }
34498 : else
34499 : {
34500 0 : std::cout << "SgUpirSyncField :: " << std::flush;
34501 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
34502 0 : std::cout << " not valid " << std::endl;
34503 : }
34504 : }
34505 :
34506 :
34507 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34508 :
34509 0 : }
34510 :
34511 :
34512 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
34513 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
34514 : bool
34515 0 : SgUpirSyncField::isInMemoryPool ()
34516 : {
34517 0 : typedef unsigned char* TestType;
34518 :
34519 0 : bool found = false;
34520 :
34521 0 : ROSE_ASSERT(this != NULL);
34522 :
34523 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
34524 :
34525 0 : TestType tested = (TestType) ( this ) ;
34526 :
34527 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirSyncField::pools.begin();
34528 :
34529 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
34530 : // while (found == false && block < Memory_Block_List.end())
34531 0 : while ( (found == false) && (block != SgUpirSyncField::pools.end()) )
34532 : {
34533 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirSyncField::pool_size * sizeof(SgUpirSyncField) ) ) ;
34534 0 : ++block;
34535 : }
34536 :
34537 : // Special handling for static data
34538 :
34539 :
34540 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
34541 0 : ROSE_ASSERT(found == true);
34542 :
34543 0 : return found;
34544 : }
34545 : /* #line 34546 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
34546 :
34547 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
34548 :
34549 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34550 :
34551 : /* #line 34552 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
34552 :
34553 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34554 :
34555 : void
34556 0 : SgUpirDataField::checkDataMemberPointersIfInMemoryPool()
34557 : {
34558 : // ------------ checking pointers of SgUpirDataField -------------------
34559 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34560 :
34561 0 : if ( p_startOfConstruct != NULL )
34562 : {
34563 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34564 : {
34565 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
34566 : {
34567 0 : std::cout << "SgUpirDataField :: ";
34568 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
34569 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
34570 : }
34571 : }
34572 : else
34573 : {
34574 0 : std::cout << "SgUpirDataField :: " << std::flush;
34575 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
34576 0 : std::cout << " not valid " << std::endl;
34577 : }
34578 : }
34579 :
34580 0 : if ( p_endOfConstruct != NULL )
34581 : {
34582 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34583 : {
34584 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
34585 : {
34586 0 : std::cout << "SgUpirDataField :: ";
34587 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
34588 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
34589 : }
34590 : }
34591 : else
34592 : {
34593 0 : std::cout << "SgUpirDataField :: " << std::flush;
34594 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
34595 0 : std::cout << " not valid " << std::endl;
34596 : }
34597 : }
34598 :
34599 0 : if ( p_parent != NULL )
34600 : {
34601 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34602 : {
34603 0 : if ( p_parent->isInMemoryPool() == false )
34604 : {
34605 0 : std::cout << "SgUpirDataField :: ";
34606 0 : std::cout << " p_parent is not in memory pool of ";
34607 0 : std::cout << p_parent->class_name() << std::endl;
34608 : }
34609 : }
34610 : else
34611 : {
34612 0 : std::cout << "SgUpirDataField :: " << std::flush;
34613 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
34614 0 : std::cout << " not valid " << std::endl;
34615 : }
34616 : }
34617 :
34618 :
34619 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34620 :
34621 0 : }
34622 :
34623 :
34624 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
34625 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
34626 : bool
34627 0 : SgUpirDataField::isInMemoryPool ()
34628 : {
34629 0 : typedef unsigned char* TestType;
34630 :
34631 0 : bool found = false;
34632 :
34633 0 : ROSE_ASSERT(this != NULL);
34634 :
34635 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
34636 :
34637 0 : TestType tested = (TestType) ( this ) ;
34638 :
34639 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirDataField::pools.begin();
34640 :
34641 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
34642 : // while (found == false && block < Memory_Block_List.end())
34643 0 : while ( (found == false) && (block != SgUpirDataField::pools.end()) )
34644 : {
34645 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirDataField::pool_size * sizeof(SgUpirDataField) ) ) ;
34646 0 : ++block;
34647 : }
34648 :
34649 : // Special handling for static data
34650 :
34651 :
34652 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
34653 0 : ROSE_ASSERT(found == true);
34654 :
34655 0 : return found;
34656 : }
34657 : /* #line 34658 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
34658 :
34659 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
34660 :
34661 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34662 :
34663 : /* #line 34664 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
34664 :
34665 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34666 :
34667 : void
34668 0 : SgUpirTargetField::checkDataMemberPointersIfInMemoryPool()
34669 : {
34670 : // ------------ checking pointers of SgUpirTargetField -------------------
34671 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34672 :
34673 0 : if ( p_startOfConstruct != NULL )
34674 : {
34675 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34676 : {
34677 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
34678 : {
34679 0 : std::cout << "SgUpirTargetField :: ";
34680 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
34681 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
34682 : }
34683 : }
34684 : else
34685 : {
34686 0 : std::cout << "SgUpirTargetField :: " << std::flush;
34687 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
34688 0 : std::cout << " not valid " << std::endl;
34689 : }
34690 : }
34691 :
34692 0 : if ( p_endOfConstruct != NULL )
34693 : {
34694 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34695 : {
34696 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
34697 : {
34698 0 : std::cout << "SgUpirTargetField :: ";
34699 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
34700 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
34701 : }
34702 : }
34703 : else
34704 : {
34705 0 : std::cout << "SgUpirTargetField :: " << std::flush;
34706 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
34707 0 : std::cout << " not valid " << std::endl;
34708 : }
34709 : }
34710 :
34711 0 : if ( p_parent != NULL )
34712 : {
34713 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34714 : {
34715 0 : if ( p_parent->isInMemoryPool() == false )
34716 : {
34717 0 : std::cout << "SgUpirTargetField :: ";
34718 0 : std::cout << " p_parent is not in memory pool of ";
34719 0 : std::cout << p_parent->class_name() << std::endl;
34720 : }
34721 : }
34722 : else
34723 : {
34724 0 : std::cout << "SgUpirTargetField :: " << std::flush;
34725 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
34726 0 : std::cout << " not valid " << std::endl;
34727 : }
34728 : }
34729 :
34730 :
34731 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34732 :
34733 0 : }
34734 :
34735 :
34736 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
34737 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
34738 : bool
34739 0 : SgUpirTargetField::isInMemoryPool ()
34740 : {
34741 0 : typedef unsigned char* TestType;
34742 :
34743 0 : bool found = false;
34744 :
34745 0 : ROSE_ASSERT(this != NULL);
34746 :
34747 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
34748 :
34749 0 : TestType tested = (TestType) ( this ) ;
34750 :
34751 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirTargetField::pools.begin();
34752 :
34753 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
34754 : // while (found == false && block < Memory_Block_List.end())
34755 0 : while ( (found == false) && (block != SgUpirTargetField::pools.end()) )
34756 : {
34757 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirTargetField::pool_size * sizeof(SgUpirTargetField) ) ) ;
34758 0 : ++block;
34759 : }
34760 :
34761 : // Special handling for static data
34762 :
34763 :
34764 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
34765 0 : ROSE_ASSERT(found == true);
34766 :
34767 0 : return found;
34768 : }
34769 : /* #line 34770 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
34770 :
34771 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
34772 :
34773 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34774 :
34775 : /* #line 34776 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
34776 :
34777 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34778 :
34779 : void
34780 0 : SgUpirDataItemField::checkDataMemberPointersIfInMemoryPool()
34781 : {
34782 : // ------------ checking pointers of SgUpirDataItemField -------------------
34783 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34784 :
34785 0 : if ( p_symbol != NULL )
34786 : {
34787 0 : if ( p_symbol->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34788 : {
34789 0 : if ( p_symbol->isInMemoryPool() == false )
34790 : {
34791 0 : std::cout << "SgUpirDataItemField :: ";
34792 0 : std::cout << " p_symbol is not in memory pool of ";
34793 0 : std::cout << p_symbol->class_name() << std::endl;
34794 : }
34795 : }
34796 : else
34797 : {
34798 0 : std::cout << "SgUpirDataItemField :: " << std::flush;
34799 0 : std::cout << "SgSymbol* p_symbol = " << p_symbol << " --> " << std::flush;
34800 0 : std::cout << " not valid " << std::endl;
34801 : }
34802 : }
34803 :
34804 0 : if ( p_mapper != NULL )
34805 : {
34806 0 : if ( p_mapper->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34807 : {
34808 0 : if ( p_mapper->isInMemoryPool() == false )
34809 : {
34810 0 : std::cout << "SgUpirDataItemField :: ";
34811 0 : std::cout << " p_mapper is not in memory pool of ";
34812 0 : std::cout << p_mapper->class_name() << std::endl;
34813 : }
34814 : }
34815 : else
34816 : {
34817 0 : std::cout << "SgUpirDataItemField :: " << std::flush;
34818 0 : std::cout << "SgExpression* p_mapper = " << p_mapper << " --> " << std::flush;
34819 0 : std::cout << " not valid " << std::endl;
34820 : }
34821 : }
34822 :
34823 0 : if ( p_unit_id != NULL )
34824 : {
34825 0 : if ( p_unit_id->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34826 : {
34827 0 : if ( p_unit_id->isInMemoryPool() == false )
34828 : {
34829 0 : std::cout << "SgUpirDataItemField :: ";
34830 0 : std::cout << " p_unit_id is not in memory pool of ";
34831 0 : std::cout << p_unit_id->class_name() << std::endl;
34832 : }
34833 : }
34834 : else
34835 : {
34836 0 : std::cout << "SgUpirDataItemField :: " << std::flush;
34837 0 : std::cout << "SgExpression* p_unit_id = " << p_unit_id << " --> " << std::flush;
34838 0 : std::cout << " not valid " << std::endl;
34839 : }
34840 : }
34841 :
34842 0 : if ( p_user_defined_allocator != NULL )
34843 : {
34844 0 : if ( p_user_defined_allocator->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34845 : {
34846 0 : if ( p_user_defined_allocator->isInMemoryPool() == false )
34847 : {
34848 0 : std::cout << "SgUpirDataItemField :: ";
34849 0 : std::cout << " p_user_defined_allocator is not in memory pool of ";
34850 0 : std::cout << p_user_defined_allocator->class_name() << std::endl;
34851 : }
34852 : }
34853 : else
34854 : {
34855 0 : std::cout << "SgUpirDataItemField :: " << std::flush;
34856 0 : std::cout << "SgExpression* p_user_defined_allocator = " << p_user_defined_allocator << " --> " << std::flush;
34857 0 : std::cout << " not valid " << std::endl;
34858 : }
34859 : }
34860 :
34861 0 : if ( p_user_defined_deallocator != NULL )
34862 : {
34863 0 : if ( p_user_defined_deallocator->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34864 : {
34865 0 : if ( p_user_defined_deallocator->isInMemoryPool() == false )
34866 : {
34867 0 : std::cout << "SgUpirDataItemField :: ";
34868 0 : std::cout << " p_user_defined_deallocator is not in memory pool of ";
34869 0 : std::cout << p_user_defined_deallocator->class_name() << std::endl;
34870 : }
34871 : }
34872 : else
34873 : {
34874 0 : std::cout << "SgUpirDataItemField :: " << std::flush;
34875 0 : std::cout << "SgExpression* p_user_defined_deallocator = " << p_user_defined_deallocator << " --> " << std::flush;
34876 0 : std::cout << " not valid " << std::endl;
34877 : }
34878 : }
34879 :
34880 0 : if ( p_memcpy_helper != NULL )
34881 : {
34882 0 : if ( p_memcpy_helper->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34883 : {
34884 0 : if ( p_memcpy_helper->isInMemoryPool() == false )
34885 : {
34886 0 : std::cout << "SgUpirDataItemField :: ";
34887 0 : std::cout << " p_memcpy_helper is not in memory pool of ";
34888 0 : std::cout << p_memcpy_helper->class_name() << std::endl;
34889 : }
34890 : }
34891 : else
34892 : {
34893 0 : std::cout << "SgUpirDataItemField :: " << std::flush;
34894 0 : std::cout << "SgExpression* p_memcpy_helper = " << p_memcpy_helper << " --> " << std::flush;
34895 0 : std::cout << " not valid " << std::endl;
34896 : }
34897 : }
34898 :
34899 0 : if ( p_startOfConstruct != NULL )
34900 : {
34901 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34902 : {
34903 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
34904 : {
34905 0 : std::cout << "SgUpirDataItemField :: ";
34906 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
34907 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
34908 : }
34909 : }
34910 : else
34911 : {
34912 0 : std::cout << "SgUpirDataItemField :: " << std::flush;
34913 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
34914 0 : std::cout << " not valid " << std::endl;
34915 : }
34916 : }
34917 :
34918 0 : if ( p_endOfConstruct != NULL )
34919 : {
34920 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34921 : {
34922 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
34923 : {
34924 0 : std::cout << "SgUpirDataItemField :: ";
34925 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
34926 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
34927 : }
34928 : }
34929 : else
34930 : {
34931 0 : std::cout << "SgUpirDataItemField :: " << std::flush;
34932 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
34933 0 : std::cout << " not valid " << std::endl;
34934 : }
34935 : }
34936 :
34937 0 : if ( p_parent != NULL )
34938 : {
34939 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
34940 : {
34941 0 : if ( p_parent->isInMemoryPool() == false )
34942 : {
34943 0 : std::cout << "SgUpirDataItemField :: ";
34944 0 : std::cout << " p_parent is not in memory pool of ";
34945 0 : std::cout << p_parent->class_name() << std::endl;
34946 : }
34947 : }
34948 : else
34949 : {
34950 0 : std::cout << "SgUpirDataItemField :: " << std::flush;
34951 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
34952 0 : std::cout << " not valid " << std::endl;
34953 : }
34954 : }
34955 :
34956 :
34957 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
34958 :
34959 0 : }
34960 :
34961 :
34962 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
34963 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
34964 : bool
34965 0 : SgUpirDataItemField::isInMemoryPool ()
34966 : {
34967 0 : typedef unsigned char* TestType;
34968 :
34969 0 : bool found = false;
34970 :
34971 0 : ROSE_ASSERT(this != NULL);
34972 :
34973 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
34974 :
34975 0 : TestType tested = (TestType) ( this ) ;
34976 :
34977 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirDataItemField::pools.begin();
34978 :
34979 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
34980 : // while (found == false && block < Memory_Block_List.end())
34981 0 : while ( (found == false) && (block != SgUpirDataItemField::pools.end()) )
34982 : {
34983 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirDataItemField::pool_size * sizeof(SgUpirDataItemField) ) ) ;
34984 0 : ++block;
34985 : }
34986 :
34987 : // Special handling for static data
34988 :
34989 :
34990 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
34991 0 : ROSE_ASSERT(found == true);
34992 :
34993 0 : return found;
34994 : }
34995 : /* #line 34996 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
34996 :
34997 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
34998 :
34999 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35000 :
35001 : /* #line 35002 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
35002 :
35003 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35004 :
35005 : void
35006 0 : SgLambdaCapture::checkDataMemberPointersIfInMemoryPool()
35007 : {
35008 : // ------------ checking pointers of SgLambdaCapture -------------------
35009 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35010 :
35011 0 : if ( p_capture_variable != NULL )
35012 : {
35013 0 : if ( p_capture_variable->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35014 : {
35015 0 : if ( p_capture_variable->isInMemoryPool() == false )
35016 : {
35017 0 : std::cout << "SgLambdaCapture :: ";
35018 0 : std::cout << " p_capture_variable is not in memory pool of ";
35019 0 : std::cout << p_capture_variable->class_name() << std::endl;
35020 : }
35021 : }
35022 : else
35023 : {
35024 0 : std::cout << "SgLambdaCapture :: " << std::flush;
35025 0 : std::cout << "SgExpression* p_capture_variable = " << p_capture_variable << " --> " << std::flush;
35026 0 : std::cout << " not valid " << std::endl;
35027 : }
35028 : }
35029 :
35030 0 : if ( p_source_closure_variable != NULL )
35031 : {
35032 0 : if ( p_source_closure_variable->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35033 : {
35034 0 : if ( p_source_closure_variable->isInMemoryPool() == false )
35035 : {
35036 0 : std::cout << "SgLambdaCapture :: ";
35037 0 : std::cout << " p_source_closure_variable is not in memory pool of ";
35038 0 : std::cout << p_source_closure_variable->class_name() << std::endl;
35039 : }
35040 : }
35041 : else
35042 : {
35043 0 : std::cout << "SgLambdaCapture :: " << std::flush;
35044 0 : std::cout << "SgExpression* p_source_closure_variable = " << p_source_closure_variable << " --> " << std::flush;
35045 0 : std::cout << " not valid " << std::endl;
35046 : }
35047 : }
35048 :
35049 0 : if ( p_closure_variable != NULL )
35050 : {
35051 0 : if ( p_closure_variable->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35052 : {
35053 0 : if ( p_closure_variable->isInMemoryPool() == false )
35054 : {
35055 0 : std::cout << "SgLambdaCapture :: ";
35056 0 : std::cout << " p_closure_variable is not in memory pool of ";
35057 0 : std::cout << p_closure_variable->class_name() << std::endl;
35058 : }
35059 : }
35060 : else
35061 : {
35062 0 : std::cout << "SgLambdaCapture :: " << std::flush;
35063 0 : std::cout << "SgExpression* p_closure_variable = " << p_closure_variable << " --> " << std::flush;
35064 0 : std::cout << " not valid " << std::endl;
35065 : }
35066 : }
35067 :
35068 0 : if ( p_startOfConstruct != NULL )
35069 : {
35070 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35071 : {
35072 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
35073 : {
35074 0 : std::cout << "SgLambdaCapture :: ";
35075 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
35076 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
35077 : }
35078 : }
35079 : else
35080 : {
35081 0 : std::cout << "SgLambdaCapture :: " << std::flush;
35082 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
35083 0 : std::cout << " not valid " << std::endl;
35084 : }
35085 : }
35086 :
35087 0 : if ( p_endOfConstruct != NULL )
35088 : {
35089 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35090 : {
35091 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
35092 : {
35093 0 : std::cout << "SgLambdaCapture :: ";
35094 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
35095 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
35096 : }
35097 : }
35098 : else
35099 : {
35100 0 : std::cout << "SgLambdaCapture :: " << std::flush;
35101 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
35102 0 : std::cout << " not valid " << std::endl;
35103 : }
35104 : }
35105 :
35106 0 : if ( p_parent != NULL )
35107 : {
35108 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35109 : {
35110 0 : if ( p_parent->isInMemoryPool() == false )
35111 : {
35112 0 : std::cout << "SgLambdaCapture :: ";
35113 0 : std::cout << " p_parent is not in memory pool of ";
35114 0 : std::cout << p_parent->class_name() << std::endl;
35115 : }
35116 : }
35117 : else
35118 : {
35119 0 : std::cout << "SgLambdaCapture :: " << std::flush;
35120 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
35121 0 : std::cout << " not valid " << std::endl;
35122 : }
35123 : }
35124 :
35125 :
35126 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35127 :
35128 0 : }
35129 :
35130 :
35131 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
35132 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
35133 : bool
35134 0 : SgLambdaCapture::isInMemoryPool ()
35135 : {
35136 0 : typedef unsigned char* TestType;
35137 :
35138 0 : bool found = false;
35139 :
35140 0 : ROSE_ASSERT(this != NULL);
35141 :
35142 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
35143 :
35144 0 : TestType tested = (TestType) ( this ) ;
35145 :
35146 0 : std::vector < unsigned char* > :: const_iterator block = SgLambdaCapture::pools.begin();
35147 :
35148 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
35149 : // while (found == false && block < Memory_Block_List.end())
35150 0 : while ( (found == false) && (block != SgLambdaCapture::pools.end()) )
35151 : {
35152 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLambdaCapture::pool_size * sizeof(SgLambdaCapture) ) ) ;
35153 0 : ++block;
35154 : }
35155 :
35156 : // Special handling for static data
35157 :
35158 :
35159 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
35160 0 : ROSE_ASSERT(found == true);
35161 :
35162 0 : return found;
35163 : }
35164 : /* #line 35165 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
35165 :
35166 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
35167 :
35168 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35169 :
35170 : /* #line 35171 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
35171 :
35172 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35173 :
35174 : void
35175 0 : SgLambdaCaptureList::checkDataMemberPointersIfInMemoryPool()
35176 : {
35177 : // ------------ checking pointers of SgLambdaCaptureList -------------------
35178 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35179 :
35180 0 : SgLambdaCapturePtrList::iterator i_capture_list = p_capture_list.begin() ;
35181 0 : for ( ; i_capture_list != p_capture_list.end(); ++i_capture_list )
35182 : {
35183 0 : if ( (*i_capture_list) != NULL )
35184 : {
35185 0 : if ( (*i_capture_list)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35186 : {
35187 0 : if ( (*i_capture_list)->isInMemoryPool() == false )
35188 : {
35189 0 : std::cout << "SgLambdaCaptureList :: ";
35190 0 : std::cout << " p_capture_list ( list of poitners to IR nodes ), entry is not in memory pool of ";
35191 0 : std::cout << (*i_capture_list)->class_name() << std::endl;
35192 : }
35193 : }
35194 : else
35195 : {
35196 0 : std::cout << "SgLambdaCaptureList :: " << std::flush;
35197 0 : std::cout << "SgLambdaCapturePtrList p_capture_list --> " << std::flush;
35198 0 : std::cout << " entry not valid " << std::endl;
35199 : }
35200 : }
35201 : else
35202 : {
35203 0 : std::cout << "SgLambdaCapturePtrList p_capture_list --> NULL " << std::endl;
35204 : }
35205 : }
35206 :
35207 0 : if ( p_startOfConstruct != NULL )
35208 : {
35209 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35210 : {
35211 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
35212 : {
35213 0 : std::cout << "SgLambdaCaptureList :: ";
35214 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
35215 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
35216 : }
35217 : }
35218 : else
35219 : {
35220 0 : std::cout << "SgLambdaCaptureList :: " << std::flush;
35221 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
35222 0 : std::cout << " not valid " << std::endl;
35223 : }
35224 : }
35225 :
35226 0 : if ( p_endOfConstruct != NULL )
35227 : {
35228 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35229 : {
35230 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
35231 : {
35232 0 : std::cout << "SgLambdaCaptureList :: ";
35233 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
35234 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
35235 : }
35236 : }
35237 : else
35238 : {
35239 0 : std::cout << "SgLambdaCaptureList :: " << std::flush;
35240 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
35241 0 : std::cout << " not valid " << std::endl;
35242 : }
35243 : }
35244 :
35245 0 : if ( p_parent != NULL )
35246 : {
35247 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35248 : {
35249 0 : if ( p_parent->isInMemoryPool() == false )
35250 : {
35251 0 : std::cout << "SgLambdaCaptureList :: ";
35252 0 : std::cout << " p_parent is not in memory pool of ";
35253 0 : std::cout << p_parent->class_name() << std::endl;
35254 : }
35255 : }
35256 : else
35257 : {
35258 0 : std::cout << "SgLambdaCaptureList :: " << std::flush;
35259 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
35260 0 : std::cout << " not valid " << std::endl;
35261 : }
35262 : }
35263 :
35264 :
35265 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35266 :
35267 0 : }
35268 :
35269 :
35270 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
35271 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
35272 : bool
35273 0 : SgLambdaCaptureList::isInMemoryPool ()
35274 : {
35275 0 : typedef unsigned char* TestType;
35276 :
35277 0 : bool found = false;
35278 :
35279 0 : ROSE_ASSERT(this != NULL);
35280 :
35281 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
35282 :
35283 0 : TestType tested = (TestType) ( this ) ;
35284 :
35285 0 : std::vector < unsigned char* > :: const_iterator block = SgLambdaCaptureList::pools.begin();
35286 :
35287 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
35288 : // while (found == false && block < Memory_Block_List.end())
35289 0 : while ( (found == false) && (block != SgLambdaCaptureList::pools.end()) )
35290 : {
35291 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLambdaCaptureList::pool_size * sizeof(SgLambdaCaptureList) ) ) ;
35292 0 : ++block;
35293 : }
35294 :
35295 : // Special handling for static data
35296 :
35297 :
35298 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
35299 0 : ROSE_ASSERT(found == true);
35300 :
35301 0 : return found;
35302 : }
35303 : /* #line 35304 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
35304 :
35305 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
35306 :
35307 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35308 :
35309 : /* #line 35310 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
35310 :
35311 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35312 :
35313 : void
35314 0 : SgStatement::checkDataMemberPointersIfInMemoryPool()
35315 : {
35316 : // ------------ checking pointers of SgStatement -------------------
35317 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35318 :
35319 0 : if ( p_numeric_label != NULL )
35320 : {
35321 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35322 : {
35323 0 : if ( p_numeric_label->isInMemoryPool() == false )
35324 : {
35325 0 : std::cout << "SgStatement :: ";
35326 0 : std::cout << " p_numeric_label is not in memory pool of ";
35327 0 : std::cout << p_numeric_label->class_name() << std::endl;
35328 : }
35329 : }
35330 : else
35331 : {
35332 0 : std::cout << "SgStatement :: " << std::flush;
35333 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
35334 0 : std::cout << " not valid " << std::endl;
35335 : }
35336 : }
35337 :
35338 0 : if ( p_startOfConstruct != NULL )
35339 : {
35340 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35341 : {
35342 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
35343 : {
35344 0 : std::cout << "SgStatement :: ";
35345 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
35346 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
35347 : }
35348 : }
35349 : else
35350 : {
35351 0 : std::cout << "SgStatement :: " << std::flush;
35352 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
35353 0 : std::cout << " not valid " << std::endl;
35354 : }
35355 : }
35356 :
35357 0 : if ( p_endOfConstruct != NULL )
35358 : {
35359 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35360 : {
35361 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
35362 : {
35363 0 : std::cout << "SgStatement :: ";
35364 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
35365 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
35366 : }
35367 : }
35368 : else
35369 : {
35370 0 : std::cout << "SgStatement :: " << std::flush;
35371 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
35372 0 : std::cout << " not valid " << std::endl;
35373 : }
35374 : }
35375 :
35376 0 : if ( p_parent != NULL )
35377 : {
35378 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35379 : {
35380 0 : if ( p_parent->isInMemoryPool() == false )
35381 : {
35382 0 : std::cout << "SgStatement :: ";
35383 0 : std::cout << " p_parent is not in memory pool of ";
35384 0 : std::cout << p_parent->class_name() << std::endl;
35385 : }
35386 : }
35387 : else
35388 : {
35389 0 : std::cout << "SgStatement :: " << std::flush;
35390 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
35391 0 : std::cout << " not valid " << std::endl;
35392 : }
35393 : }
35394 :
35395 :
35396 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35397 :
35398 0 : }
35399 :
35400 :
35401 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
35402 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
35403 : bool
35404 0 : SgStatement::isInMemoryPool ()
35405 : {
35406 0 : typedef unsigned char* TestType;
35407 :
35408 0 : bool found = false;
35409 :
35410 0 : ROSE_ASSERT(this != NULL);
35411 :
35412 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
35413 :
35414 0 : TestType tested = (TestType) ( this ) ;
35415 :
35416 0 : std::vector < unsigned char* > :: const_iterator block = SgStatement::pools.begin();
35417 :
35418 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
35419 : // while (found == false && block < Memory_Block_List.end())
35420 0 : while ( (found == false) && (block != SgStatement::pools.end()) )
35421 : {
35422 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgStatement::pool_size * sizeof(SgStatement) ) ) ;
35423 0 : ++block;
35424 : }
35425 :
35426 : // Special handling for static data
35427 :
35428 :
35429 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
35430 0 : ROSE_ASSERT(found == true);
35431 :
35432 0 : return found;
35433 : }
35434 : /* #line 35435 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
35435 :
35436 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
35437 :
35438 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35439 :
35440 : /* #line 35441 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
35441 :
35442 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35443 :
35444 : void
35445 0 : SgScopeStatement::checkDataMemberPointersIfInMemoryPool()
35446 : {
35447 : // ------------ checking pointers of SgScopeStatement -------------------
35448 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35449 :
35450 0 : if ( p_symbol_table != NULL )
35451 : {
35452 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35453 : {
35454 0 : if ( p_symbol_table->isInMemoryPool() == false )
35455 : {
35456 0 : std::cout << "SgScopeStatement :: ";
35457 0 : std::cout << " p_symbol_table is not in memory pool of ";
35458 0 : std::cout << p_symbol_table->class_name() << std::endl;
35459 : }
35460 : }
35461 : else
35462 : {
35463 0 : std::cout << "SgScopeStatement :: " << std::flush;
35464 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
35465 0 : std::cout << " not valid " << std::endl;
35466 : }
35467 : }
35468 :
35469 0 : if ( p_type_table != NULL )
35470 : {
35471 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35472 : {
35473 0 : if ( p_type_table->isInMemoryPool() == false )
35474 : {
35475 0 : std::cout << "SgScopeStatement :: ";
35476 0 : std::cout << " p_type_table is not in memory pool of ";
35477 0 : std::cout << p_type_table->class_name() << std::endl;
35478 : }
35479 : }
35480 : else
35481 : {
35482 0 : std::cout << "SgScopeStatement :: " << std::flush;
35483 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
35484 0 : std::cout << " not valid " << std::endl;
35485 : }
35486 : }
35487 :
35488 0 : if ( p_pragma != NULL )
35489 : {
35490 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35491 : {
35492 0 : if ( p_pragma->isInMemoryPool() == false )
35493 : {
35494 0 : std::cout << "SgScopeStatement :: ";
35495 0 : std::cout << " p_pragma is not in memory pool of ";
35496 0 : std::cout << p_pragma->class_name() << std::endl;
35497 : }
35498 : }
35499 : else
35500 : {
35501 0 : std::cout << "SgScopeStatement :: " << std::flush;
35502 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
35503 0 : std::cout << " not valid " << std::endl;
35504 : }
35505 : }
35506 :
35507 0 : if ( p_numeric_label != NULL )
35508 : {
35509 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35510 : {
35511 0 : if ( p_numeric_label->isInMemoryPool() == false )
35512 : {
35513 0 : std::cout << "SgScopeStatement :: ";
35514 0 : std::cout << " p_numeric_label is not in memory pool of ";
35515 0 : std::cout << p_numeric_label->class_name() << std::endl;
35516 : }
35517 : }
35518 : else
35519 : {
35520 0 : std::cout << "SgScopeStatement :: " << std::flush;
35521 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
35522 0 : std::cout << " not valid " << std::endl;
35523 : }
35524 : }
35525 :
35526 0 : if ( p_startOfConstruct != NULL )
35527 : {
35528 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35529 : {
35530 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
35531 : {
35532 0 : std::cout << "SgScopeStatement :: ";
35533 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
35534 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
35535 : }
35536 : }
35537 : else
35538 : {
35539 0 : std::cout << "SgScopeStatement :: " << std::flush;
35540 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
35541 0 : std::cout << " not valid " << std::endl;
35542 : }
35543 : }
35544 :
35545 0 : if ( p_endOfConstruct != NULL )
35546 : {
35547 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35548 : {
35549 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
35550 : {
35551 0 : std::cout << "SgScopeStatement :: ";
35552 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
35553 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
35554 : }
35555 : }
35556 : else
35557 : {
35558 0 : std::cout << "SgScopeStatement :: " << std::flush;
35559 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
35560 0 : std::cout << " not valid " << std::endl;
35561 : }
35562 : }
35563 :
35564 0 : if ( p_parent != NULL )
35565 : {
35566 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35567 : {
35568 0 : if ( p_parent->isInMemoryPool() == false )
35569 : {
35570 0 : std::cout << "SgScopeStatement :: ";
35571 0 : std::cout << " p_parent is not in memory pool of ";
35572 0 : std::cout << p_parent->class_name() << std::endl;
35573 : }
35574 : }
35575 : else
35576 : {
35577 0 : std::cout << "SgScopeStatement :: " << std::flush;
35578 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
35579 0 : std::cout << " not valid " << std::endl;
35580 : }
35581 : }
35582 :
35583 :
35584 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35585 :
35586 0 : }
35587 :
35588 :
35589 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
35590 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
35591 : bool
35592 0 : SgScopeStatement::isInMemoryPool ()
35593 : {
35594 0 : typedef unsigned char* TestType;
35595 :
35596 0 : bool found = false;
35597 :
35598 0 : ROSE_ASSERT(this != NULL);
35599 :
35600 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
35601 :
35602 0 : TestType tested = (TestType) ( this ) ;
35603 :
35604 0 : std::vector < unsigned char* > :: const_iterator block = SgScopeStatement::pools.begin();
35605 :
35606 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
35607 : // while (found == false && block < Memory_Block_List.end())
35608 0 : while ( (found == false) && (block != SgScopeStatement::pools.end()) )
35609 : {
35610 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgScopeStatement::pool_size * sizeof(SgScopeStatement) ) ) ;
35611 0 : ++block;
35612 : }
35613 :
35614 : // Special handling for static data
35615 :
35616 :
35617 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
35618 0 : ROSE_ASSERT(found == true);
35619 :
35620 0 : return found;
35621 : }
35622 : /* #line 35623 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
35623 :
35624 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
35625 :
35626 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35627 :
35628 : /* #line 35629 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
35629 :
35630 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35631 :
35632 : void
35633 0 : SgGlobal::checkDataMemberPointersIfInMemoryPool()
35634 : {
35635 : // ------------ checking pointers of SgGlobal -------------------
35636 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35637 :
35638 0 : SgDeclarationStatementPtrList::iterator i_declarations = p_declarations.begin() ;
35639 0 : for ( ; i_declarations != p_declarations.end(); ++i_declarations )
35640 : {
35641 0 : if ( (*i_declarations) != NULL )
35642 : {
35643 0 : if ( (*i_declarations)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35644 : {
35645 0 : if ( (*i_declarations)->isInMemoryPool() == false )
35646 : {
35647 0 : std::cout << "SgGlobal :: ";
35648 0 : std::cout << " p_declarations ( list of poitners to IR nodes ), entry is not in memory pool of ";
35649 0 : std::cout << (*i_declarations)->class_name() << std::endl;
35650 : }
35651 : }
35652 : else
35653 : {
35654 0 : std::cout << "SgGlobal :: " << std::flush;
35655 0 : std::cout << "SgDeclarationStatementPtrList p_declarations --> " << std::flush;
35656 0 : std::cout << " entry not valid " << std::endl;
35657 : }
35658 : }
35659 : else
35660 : {
35661 0 : std::cout << "SgDeclarationStatementPtrList p_declarations --> NULL " << std::endl;
35662 : }
35663 : }
35664 :
35665 0 : if ( p_symbol_table != NULL )
35666 : {
35667 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35668 : {
35669 0 : if ( p_symbol_table->isInMemoryPool() == false )
35670 : {
35671 0 : std::cout << "SgGlobal :: ";
35672 0 : std::cout << " p_symbol_table is not in memory pool of ";
35673 0 : std::cout << p_symbol_table->class_name() << std::endl;
35674 : }
35675 : }
35676 : else
35677 : {
35678 0 : std::cout << "SgGlobal :: " << std::flush;
35679 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
35680 0 : std::cout << " not valid " << std::endl;
35681 : }
35682 : }
35683 :
35684 0 : if ( p_type_table != NULL )
35685 : {
35686 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35687 : {
35688 0 : if ( p_type_table->isInMemoryPool() == false )
35689 : {
35690 0 : std::cout << "SgGlobal :: ";
35691 0 : std::cout << " p_type_table is not in memory pool of ";
35692 0 : std::cout << p_type_table->class_name() << std::endl;
35693 : }
35694 : }
35695 : else
35696 : {
35697 0 : std::cout << "SgGlobal :: " << std::flush;
35698 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
35699 0 : std::cout << " not valid " << std::endl;
35700 : }
35701 : }
35702 :
35703 0 : if ( p_pragma != NULL )
35704 : {
35705 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35706 : {
35707 0 : if ( p_pragma->isInMemoryPool() == false )
35708 : {
35709 0 : std::cout << "SgGlobal :: ";
35710 0 : std::cout << " p_pragma is not in memory pool of ";
35711 0 : std::cout << p_pragma->class_name() << std::endl;
35712 : }
35713 : }
35714 : else
35715 : {
35716 0 : std::cout << "SgGlobal :: " << std::flush;
35717 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
35718 0 : std::cout << " not valid " << std::endl;
35719 : }
35720 : }
35721 :
35722 0 : if ( p_numeric_label != NULL )
35723 : {
35724 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35725 : {
35726 0 : if ( p_numeric_label->isInMemoryPool() == false )
35727 : {
35728 0 : std::cout << "SgGlobal :: ";
35729 0 : std::cout << " p_numeric_label is not in memory pool of ";
35730 0 : std::cout << p_numeric_label->class_name() << std::endl;
35731 : }
35732 : }
35733 : else
35734 : {
35735 0 : std::cout << "SgGlobal :: " << std::flush;
35736 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
35737 0 : std::cout << " not valid " << std::endl;
35738 : }
35739 : }
35740 :
35741 0 : if ( p_startOfConstruct != NULL )
35742 : {
35743 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35744 : {
35745 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
35746 : {
35747 0 : std::cout << "SgGlobal :: ";
35748 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
35749 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
35750 : }
35751 : }
35752 : else
35753 : {
35754 0 : std::cout << "SgGlobal :: " << std::flush;
35755 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
35756 0 : std::cout << " not valid " << std::endl;
35757 : }
35758 : }
35759 :
35760 0 : if ( p_endOfConstruct != NULL )
35761 : {
35762 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35763 : {
35764 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
35765 : {
35766 0 : std::cout << "SgGlobal :: ";
35767 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
35768 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
35769 : }
35770 : }
35771 : else
35772 : {
35773 0 : std::cout << "SgGlobal :: " << std::flush;
35774 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
35775 0 : std::cout << " not valid " << std::endl;
35776 : }
35777 : }
35778 :
35779 0 : if ( p_parent != NULL )
35780 : {
35781 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35782 : {
35783 0 : if ( p_parent->isInMemoryPool() == false )
35784 : {
35785 0 : std::cout << "SgGlobal :: ";
35786 0 : std::cout << " p_parent is not in memory pool of ";
35787 0 : std::cout << p_parent->class_name() << std::endl;
35788 : }
35789 : }
35790 : else
35791 : {
35792 0 : std::cout << "SgGlobal :: " << std::flush;
35793 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
35794 0 : std::cout << " not valid " << std::endl;
35795 : }
35796 : }
35797 :
35798 :
35799 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35800 :
35801 0 : }
35802 :
35803 :
35804 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
35805 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
35806 : bool
35807 0 : SgGlobal::isInMemoryPool ()
35808 : {
35809 0 : typedef unsigned char* TestType;
35810 :
35811 0 : bool found = false;
35812 :
35813 0 : ROSE_ASSERT(this != NULL);
35814 :
35815 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
35816 :
35817 0 : TestType tested = (TestType) ( this ) ;
35818 :
35819 0 : std::vector < unsigned char* > :: const_iterator block = SgGlobal::pools.begin();
35820 :
35821 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
35822 : // while (found == false && block < Memory_Block_List.end())
35823 0 : while ( (found == false) && (block != SgGlobal::pools.end()) )
35824 : {
35825 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgGlobal::pool_size * sizeof(SgGlobal) ) ) ;
35826 0 : ++block;
35827 : }
35828 :
35829 : // Special handling for static data
35830 :
35831 :
35832 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
35833 0 : ROSE_ASSERT(found == true);
35834 :
35835 0 : return found;
35836 : }
35837 : /* #line 35838 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
35838 :
35839 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
35840 :
35841 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35842 :
35843 : /* #line 35844 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
35844 :
35845 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
35846 :
35847 : void
35848 0 : SgBasicBlock::checkDataMemberPointersIfInMemoryPool()
35849 : {
35850 : // ------------ checking pointers of SgBasicBlock -------------------
35851 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35852 :
35853 0 : SgStatementPtrList::iterator i_statements = p_statements.begin() ;
35854 0 : for ( ; i_statements != p_statements.end(); ++i_statements )
35855 : {
35856 0 : if ( (*i_statements) != NULL )
35857 : {
35858 0 : if ( (*i_statements)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35859 : {
35860 0 : if ( (*i_statements)->isInMemoryPool() == false )
35861 : {
35862 0 : std::cout << "SgBasicBlock :: ";
35863 0 : std::cout << " p_statements ( list of poitners to IR nodes ), entry is not in memory pool of ";
35864 0 : std::cout << (*i_statements)->class_name() << std::endl;
35865 : }
35866 : }
35867 : else
35868 : {
35869 0 : std::cout << "SgBasicBlock :: " << std::flush;
35870 0 : std::cout << "SgStatementPtrList p_statements --> " << std::flush;
35871 0 : std::cout << " entry not valid " << std::endl;
35872 : }
35873 : }
35874 : else
35875 : {
35876 0 : std::cout << "SgStatementPtrList p_statements --> NULL " << std::endl;
35877 : }
35878 : }
35879 :
35880 0 : if ( p_symbol_table != NULL )
35881 : {
35882 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35883 : {
35884 0 : if ( p_symbol_table->isInMemoryPool() == false )
35885 : {
35886 0 : std::cout << "SgBasicBlock :: ";
35887 0 : std::cout << " p_symbol_table is not in memory pool of ";
35888 0 : std::cout << p_symbol_table->class_name() << std::endl;
35889 : }
35890 : }
35891 : else
35892 : {
35893 0 : std::cout << "SgBasicBlock :: " << std::flush;
35894 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
35895 0 : std::cout << " not valid " << std::endl;
35896 : }
35897 : }
35898 :
35899 0 : if ( p_type_table != NULL )
35900 : {
35901 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35902 : {
35903 0 : if ( p_type_table->isInMemoryPool() == false )
35904 : {
35905 0 : std::cout << "SgBasicBlock :: ";
35906 0 : std::cout << " p_type_table is not in memory pool of ";
35907 0 : std::cout << p_type_table->class_name() << std::endl;
35908 : }
35909 : }
35910 : else
35911 : {
35912 0 : std::cout << "SgBasicBlock :: " << std::flush;
35913 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
35914 0 : std::cout << " not valid " << std::endl;
35915 : }
35916 : }
35917 :
35918 0 : if ( p_pragma != NULL )
35919 : {
35920 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35921 : {
35922 0 : if ( p_pragma->isInMemoryPool() == false )
35923 : {
35924 0 : std::cout << "SgBasicBlock :: ";
35925 0 : std::cout << " p_pragma is not in memory pool of ";
35926 0 : std::cout << p_pragma->class_name() << std::endl;
35927 : }
35928 : }
35929 : else
35930 : {
35931 0 : std::cout << "SgBasicBlock :: " << std::flush;
35932 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
35933 0 : std::cout << " not valid " << std::endl;
35934 : }
35935 : }
35936 :
35937 0 : if ( p_numeric_label != NULL )
35938 : {
35939 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35940 : {
35941 0 : if ( p_numeric_label->isInMemoryPool() == false )
35942 : {
35943 0 : std::cout << "SgBasicBlock :: ";
35944 0 : std::cout << " p_numeric_label is not in memory pool of ";
35945 0 : std::cout << p_numeric_label->class_name() << std::endl;
35946 : }
35947 : }
35948 : else
35949 : {
35950 0 : std::cout << "SgBasicBlock :: " << std::flush;
35951 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
35952 0 : std::cout << " not valid " << std::endl;
35953 : }
35954 : }
35955 :
35956 0 : if ( p_startOfConstruct != NULL )
35957 : {
35958 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35959 : {
35960 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
35961 : {
35962 0 : std::cout << "SgBasicBlock :: ";
35963 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
35964 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
35965 : }
35966 : }
35967 : else
35968 : {
35969 0 : std::cout << "SgBasicBlock :: " << std::flush;
35970 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
35971 0 : std::cout << " not valid " << std::endl;
35972 : }
35973 : }
35974 :
35975 0 : if ( p_endOfConstruct != NULL )
35976 : {
35977 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35978 : {
35979 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
35980 : {
35981 0 : std::cout << "SgBasicBlock :: ";
35982 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
35983 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
35984 : }
35985 : }
35986 : else
35987 : {
35988 0 : std::cout << "SgBasicBlock :: " << std::flush;
35989 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
35990 0 : std::cout << " not valid " << std::endl;
35991 : }
35992 : }
35993 :
35994 0 : if ( p_parent != NULL )
35995 : {
35996 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
35997 : {
35998 0 : if ( p_parent->isInMemoryPool() == false )
35999 : {
36000 0 : std::cout << "SgBasicBlock :: ";
36001 0 : std::cout << " p_parent is not in memory pool of ";
36002 0 : std::cout << p_parent->class_name() << std::endl;
36003 : }
36004 : }
36005 : else
36006 : {
36007 0 : std::cout << "SgBasicBlock :: " << std::flush;
36008 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
36009 0 : std::cout << " not valid " << std::endl;
36010 : }
36011 : }
36012 :
36013 :
36014 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
36015 :
36016 0 : }
36017 :
36018 :
36019 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
36020 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
36021 : bool
36022 0 : SgBasicBlock::isInMemoryPool ()
36023 : {
36024 0 : typedef unsigned char* TestType;
36025 :
36026 0 : bool found = false;
36027 :
36028 0 : ROSE_ASSERT(this != NULL);
36029 :
36030 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
36031 :
36032 0 : TestType tested = (TestType) ( this ) ;
36033 :
36034 0 : std::vector < unsigned char* > :: const_iterator block = SgBasicBlock::pools.begin();
36035 :
36036 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
36037 : // while (found == false && block < Memory_Block_List.end())
36038 0 : while ( (found == false) && (block != SgBasicBlock::pools.end()) )
36039 : {
36040 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgBasicBlock::pool_size * sizeof(SgBasicBlock) ) ) ;
36041 0 : ++block;
36042 : }
36043 :
36044 : // Special handling for static data
36045 :
36046 :
36047 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
36048 0 : ROSE_ASSERT(found == true);
36049 :
36050 0 : return found;
36051 : }
36052 : /* #line 36053 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
36053 :
36054 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
36055 :
36056 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
36057 :
36058 : /* #line 36059 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
36059 :
36060 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
36061 :
36062 : void
36063 0 : SgIfStmt::checkDataMemberPointersIfInMemoryPool()
36064 : {
36065 : // ------------ checking pointers of SgIfStmt -------------------
36066 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36067 :
36068 0 : if ( p_conditional != NULL )
36069 : {
36070 0 : if ( p_conditional->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36071 : {
36072 0 : if ( p_conditional->isInMemoryPool() == false )
36073 : {
36074 0 : std::cout << "SgIfStmt :: ";
36075 0 : std::cout << " p_conditional is not in memory pool of ";
36076 0 : std::cout << p_conditional->class_name() << std::endl;
36077 : }
36078 : }
36079 : else
36080 : {
36081 0 : std::cout << "SgIfStmt :: " << std::flush;
36082 0 : std::cout << "SgStatement* p_conditional = " << p_conditional << " --> " << std::flush;
36083 0 : std::cout << " not valid " << std::endl;
36084 : }
36085 : }
36086 :
36087 0 : if ( p_true_body != NULL )
36088 : {
36089 0 : if ( p_true_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36090 : {
36091 0 : if ( p_true_body->isInMemoryPool() == false )
36092 : {
36093 0 : std::cout << "SgIfStmt :: ";
36094 0 : std::cout << " p_true_body is not in memory pool of ";
36095 0 : std::cout << p_true_body->class_name() << std::endl;
36096 : }
36097 : }
36098 : else
36099 : {
36100 0 : std::cout << "SgIfStmt :: " << std::flush;
36101 0 : std::cout << "SgStatement* p_true_body = " << p_true_body << " --> " << std::flush;
36102 0 : std::cout << " not valid " << std::endl;
36103 : }
36104 : }
36105 :
36106 0 : if ( p_false_body != NULL )
36107 : {
36108 0 : if ( p_false_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36109 : {
36110 0 : if ( p_false_body->isInMemoryPool() == false )
36111 : {
36112 0 : std::cout << "SgIfStmt :: ";
36113 0 : std::cout << " p_false_body is not in memory pool of ";
36114 0 : std::cout << p_false_body->class_name() << std::endl;
36115 : }
36116 : }
36117 : else
36118 : {
36119 0 : std::cout << "SgIfStmt :: " << std::flush;
36120 0 : std::cout << "SgStatement* p_false_body = " << p_false_body << " --> " << std::flush;
36121 0 : std::cout << " not valid " << std::endl;
36122 : }
36123 : }
36124 :
36125 0 : if ( p_else_numeric_label != NULL )
36126 : {
36127 0 : if ( p_else_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36128 : {
36129 0 : if ( p_else_numeric_label->isInMemoryPool() == false )
36130 : {
36131 0 : std::cout << "SgIfStmt :: ";
36132 0 : std::cout << " p_else_numeric_label is not in memory pool of ";
36133 0 : std::cout << p_else_numeric_label->class_name() << std::endl;
36134 : }
36135 : }
36136 : else
36137 : {
36138 0 : std::cout << "SgIfStmt :: " << std::flush;
36139 0 : std::cout << "SgLabelRefExp* p_else_numeric_label = " << p_else_numeric_label << " --> " << std::flush;
36140 0 : std::cout << " not valid " << std::endl;
36141 : }
36142 : }
36143 :
36144 0 : if ( p_end_numeric_label != NULL )
36145 : {
36146 0 : if ( p_end_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36147 : {
36148 0 : if ( p_end_numeric_label->isInMemoryPool() == false )
36149 : {
36150 0 : std::cout << "SgIfStmt :: ";
36151 0 : std::cout << " p_end_numeric_label is not in memory pool of ";
36152 0 : std::cout << p_end_numeric_label->class_name() << std::endl;
36153 : }
36154 : }
36155 : else
36156 : {
36157 0 : std::cout << "SgIfStmt :: " << std::flush;
36158 0 : std::cout << "SgLabelRefExp* p_end_numeric_label = " << p_end_numeric_label << " --> " << std::flush;
36159 0 : std::cout << " not valid " << std::endl;
36160 : }
36161 : }
36162 :
36163 0 : if ( p_symbol_table != NULL )
36164 : {
36165 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36166 : {
36167 0 : if ( p_symbol_table->isInMemoryPool() == false )
36168 : {
36169 0 : std::cout << "SgIfStmt :: ";
36170 0 : std::cout << " p_symbol_table is not in memory pool of ";
36171 0 : std::cout << p_symbol_table->class_name() << std::endl;
36172 : }
36173 : }
36174 : else
36175 : {
36176 0 : std::cout << "SgIfStmt :: " << std::flush;
36177 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
36178 0 : std::cout << " not valid " << std::endl;
36179 : }
36180 : }
36181 :
36182 0 : if ( p_type_table != NULL )
36183 : {
36184 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36185 : {
36186 0 : if ( p_type_table->isInMemoryPool() == false )
36187 : {
36188 0 : std::cout << "SgIfStmt :: ";
36189 0 : std::cout << " p_type_table is not in memory pool of ";
36190 0 : std::cout << p_type_table->class_name() << std::endl;
36191 : }
36192 : }
36193 : else
36194 : {
36195 0 : std::cout << "SgIfStmt :: " << std::flush;
36196 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
36197 0 : std::cout << " not valid " << std::endl;
36198 : }
36199 : }
36200 :
36201 0 : if ( p_pragma != NULL )
36202 : {
36203 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36204 : {
36205 0 : if ( p_pragma->isInMemoryPool() == false )
36206 : {
36207 0 : std::cout << "SgIfStmt :: ";
36208 0 : std::cout << " p_pragma is not in memory pool of ";
36209 0 : std::cout << p_pragma->class_name() << std::endl;
36210 : }
36211 : }
36212 : else
36213 : {
36214 0 : std::cout << "SgIfStmt :: " << std::flush;
36215 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
36216 0 : std::cout << " not valid " << std::endl;
36217 : }
36218 : }
36219 :
36220 0 : if ( p_numeric_label != NULL )
36221 : {
36222 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36223 : {
36224 0 : if ( p_numeric_label->isInMemoryPool() == false )
36225 : {
36226 0 : std::cout << "SgIfStmt :: ";
36227 0 : std::cout << " p_numeric_label is not in memory pool of ";
36228 0 : std::cout << p_numeric_label->class_name() << std::endl;
36229 : }
36230 : }
36231 : else
36232 : {
36233 0 : std::cout << "SgIfStmt :: " << std::flush;
36234 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
36235 0 : std::cout << " not valid " << std::endl;
36236 : }
36237 : }
36238 :
36239 0 : if ( p_startOfConstruct != NULL )
36240 : {
36241 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36242 : {
36243 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
36244 : {
36245 0 : std::cout << "SgIfStmt :: ";
36246 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
36247 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
36248 : }
36249 : }
36250 : else
36251 : {
36252 0 : std::cout << "SgIfStmt :: " << std::flush;
36253 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
36254 0 : std::cout << " not valid " << std::endl;
36255 : }
36256 : }
36257 :
36258 0 : if ( p_endOfConstruct != NULL )
36259 : {
36260 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36261 : {
36262 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
36263 : {
36264 0 : std::cout << "SgIfStmt :: ";
36265 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
36266 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
36267 : }
36268 : }
36269 : else
36270 : {
36271 0 : std::cout << "SgIfStmt :: " << std::flush;
36272 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
36273 0 : std::cout << " not valid " << std::endl;
36274 : }
36275 : }
36276 :
36277 0 : if ( p_parent != NULL )
36278 : {
36279 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36280 : {
36281 0 : if ( p_parent->isInMemoryPool() == false )
36282 : {
36283 0 : std::cout << "SgIfStmt :: ";
36284 0 : std::cout << " p_parent is not in memory pool of ";
36285 0 : std::cout << p_parent->class_name() << std::endl;
36286 : }
36287 : }
36288 : else
36289 : {
36290 0 : std::cout << "SgIfStmt :: " << std::flush;
36291 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
36292 0 : std::cout << " not valid " << std::endl;
36293 : }
36294 : }
36295 :
36296 :
36297 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
36298 :
36299 0 : }
36300 :
36301 :
36302 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
36303 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
36304 : bool
36305 0 : SgIfStmt::isInMemoryPool ()
36306 : {
36307 0 : typedef unsigned char* TestType;
36308 :
36309 0 : bool found = false;
36310 :
36311 0 : ROSE_ASSERT(this != NULL);
36312 :
36313 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
36314 :
36315 0 : TestType tested = (TestType) ( this ) ;
36316 :
36317 0 : std::vector < unsigned char* > :: const_iterator block = SgIfStmt::pools.begin();
36318 :
36319 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
36320 : // while (found == false && block < Memory_Block_List.end())
36321 0 : while ( (found == false) && (block != SgIfStmt::pools.end()) )
36322 : {
36323 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIfStmt::pool_size * sizeof(SgIfStmt) ) ) ;
36324 0 : ++block;
36325 : }
36326 :
36327 : // Special handling for static data
36328 :
36329 :
36330 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
36331 0 : ROSE_ASSERT(found == true);
36332 :
36333 0 : return found;
36334 : }
36335 : /* #line 36336 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
36336 :
36337 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
36338 :
36339 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
36340 :
36341 : /* #line 36342 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
36342 :
36343 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
36344 :
36345 : void
36346 0 : SgForStatement::checkDataMemberPointersIfInMemoryPool()
36347 : {
36348 : // ------------ checking pointers of SgForStatement -------------------
36349 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36350 :
36351 0 : if ( p_for_init_stmt != NULL )
36352 : {
36353 0 : if ( p_for_init_stmt->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36354 : {
36355 0 : if ( p_for_init_stmt->isInMemoryPool() == false )
36356 : {
36357 0 : std::cout << "SgForStatement :: ";
36358 0 : std::cout << " p_for_init_stmt is not in memory pool of ";
36359 0 : std::cout << p_for_init_stmt->class_name() << std::endl;
36360 : }
36361 : }
36362 : else
36363 : {
36364 0 : std::cout << "SgForStatement :: " << std::flush;
36365 0 : std::cout << "SgForInitStatement* p_for_init_stmt = " << p_for_init_stmt << " --> " << std::flush;
36366 0 : std::cout << " not valid " << std::endl;
36367 : }
36368 : }
36369 :
36370 0 : if ( p_test != NULL )
36371 : {
36372 0 : if ( p_test->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36373 : {
36374 0 : if ( p_test->isInMemoryPool() == false )
36375 : {
36376 0 : std::cout << "SgForStatement :: ";
36377 0 : std::cout << " p_test is not in memory pool of ";
36378 0 : std::cout << p_test->class_name() << std::endl;
36379 : }
36380 : }
36381 : else
36382 : {
36383 0 : std::cout << "SgForStatement :: " << std::flush;
36384 0 : std::cout << "SgStatement* p_test = " << p_test << " --> " << std::flush;
36385 0 : std::cout << " not valid " << std::endl;
36386 : }
36387 : }
36388 :
36389 0 : if ( p_increment != NULL )
36390 : {
36391 0 : if ( p_increment->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36392 : {
36393 0 : if ( p_increment->isInMemoryPool() == false )
36394 : {
36395 0 : std::cout << "SgForStatement :: ";
36396 0 : std::cout << " p_increment is not in memory pool of ";
36397 0 : std::cout << p_increment->class_name() << std::endl;
36398 : }
36399 : }
36400 : else
36401 : {
36402 0 : std::cout << "SgForStatement :: " << std::flush;
36403 0 : std::cout << "SgExpression* p_increment = " << p_increment << " --> " << std::flush;
36404 0 : std::cout << " not valid " << std::endl;
36405 : }
36406 : }
36407 :
36408 0 : if ( p_loop_body != NULL )
36409 : {
36410 0 : if ( p_loop_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36411 : {
36412 0 : if ( p_loop_body->isInMemoryPool() == false )
36413 : {
36414 0 : std::cout << "SgForStatement :: ";
36415 0 : std::cout << " p_loop_body is not in memory pool of ";
36416 0 : std::cout << p_loop_body->class_name() << std::endl;
36417 : }
36418 : }
36419 : else
36420 : {
36421 0 : std::cout << "SgForStatement :: " << std::flush;
36422 0 : std::cout << "SgStatement* p_loop_body = " << p_loop_body << " --> " << std::flush;
36423 0 : std::cout << " not valid " << std::endl;
36424 : }
36425 : }
36426 :
36427 0 : if ( p_else_body != NULL )
36428 : {
36429 0 : if ( p_else_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36430 : {
36431 0 : if ( p_else_body->isInMemoryPool() == false )
36432 : {
36433 0 : std::cout << "SgForStatement :: ";
36434 0 : std::cout << " p_else_body is not in memory pool of ";
36435 0 : std::cout << p_else_body->class_name() << std::endl;
36436 : }
36437 : }
36438 : else
36439 : {
36440 0 : std::cout << "SgForStatement :: " << std::flush;
36441 0 : std::cout << "SgStatement* p_else_body = " << p_else_body << " --> " << std::flush;
36442 0 : std::cout << " not valid " << std::endl;
36443 : }
36444 : }
36445 :
36446 0 : if ( p_symbol_table != NULL )
36447 : {
36448 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36449 : {
36450 0 : if ( p_symbol_table->isInMemoryPool() == false )
36451 : {
36452 0 : std::cout << "SgForStatement :: ";
36453 0 : std::cout << " p_symbol_table is not in memory pool of ";
36454 0 : std::cout << p_symbol_table->class_name() << std::endl;
36455 : }
36456 : }
36457 : else
36458 : {
36459 0 : std::cout << "SgForStatement :: " << std::flush;
36460 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
36461 0 : std::cout << " not valid " << std::endl;
36462 : }
36463 : }
36464 :
36465 0 : if ( p_type_table != NULL )
36466 : {
36467 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36468 : {
36469 0 : if ( p_type_table->isInMemoryPool() == false )
36470 : {
36471 0 : std::cout << "SgForStatement :: ";
36472 0 : std::cout << " p_type_table is not in memory pool of ";
36473 0 : std::cout << p_type_table->class_name() << std::endl;
36474 : }
36475 : }
36476 : else
36477 : {
36478 0 : std::cout << "SgForStatement :: " << std::flush;
36479 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
36480 0 : std::cout << " not valid " << std::endl;
36481 : }
36482 : }
36483 :
36484 0 : if ( p_pragma != NULL )
36485 : {
36486 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36487 : {
36488 0 : if ( p_pragma->isInMemoryPool() == false )
36489 : {
36490 0 : std::cout << "SgForStatement :: ";
36491 0 : std::cout << " p_pragma is not in memory pool of ";
36492 0 : std::cout << p_pragma->class_name() << std::endl;
36493 : }
36494 : }
36495 : else
36496 : {
36497 0 : std::cout << "SgForStatement :: " << std::flush;
36498 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
36499 0 : std::cout << " not valid " << std::endl;
36500 : }
36501 : }
36502 :
36503 0 : if ( p_numeric_label != NULL )
36504 : {
36505 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36506 : {
36507 0 : if ( p_numeric_label->isInMemoryPool() == false )
36508 : {
36509 0 : std::cout << "SgForStatement :: ";
36510 0 : std::cout << " p_numeric_label is not in memory pool of ";
36511 0 : std::cout << p_numeric_label->class_name() << std::endl;
36512 : }
36513 : }
36514 : else
36515 : {
36516 0 : std::cout << "SgForStatement :: " << std::flush;
36517 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
36518 0 : std::cout << " not valid " << std::endl;
36519 : }
36520 : }
36521 :
36522 0 : if ( p_startOfConstruct != NULL )
36523 : {
36524 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36525 : {
36526 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
36527 : {
36528 0 : std::cout << "SgForStatement :: ";
36529 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
36530 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
36531 : }
36532 : }
36533 : else
36534 : {
36535 0 : std::cout << "SgForStatement :: " << std::flush;
36536 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
36537 0 : std::cout << " not valid " << std::endl;
36538 : }
36539 : }
36540 :
36541 0 : if ( p_endOfConstruct != NULL )
36542 : {
36543 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36544 : {
36545 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
36546 : {
36547 0 : std::cout << "SgForStatement :: ";
36548 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
36549 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
36550 : }
36551 : }
36552 : else
36553 : {
36554 0 : std::cout << "SgForStatement :: " << std::flush;
36555 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
36556 0 : std::cout << " not valid " << std::endl;
36557 : }
36558 : }
36559 :
36560 0 : if ( p_parent != NULL )
36561 : {
36562 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36563 : {
36564 0 : if ( p_parent->isInMemoryPool() == false )
36565 : {
36566 0 : std::cout << "SgForStatement :: ";
36567 0 : std::cout << " p_parent is not in memory pool of ";
36568 0 : std::cout << p_parent->class_name() << std::endl;
36569 : }
36570 : }
36571 : else
36572 : {
36573 0 : std::cout << "SgForStatement :: " << std::flush;
36574 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
36575 0 : std::cout << " not valid " << std::endl;
36576 : }
36577 : }
36578 :
36579 :
36580 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
36581 :
36582 0 : }
36583 :
36584 :
36585 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
36586 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
36587 : bool
36588 0 : SgForStatement::isInMemoryPool ()
36589 : {
36590 0 : typedef unsigned char* TestType;
36591 :
36592 0 : bool found = false;
36593 :
36594 0 : ROSE_ASSERT(this != NULL);
36595 :
36596 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
36597 :
36598 0 : TestType tested = (TestType) ( this ) ;
36599 :
36600 0 : std::vector < unsigned char* > :: const_iterator block = SgForStatement::pools.begin();
36601 :
36602 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
36603 : // while (found == false && block < Memory_Block_List.end())
36604 0 : while ( (found == false) && (block != SgForStatement::pools.end()) )
36605 : {
36606 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgForStatement::pool_size * sizeof(SgForStatement) ) ) ;
36607 0 : ++block;
36608 : }
36609 :
36610 : // Special handling for static data
36611 :
36612 :
36613 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
36614 0 : ROSE_ASSERT(found == true);
36615 :
36616 0 : return found;
36617 : }
36618 : /* #line 36619 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
36619 :
36620 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
36621 :
36622 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
36623 :
36624 : /* #line 36625 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
36625 :
36626 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
36627 :
36628 : void
36629 0 : SgFunctionDefinition::checkDataMemberPointersIfInMemoryPool()
36630 : {
36631 : // ------------ checking pointers of SgFunctionDefinition -------------------
36632 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36633 :
36634 0 : if ( p_body != NULL )
36635 : {
36636 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36637 : {
36638 0 : if ( p_body->isInMemoryPool() == false )
36639 : {
36640 0 : std::cout << "SgFunctionDefinition :: ";
36641 0 : std::cout << " p_body is not in memory pool of ";
36642 0 : std::cout << p_body->class_name() << std::endl;
36643 : }
36644 : }
36645 : else
36646 : {
36647 0 : std::cout << "SgFunctionDefinition :: " << std::flush;
36648 0 : std::cout << "SgBasicBlock* p_body = " << p_body << " --> " << std::flush;
36649 0 : std::cout << " not valid " << std::endl;
36650 : }
36651 : }
36652 :
36653 0 : if ( p_symbol_table != NULL )
36654 : {
36655 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36656 : {
36657 0 : if ( p_symbol_table->isInMemoryPool() == false )
36658 : {
36659 0 : std::cout << "SgFunctionDefinition :: ";
36660 0 : std::cout << " p_symbol_table is not in memory pool of ";
36661 0 : std::cout << p_symbol_table->class_name() << std::endl;
36662 : }
36663 : }
36664 : else
36665 : {
36666 0 : std::cout << "SgFunctionDefinition :: " << std::flush;
36667 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
36668 0 : std::cout << " not valid " << std::endl;
36669 : }
36670 : }
36671 :
36672 0 : if ( p_type_table != NULL )
36673 : {
36674 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36675 : {
36676 0 : if ( p_type_table->isInMemoryPool() == false )
36677 : {
36678 0 : std::cout << "SgFunctionDefinition :: ";
36679 0 : std::cout << " p_type_table is not in memory pool of ";
36680 0 : std::cout << p_type_table->class_name() << std::endl;
36681 : }
36682 : }
36683 : else
36684 : {
36685 0 : std::cout << "SgFunctionDefinition :: " << std::flush;
36686 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
36687 0 : std::cout << " not valid " << std::endl;
36688 : }
36689 : }
36690 :
36691 0 : if ( p_pragma != NULL )
36692 : {
36693 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36694 : {
36695 0 : if ( p_pragma->isInMemoryPool() == false )
36696 : {
36697 0 : std::cout << "SgFunctionDefinition :: ";
36698 0 : std::cout << " p_pragma is not in memory pool of ";
36699 0 : std::cout << p_pragma->class_name() << std::endl;
36700 : }
36701 : }
36702 : else
36703 : {
36704 0 : std::cout << "SgFunctionDefinition :: " << std::flush;
36705 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
36706 0 : std::cout << " not valid " << std::endl;
36707 : }
36708 : }
36709 :
36710 0 : if ( p_numeric_label != NULL )
36711 : {
36712 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36713 : {
36714 0 : if ( p_numeric_label->isInMemoryPool() == false )
36715 : {
36716 0 : std::cout << "SgFunctionDefinition :: ";
36717 0 : std::cout << " p_numeric_label is not in memory pool of ";
36718 0 : std::cout << p_numeric_label->class_name() << std::endl;
36719 : }
36720 : }
36721 : else
36722 : {
36723 0 : std::cout << "SgFunctionDefinition :: " << std::flush;
36724 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
36725 0 : std::cout << " not valid " << std::endl;
36726 : }
36727 : }
36728 :
36729 0 : if ( p_startOfConstruct != NULL )
36730 : {
36731 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36732 : {
36733 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
36734 : {
36735 0 : std::cout << "SgFunctionDefinition :: ";
36736 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
36737 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
36738 : }
36739 : }
36740 : else
36741 : {
36742 0 : std::cout << "SgFunctionDefinition :: " << std::flush;
36743 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
36744 0 : std::cout << " not valid " << std::endl;
36745 : }
36746 : }
36747 :
36748 0 : if ( p_endOfConstruct != NULL )
36749 : {
36750 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36751 : {
36752 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
36753 : {
36754 0 : std::cout << "SgFunctionDefinition :: ";
36755 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
36756 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
36757 : }
36758 : }
36759 : else
36760 : {
36761 0 : std::cout << "SgFunctionDefinition :: " << std::flush;
36762 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
36763 0 : std::cout << " not valid " << std::endl;
36764 : }
36765 : }
36766 :
36767 0 : if ( p_parent != NULL )
36768 : {
36769 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36770 : {
36771 0 : if ( p_parent->isInMemoryPool() == false )
36772 : {
36773 0 : std::cout << "SgFunctionDefinition :: ";
36774 0 : std::cout << " p_parent is not in memory pool of ";
36775 0 : std::cout << p_parent->class_name() << std::endl;
36776 : }
36777 : }
36778 : else
36779 : {
36780 0 : std::cout << "SgFunctionDefinition :: " << std::flush;
36781 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
36782 0 : std::cout << " not valid " << std::endl;
36783 : }
36784 : }
36785 :
36786 :
36787 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
36788 :
36789 0 : }
36790 :
36791 :
36792 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
36793 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
36794 : bool
36795 0 : SgFunctionDefinition::isInMemoryPool ()
36796 : {
36797 0 : typedef unsigned char* TestType;
36798 :
36799 0 : bool found = false;
36800 :
36801 0 : ROSE_ASSERT(this != NULL);
36802 :
36803 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
36804 :
36805 0 : TestType tested = (TestType) ( this ) ;
36806 :
36807 0 : std::vector < unsigned char* > :: const_iterator block = SgFunctionDefinition::pools.begin();
36808 :
36809 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
36810 : // while (found == false && block < Memory_Block_List.end())
36811 0 : while ( (found == false) && (block != SgFunctionDefinition::pools.end()) )
36812 : {
36813 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFunctionDefinition::pool_size * sizeof(SgFunctionDefinition) ) ) ;
36814 0 : ++block;
36815 : }
36816 :
36817 : // Special handling for static data
36818 :
36819 :
36820 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
36821 0 : ROSE_ASSERT(found == true);
36822 :
36823 0 : return found;
36824 : }
36825 : /* #line 36826 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
36826 :
36827 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
36828 :
36829 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
36830 :
36831 : /* #line 36832 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
36832 :
36833 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
36834 :
36835 : void
36836 0 : SgTemplateFunctionDefinition::checkDataMemberPointersIfInMemoryPool()
36837 : {
36838 : // ------------ checking pointers of SgTemplateFunctionDefinition -------------------
36839 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36840 :
36841 0 : if ( p_body != NULL )
36842 : {
36843 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36844 : {
36845 0 : if ( p_body->isInMemoryPool() == false )
36846 : {
36847 0 : std::cout << "SgTemplateFunctionDefinition :: ";
36848 0 : std::cout << " p_body is not in memory pool of ";
36849 0 : std::cout << p_body->class_name() << std::endl;
36850 : }
36851 : }
36852 : else
36853 : {
36854 0 : std::cout << "SgTemplateFunctionDefinition :: " << std::flush;
36855 0 : std::cout << "SgBasicBlock* p_body = " << p_body << " --> " << std::flush;
36856 0 : std::cout << " not valid " << std::endl;
36857 : }
36858 : }
36859 :
36860 0 : if ( p_symbol_table != NULL )
36861 : {
36862 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36863 : {
36864 0 : if ( p_symbol_table->isInMemoryPool() == false )
36865 : {
36866 0 : std::cout << "SgTemplateFunctionDefinition :: ";
36867 0 : std::cout << " p_symbol_table is not in memory pool of ";
36868 0 : std::cout << p_symbol_table->class_name() << std::endl;
36869 : }
36870 : }
36871 : else
36872 : {
36873 0 : std::cout << "SgTemplateFunctionDefinition :: " << std::flush;
36874 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
36875 0 : std::cout << " not valid " << std::endl;
36876 : }
36877 : }
36878 :
36879 0 : if ( p_type_table != NULL )
36880 : {
36881 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36882 : {
36883 0 : if ( p_type_table->isInMemoryPool() == false )
36884 : {
36885 0 : std::cout << "SgTemplateFunctionDefinition :: ";
36886 0 : std::cout << " p_type_table is not in memory pool of ";
36887 0 : std::cout << p_type_table->class_name() << std::endl;
36888 : }
36889 : }
36890 : else
36891 : {
36892 0 : std::cout << "SgTemplateFunctionDefinition :: " << std::flush;
36893 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
36894 0 : std::cout << " not valid " << std::endl;
36895 : }
36896 : }
36897 :
36898 0 : if ( p_pragma != NULL )
36899 : {
36900 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36901 : {
36902 0 : if ( p_pragma->isInMemoryPool() == false )
36903 : {
36904 0 : std::cout << "SgTemplateFunctionDefinition :: ";
36905 0 : std::cout << " p_pragma is not in memory pool of ";
36906 0 : std::cout << p_pragma->class_name() << std::endl;
36907 : }
36908 : }
36909 : else
36910 : {
36911 0 : std::cout << "SgTemplateFunctionDefinition :: " << std::flush;
36912 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
36913 0 : std::cout << " not valid " << std::endl;
36914 : }
36915 : }
36916 :
36917 0 : if ( p_numeric_label != NULL )
36918 : {
36919 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36920 : {
36921 0 : if ( p_numeric_label->isInMemoryPool() == false )
36922 : {
36923 0 : std::cout << "SgTemplateFunctionDefinition :: ";
36924 0 : std::cout << " p_numeric_label is not in memory pool of ";
36925 0 : std::cout << p_numeric_label->class_name() << std::endl;
36926 : }
36927 : }
36928 : else
36929 : {
36930 0 : std::cout << "SgTemplateFunctionDefinition :: " << std::flush;
36931 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
36932 0 : std::cout << " not valid " << std::endl;
36933 : }
36934 : }
36935 :
36936 0 : if ( p_startOfConstruct != NULL )
36937 : {
36938 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36939 : {
36940 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
36941 : {
36942 0 : std::cout << "SgTemplateFunctionDefinition :: ";
36943 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
36944 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
36945 : }
36946 : }
36947 : else
36948 : {
36949 0 : std::cout << "SgTemplateFunctionDefinition :: " << std::flush;
36950 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
36951 0 : std::cout << " not valid " << std::endl;
36952 : }
36953 : }
36954 :
36955 0 : if ( p_endOfConstruct != NULL )
36956 : {
36957 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36958 : {
36959 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
36960 : {
36961 0 : std::cout << "SgTemplateFunctionDefinition :: ";
36962 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
36963 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
36964 : }
36965 : }
36966 : else
36967 : {
36968 0 : std::cout << "SgTemplateFunctionDefinition :: " << std::flush;
36969 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
36970 0 : std::cout << " not valid " << std::endl;
36971 : }
36972 : }
36973 :
36974 0 : if ( p_parent != NULL )
36975 : {
36976 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
36977 : {
36978 0 : if ( p_parent->isInMemoryPool() == false )
36979 : {
36980 0 : std::cout << "SgTemplateFunctionDefinition :: ";
36981 0 : std::cout << " p_parent is not in memory pool of ";
36982 0 : std::cout << p_parent->class_name() << std::endl;
36983 : }
36984 : }
36985 : else
36986 : {
36987 0 : std::cout << "SgTemplateFunctionDefinition :: " << std::flush;
36988 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
36989 0 : std::cout << " not valid " << std::endl;
36990 : }
36991 : }
36992 :
36993 :
36994 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
36995 :
36996 0 : }
36997 :
36998 :
36999 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
37000 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
37001 : bool
37002 0 : SgTemplateFunctionDefinition::isInMemoryPool ()
37003 : {
37004 0 : typedef unsigned char* TestType;
37005 :
37006 0 : bool found = false;
37007 :
37008 0 : ROSE_ASSERT(this != NULL);
37009 :
37010 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
37011 :
37012 0 : TestType tested = (TestType) ( this ) ;
37013 :
37014 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateFunctionDefinition::pools.begin();
37015 :
37016 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
37017 : // while (found == false && block < Memory_Block_List.end())
37018 0 : while ( (found == false) && (block != SgTemplateFunctionDefinition::pools.end()) )
37019 : {
37020 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateFunctionDefinition::pool_size * sizeof(SgTemplateFunctionDefinition) ) ) ;
37021 0 : ++block;
37022 : }
37023 :
37024 : // Special handling for static data
37025 :
37026 :
37027 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
37028 0 : ROSE_ASSERT(found == true);
37029 :
37030 0 : return found;
37031 : }
37032 : /* #line 37033 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
37033 :
37034 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
37035 :
37036 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
37037 :
37038 : /* #line 37039 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
37039 :
37040 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
37041 :
37042 : void
37043 0 : SgClassDefinition::checkDataMemberPointersIfInMemoryPool()
37044 : {
37045 : // ------------ checking pointers of SgClassDefinition -------------------
37046 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37047 :
37048 0 : SgDeclarationStatementPtrList::iterator i_members = p_members.begin() ;
37049 0 : for ( ; i_members != p_members.end(); ++i_members )
37050 : {
37051 0 : if ( (*i_members) != NULL )
37052 : {
37053 0 : if ( (*i_members)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37054 : {
37055 0 : if ( (*i_members)->isInMemoryPool() == false )
37056 : {
37057 0 : std::cout << "SgClassDefinition :: ";
37058 0 : std::cout << " p_members ( list of poitners to IR nodes ), entry is not in memory pool of ";
37059 0 : std::cout << (*i_members)->class_name() << std::endl;
37060 : }
37061 : }
37062 : else
37063 : {
37064 0 : std::cout << "SgClassDefinition :: " << std::flush;
37065 0 : std::cout << "SgDeclarationStatementPtrList p_members --> " << std::flush;
37066 0 : std::cout << " entry not valid " << std::endl;
37067 : }
37068 : }
37069 : else
37070 : {
37071 0 : std::cout << "SgDeclarationStatementPtrList p_members --> NULL " << std::endl;
37072 : }
37073 : }
37074 :
37075 0 : SgBaseClassPtrList::iterator i_inheritances = p_inheritances.begin() ;
37076 0 : for ( ; i_inheritances != p_inheritances.end(); ++i_inheritances )
37077 : {
37078 0 : if ( (*i_inheritances) != NULL )
37079 : {
37080 0 : if ( (*i_inheritances)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37081 : {
37082 0 : if ( (*i_inheritances)->isInMemoryPool() == false )
37083 : {
37084 0 : std::cout << "SgClassDefinition :: ";
37085 0 : std::cout << " p_inheritances ( list of poitners to IR nodes ), entry is not in memory pool of ";
37086 0 : std::cout << (*i_inheritances)->class_name() << std::endl;
37087 : }
37088 : }
37089 : else
37090 : {
37091 0 : std::cout << "SgClassDefinition :: " << std::flush;
37092 0 : std::cout << "SgBaseClassPtrList p_inheritances --> " << std::flush;
37093 0 : std::cout << " entry not valid " << std::endl;
37094 : }
37095 : }
37096 : else
37097 : {
37098 0 : std::cout << "SgBaseClassPtrList p_inheritances --> NULL " << std::endl;
37099 : }
37100 : }
37101 :
37102 0 : if ( p_symbol_table != NULL )
37103 : {
37104 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37105 : {
37106 0 : if ( p_symbol_table->isInMemoryPool() == false )
37107 : {
37108 0 : std::cout << "SgClassDefinition :: ";
37109 0 : std::cout << " p_symbol_table is not in memory pool of ";
37110 0 : std::cout << p_symbol_table->class_name() << std::endl;
37111 : }
37112 : }
37113 : else
37114 : {
37115 0 : std::cout << "SgClassDefinition :: " << std::flush;
37116 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
37117 0 : std::cout << " not valid " << std::endl;
37118 : }
37119 : }
37120 :
37121 0 : if ( p_type_table != NULL )
37122 : {
37123 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37124 : {
37125 0 : if ( p_type_table->isInMemoryPool() == false )
37126 : {
37127 0 : std::cout << "SgClassDefinition :: ";
37128 0 : std::cout << " p_type_table is not in memory pool of ";
37129 0 : std::cout << p_type_table->class_name() << std::endl;
37130 : }
37131 : }
37132 : else
37133 : {
37134 0 : std::cout << "SgClassDefinition :: " << std::flush;
37135 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
37136 0 : std::cout << " not valid " << std::endl;
37137 : }
37138 : }
37139 :
37140 0 : if ( p_pragma != NULL )
37141 : {
37142 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37143 : {
37144 0 : if ( p_pragma->isInMemoryPool() == false )
37145 : {
37146 0 : std::cout << "SgClassDefinition :: ";
37147 0 : std::cout << " p_pragma is not in memory pool of ";
37148 0 : std::cout << p_pragma->class_name() << std::endl;
37149 : }
37150 : }
37151 : else
37152 : {
37153 0 : std::cout << "SgClassDefinition :: " << std::flush;
37154 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
37155 0 : std::cout << " not valid " << std::endl;
37156 : }
37157 : }
37158 :
37159 0 : if ( p_numeric_label != NULL )
37160 : {
37161 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37162 : {
37163 0 : if ( p_numeric_label->isInMemoryPool() == false )
37164 : {
37165 0 : std::cout << "SgClassDefinition :: ";
37166 0 : std::cout << " p_numeric_label is not in memory pool of ";
37167 0 : std::cout << p_numeric_label->class_name() << std::endl;
37168 : }
37169 : }
37170 : else
37171 : {
37172 0 : std::cout << "SgClassDefinition :: " << std::flush;
37173 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
37174 0 : std::cout << " not valid " << std::endl;
37175 : }
37176 : }
37177 :
37178 0 : if ( p_startOfConstruct != NULL )
37179 : {
37180 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37181 : {
37182 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
37183 : {
37184 0 : std::cout << "SgClassDefinition :: ";
37185 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
37186 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
37187 : }
37188 : }
37189 : else
37190 : {
37191 0 : std::cout << "SgClassDefinition :: " << std::flush;
37192 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
37193 0 : std::cout << " not valid " << std::endl;
37194 : }
37195 : }
37196 :
37197 0 : if ( p_endOfConstruct != NULL )
37198 : {
37199 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37200 : {
37201 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
37202 : {
37203 0 : std::cout << "SgClassDefinition :: ";
37204 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
37205 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
37206 : }
37207 : }
37208 : else
37209 : {
37210 0 : std::cout << "SgClassDefinition :: " << std::flush;
37211 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
37212 0 : std::cout << " not valid " << std::endl;
37213 : }
37214 : }
37215 :
37216 0 : if ( p_parent != NULL )
37217 : {
37218 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37219 : {
37220 0 : if ( p_parent->isInMemoryPool() == false )
37221 : {
37222 0 : std::cout << "SgClassDefinition :: ";
37223 0 : std::cout << " p_parent is not in memory pool of ";
37224 0 : std::cout << p_parent->class_name() << std::endl;
37225 : }
37226 : }
37227 : else
37228 : {
37229 0 : std::cout << "SgClassDefinition :: " << std::flush;
37230 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
37231 0 : std::cout << " not valid " << std::endl;
37232 : }
37233 : }
37234 :
37235 :
37236 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
37237 :
37238 0 : }
37239 :
37240 :
37241 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
37242 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
37243 : bool
37244 0 : SgClassDefinition::isInMemoryPool ()
37245 : {
37246 0 : typedef unsigned char* TestType;
37247 :
37248 0 : bool found = false;
37249 :
37250 0 : ROSE_ASSERT(this != NULL);
37251 :
37252 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
37253 :
37254 0 : TestType tested = (TestType) ( this ) ;
37255 :
37256 0 : std::vector < unsigned char* > :: const_iterator block = SgClassDefinition::pools.begin();
37257 :
37258 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
37259 : // while (found == false && block < Memory_Block_List.end())
37260 0 : while ( (found == false) && (block != SgClassDefinition::pools.end()) )
37261 : {
37262 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgClassDefinition::pool_size * sizeof(SgClassDefinition) ) ) ;
37263 0 : ++block;
37264 : }
37265 :
37266 : // Special handling for static data
37267 :
37268 :
37269 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
37270 0 : ROSE_ASSERT(found == true);
37271 :
37272 0 : return found;
37273 : }
37274 : /* #line 37275 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
37275 :
37276 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
37277 :
37278 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
37279 :
37280 : /* #line 37281 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
37281 :
37282 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
37283 :
37284 : void
37285 0 : SgTemplateInstantiationDefn::checkDataMemberPointersIfInMemoryPool()
37286 : {
37287 : // ------------ checking pointers of SgTemplateInstantiationDefn -------------------
37288 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37289 :
37290 0 : SgDeclarationStatementPtrList::iterator i_members = p_members.begin() ;
37291 0 : for ( ; i_members != p_members.end(); ++i_members )
37292 : {
37293 0 : if ( (*i_members) != NULL )
37294 : {
37295 0 : if ( (*i_members)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37296 : {
37297 0 : if ( (*i_members)->isInMemoryPool() == false )
37298 : {
37299 0 : std::cout << "SgTemplateInstantiationDefn :: ";
37300 0 : std::cout << " p_members ( list of poitners to IR nodes ), entry is not in memory pool of ";
37301 0 : std::cout << (*i_members)->class_name() << std::endl;
37302 : }
37303 : }
37304 : else
37305 : {
37306 0 : std::cout << "SgTemplateInstantiationDefn :: " << std::flush;
37307 0 : std::cout << "SgDeclarationStatementPtrList p_members --> " << std::flush;
37308 0 : std::cout << " entry not valid " << std::endl;
37309 : }
37310 : }
37311 : else
37312 : {
37313 0 : std::cout << "SgDeclarationStatementPtrList p_members --> NULL " << std::endl;
37314 : }
37315 : }
37316 :
37317 0 : SgBaseClassPtrList::iterator i_inheritances = p_inheritances.begin() ;
37318 0 : for ( ; i_inheritances != p_inheritances.end(); ++i_inheritances )
37319 : {
37320 0 : if ( (*i_inheritances) != NULL )
37321 : {
37322 0 : if ( (*i_inheritances)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37323 : {
37324 0 : if ( (*i_inheritances)->isInMemoryPool() == false )
37325 : {
37326 0 : std::cout << "SgTemplateInstantiationDefn :: ";
37327 0 : std::cout << " p_inheritances ( list of poitners to IR nodes ), entry is not in memory pool of ";
37328 0 : std::cout << (*i_inheritances)->class_name() << std::endl;
37329 : }
37330 : }
37331 : else
37332 : {
37333 0 : std::cout << "SgTemplateInstantiationDefn :: " << std::flush;
37334 0 : std::cout << "SgBaseClassPtrList p_inheritances --> " << std::flush;
37335 0 : std::cout << " entry not valid " << std::endl;
37336 : }
37337 : }
37338 : else
37339 : {
37340 0 : std::cout << "SgBaseClassPtrList p_inheritances --> NULL " << std::endl;
37341 : }
37342 : }
37343 :
37344 0 : if ( p_symbol_table != NULL )
37345 : {
37346 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37347 : {
37348 0 : if ( p_symbol_table->isInMemoryPool() == false )
37349 : {
37350 0 : std::cout << "SgTemplateInstantiationDefn :: ";
37351 0 : std::cout << " p_symbol_table is not in memory pool of ";
37352 0 : std::cout << p_symbol_table->class_name() << std::endl;
37353 : }
37354 : }
37355 : else
37356 : {
37357 0 : std::cout << "SgTemplateInstantiationDefn :: " << std::flush;
37358 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
37359 0 : std::cout << " not valid " << std::endl;
37360 : }
37361 : }
37362 :
37363 0 : if ( p_type_table != NULL )
37364 : {
37365 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37366 : {
37367 0 : if ( p_type_table->isInMemoryPool() == false )
37368 : {
37369 0 : std::cout << "SgTemplateInstantiationDefn :: ";
37370 0 : std::cout << " p_type_table is not in memory pool of ";
37371 0 : std::cout << p_type_table->class_name() << std::endl;
37372 : }
37373 : }
37374 : else
37375 : {
37376 0 : std::cout << "SgTemplateInstantiationDefn :: " << std::flush;
37377 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
37378 0 : std::cout << " not valid " << std::endl;
37379 : }
37380 : }
37381 :
37382 0 : if ( p_pragma != NULL )
37383 : {
37384 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37385 : {
37386 0 : if ( p_pragma->isInMemoryPool() == false )
37387 : {
37388 0 : std::cout << "SgTemplateInstantiationDefn :: ";
37389 0 : std::cout << " p_pragma is not in memory pool of ";
37390 0 : std::cout << p_pragma->class_name() << std::endl;
37391 : }
37392 : }
37393 : else
37394 : {
37395 0 : std::cout << "SgTemplateInstantiationDefn :: " << std::flush;
37396 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
37397 0 : std::cout << " not valid " << std::endl;
37398 : }
37399 : }
37400 :
37401 0 : if ( p_numeric_label != NULL )
37402 : {
37403 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37404 : {
37405 0 : if ( p_numeric_label->isInMemoryPool() == false )
37406 : {
37407 0 : std::cout << "SgTemplateInstantiationDefn :: ";
37408 0 : std::cout << " p_numeric_label is not in memory pool of ";
37409 0 : std::cout << p_numeric_label->class_name() << std::endl;
37410 : }
37411 : }
37412 : else
37413 : {
37414 0 : std::cout << "SgTemplateInstantiationDefn :: " << std::flush;
37415 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
37416 0 : std::cout << " not valid " << std::endl;
37417 : }
37418 : }
37419 :
37420 0 : if ( p_startOfConstruct != NULL )
37421 : {
37422 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37423 : {
37424 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
37425 : {
37426 0 : std::cout << "SgTemplateInstantiationDefn :: ";
37427 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
37428 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
37429 : }
37430 : }
37431 : else
37432 : {
37433 0 : std::cout << "SgTemplateInstantiationDefn :: " << std::flush;
37434 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
37435 0 : std::cout << " not valid " << std::endl;
37436 : }
37437 : }
37438 :
37439 0 : if ( p_endOfConstruct != NULL )
37440 : {
37441 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37442 : {
37443 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
37444 : {
37445 0 : std::cout << "SgTemplateInstantiationDefn :: ";
37446 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
37447 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
37448 : }
37449 : }
37450 : else
37451 : {
37452 0 : std::cout << "SgTemplateInstantiationDefn :: " << std::flush;
37453 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
37454 0 : std::cout << " not valid " << std::endl;
37455 : }
37456 : }
37457 :
37458 0 : if ( p_parent != NULL )
37459 : {
37460 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37461 : {
37462 0 : if ( p_parent->isInMemoryPool() == false )
37463 : {
37464 0 : std::cout << "SgTemplateInstantiationDefn :: ";
37465 0 : std::cout << " p_parent is not in memory pool of ";
37466 0 : std::cout << p_parent->class_name() << std::endl;
37467 : }
37468 : }
37469 : else
37470 : {
37471 0 : std::cout << "SgTemplateInstantiationDefn :: " << std::flush;
37472 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
37473 0 : std::cout << " not valid " << std::endl;
37474 : }
37475 : }
37476 :
37477 :
37478 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
37479 :
37480 0 : }
37481 :
37482 :
37483 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
37484 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
37485 : bool
37486 0 : SgTemplateInstantiationDefn::isInMemoryPool ()
37487 : {
37488 0 : typedef unsigned char* TestType;
37489 :
37490 0 : bool found = false;
37491 :
37492 0 : ROSE_ASSERT(this != NULL);
37493 :
37494 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
37495 :
37496 0 : TestType tested = (TestType) ( this ) ;
37497 :
37498 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateInstantiationDefn::pools.begin();
37499 :
37500 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
37501 : // while (found == false && block < Memory_Block_List.end())
37502 0 : while ( (found == false) && (block != SgTemplateInstantiationDefn::pools.end()) )
37503 : {
37504 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateInstantiationDefn::pool_size * sizeof(SgTemplateInstantiationDefn) ) ) ;
37505 0 : ++block;
37506 : }
37507 :
37508 : // Special handling for static data
37509 :
37510 :
37511 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
37512 0 : ROSE_ASSERT(found == true);
37513 :
37514 0 : return found;
37515 : }
37516 : /* #line 37517 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
37517 :
37518 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
37519 :
37520 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
37521 :
37522 : /* #line 37523 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
37523 :
37524 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
37525 :
37526 : void
37527 0 : SgTemplateClassDefinition::checkDataMemberPointersIfInMemoryPool()
37528 : {
37529 : // ------------ checking pointers of SgTemplateClassDefinition -------------------
37530 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37531 :
37532 0 : SgDeclarationStatementPtrList::iterator i_members = p_members.begin() ;
37533 0 : for ( ; i_members != p_members.end(); ++i_members )
37534 : {
37535 0 : if ( (*i_members) != NULL )
37536 : {
37537 0 : if ( (*i_members)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37538 : {
37539 0 : if ( (*i_members)->isInMemoryPool() == false )
37540 : {
37541 0 : std::cout << "SgTemplateClassDefinition :: ";
37542 0 : std::cout << " p_members ( list of poitners to IR nodes ), entry is not in memory pool of ";
37543 0 : std::cout << (*i_members)->class_name() << std::endl;
37544 : }
37545 : }
37546 : else
37547 : {
37548 0 : std::cout << "SgTemplateClassDefinition :: " << std::flush;
37549 0 : std::cout << "SgDeclarationStatementPtrList p_members --> " << std::flush;
37550 0 : std::cout << " entry not valid " << std::endl;
37551 : }
37552 : }
37553 : else
37554 : {
37555 0 : std::cout << "SgDeclarationStatementPtrList p_members --> NULL " << std::endl;
37556 : }
37557 : }
37558 :
37559 0 : SgBaseClassPtrList::iterator i_inheritances = p_inheritances.begin() ;
37560 0 : for ( ; i_inheritances != p_inheritances.end(); ++i_inheritances )
37561 : {
37562 0 : if ( (*i_inheritances) != NULL )
37563 : {
37564 0 : if ( (*i_inheritances)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37565 : {
37566 0 : if ( (*i_inheritances)->isInMemoryPool() == false )
37567 : {
37568 0 : std::cout << "SgTemplateClassDefinition :: ";
37569 0 : std::cout << " p_inheritances ( list of poitners to IR nodes ), entry is not in memory pool of ";
37570 0 : std::cout << (*i_inheritances)->class_name() << std::endl;
37571 : }
37572 : }
37573 : else
37574 : {
37575 0 : std::cout << "SgTemplateClassDefinition :: " << std::flush;
37576 0 : std::cout << "SgBaseClassPtrList p_inheritances --> " << std::flush;
37577 0 : std::cout << " entry not valid " << std::endl;
37578 : }
37579 : }
37580 : else
37581 : {
37582 0 : std::cout << "SgBaseClassPtrList p_inheritances --> NULL " << std::endl;
37583 : }
37584 : }
37585 :
37586 0 : if ( p_symbol_table != NULL )
37587 : {
37588 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37589 : {
37590 0 : if ( p_symbol_table->isInMemoryPool() == false )
37591 : {
37592 0 : std::cout << "SgTemplateClassDefinition :: ";
37593 0 : std::cout << " p_symbol_table is not in memory pool of ";
37594 0 : std::cout << p_symbol_table->class_name() << std::endl;
37595 : }
37596 : }
37597 : else
37598 : {
37599 0 : std::cout << "SgTemplateClassDefinition :: " << std::flush;
37600 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
37601 0 : std::cout << " not valid " << std::endl;
37602 : }
37603 : }
37604 :
37605 0 : if ( p_type_table != NULL )
37606 : {
37607 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37608 : {
37609 0 : if ( p_type_table->isInMemoryPool() == false )
37610 : {
37611 0 : std::cout << "SgTemplateClassDefinition :: ";
37612 0 : std::cout << " p_type_table is not in memory pool of ";
37613 0 : std::cout << p_type_table->class_name() << std::endl;
37614 : }
37615 : }
37616 : else
37617 : {
37618 0 : std::cout << "SgTemplateClassDefinition :: " << std::flush;
37619 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
37620 0 : std::cout << " not valid " << std::endl;
37621 : }
37622 : }
37623 :
37624 0 : if ( p_pragma != NULL )
37625 : {
37626 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37627 : {
37628 0 : if ( p_pragma->isInMemoryPool() == false )
37629 : {
37630 0 : std::cout << "SgTemplateClassDefinition :: ";
37631 0 : std::cout << " p_pragma is not in memory pool of ";
37632 0 : std::cout << p_pragma->class_name() << std::endl;
37633 : }
37634 : }
37635 : else
37636 : {
37637 0 : std::cout << "SgTemplateClassDefinition :: " << std::flush;
37638 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
37639 0 : std::cout << " not valid " << std::endl;
37640 : }
37641 : }
37642 :
37643 0 : if ( p_numeric_label != NULL )
37644 : {
37645 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37646 : {
37647 0 : if ( p_numeric_label->isInMemoryPool() == false )
37648 : {
37649 0 : std::cout << "SgTemplateClassDefinition :: ";
37650 0 : std::cout << " p_numeric_label is not in memory pool of ";
37651 0 : std::cout << p_numeric_label->class_name() << std::endl;
37652 : }
37653 : }
37654 : else
37655 : {
37656 0 : std::cout << "SgTemplateClassDefinition :: " << std::flush;
37657 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
37658 0 : std::cout << " not valid " << std::endl;
37659 : }
37660 : }
37661 :
37662 0 : if ( p_startOfConstruct != NULL )
37663 : {
37664 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37665 : {
37666 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
37667 : {
37668 0 : std::cout << "SgTemplateClassDefinition :: ";
37669 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
37670 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
37671 : }
37672 : }
37673 : else
37674 : {
37675 0 : std::cout << "SgTemplateClassDefinition :: " << std::flush;
37676 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
37677 0 : std::cout << " not valid " << std::endl;
37678 : }
37679 : }
37680 :
37681 0 : if ( p_endOfConstruct != NULL )
37682 : {
37683 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37684 : {
37685 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
37686 : {
37687 0 : std::cout << "SgTemplateClassDefinition :: ";
37688 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
37689 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
37690 : }
37691 : }
37692 : else
37693 : {
37694 0 : std::cout << "SgTemplateClassDefinition :: " << std::flush;
37695 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
37696 0 : std::cout << " not valid " << std::endl;
37697 : }
37698 : }
37699 :
37700 0 : if ( p_parent != NULL )
37701 : {
37702 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37703 : {
37704 0 : if ( p_parent->isInMemoryPool() == false )
37705 : {
37706 0 : std::cout << "SgTemplateClassDefinition :: ";
37707 0 : std::cout << " p_parent is not in memory pool of ";
37708 0 : std::cout << p_parent->class_name() << std::endl;
37709 : }
37710 : }
37711 : else
37712 : {
37713 0 : std::cout << "SgTemplateClassDefinition :: " << std::flush;
37714 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
37715 0 : std::cout << " not valid " << std::endl;
37716 : }
37717 : }
37718 :
37719 :
37720 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
37721 :
37722 0 : }
37723 :
37724 :
37725 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
37726 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
37727 : bool
37728 0 : SgTemplateClassDefinition::isInMemoryPool ()
37729 : {
37730 0 : typedef unsigned char* TestType;
37731 :
37732 0 : bool found = false;
37733 :
37734 0 : ROSE_ASSERT(this != NULL);
37735 :
37736 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
37737 :
37738 0 : TestType tested = (TestType) ( this ) ;
37739 :
37740 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateClassDefinition::pools.begin();
37741 :
37742 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
37743 : // while (found == false && block < Memory_Block_List.end())
37744 0 : while ( (found == false) && (block != SgTemplateClassDefinition::pools.end()) )
37745 : {
37746 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateClassDefinition::pool_size * sizeof(SgTemplateClassDefinition) ) ) ;
37747 0 : ++block;
37748 : }
37749 :
37750 : // Special handling for static data
37751 :
37752 :
37753 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
37754 0 : ROSE_ASSERT(found == true);
37755 :
37756 0 : return found;
37757 : }
37758 : /* #line 37759 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
37759 :
37760 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
37761 :
37762 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
37763 :
37764 : /* #line 37765 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
37765 :
37766 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
37767 :
37768 : void
37769 0 : SgWhileStmt::checkDataMemberPointersIfInMemoryPool()
37770 : {
37771 : // ------------ checking pointers of SgWhileStmt -------------------
37772 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37773 :
37774 0 : if ( p_condition != NULL )
37775 : {
37776 0 : if ( p_condition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37777 : {
37778 0 : if ( p_condition->isInMemoryPool() == false )
37779 : {
37780 0 : std::cout << "SgWhileStmt :: ";
37781 0 : std::cout << " p_condition is not in memory pool of ";
37782 0 : std::cout << p_condition->class_name() << std::endl;
37783 : }
37784 : }
37785 : else
37786 : {
37787 0 : std::cout << "SgWhileStmt :: " << std::flush;
37788 0 : std::cout << "SgStatement* p_condition = " << p_condition << " --> " << std::flush;
37789 0 : std::cout << " not valid " << std::endl;
37790 : }
37791 : }
37792 :
37793 0 : if ( p_body != NULL )
37794 : {
37795 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37796 : {
37797 0 : if ( p_body->isInMemoryPool() == false )
37798 : {
37799 0 : std::cout << "SgWhileStmt :: ";
37800 0 : std::cout << " p_body is not in memory pool of ";
37801 0 : std::cout << p_body->class_name() << std::endl;
37802 : }
37803 : }
37804 : else
37805 : {
37806 0 : std::cout << "SgWhileStmt :: " << std::flush;
37807 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
37808 0 : std::cout << " not valid " << std::endl;
37809 : }
37810 : }
37811 :
37812 0 : if ( p_else_body != NULL )
37813 : {
37814 0 : if ( p_else_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37815 : {
37816 0 : if ( p_else_body->isInMemoryPool() == false )
37817 : {
37818 0 : std::cout << "SgWhileStmt :: ";
37819 0 : std::cout << " p_else_body is not in memory pool of ";
37820 0 : std::cout << p_else_body->class_name() << std::endl;
37821 : }
37822 : }
37823 : else
37824 : {
37825 0 : std::cout << "SgWhileStmt :: " << std::flush;
37826 0 : std::cout << "SgStatement* p_else_body = " << p_else_body << " --> " << std::flush;
37827 0 : std::cout << " not valid " << std::endl;
37828 : }
37829 : }
37830 :
37831 0 : if ( p_end_numeric_label != NULL )
37832 : {
37833 0 : if ( p_end_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37834 : {
37835 0 : if ( p_end_numeric_label->isInMemoryPool() == false )
37836 : {
37837 0 : std::cout << "SgWhileStmt :: ";
37838 0 : std::cout << " p_end_numeric_label is not in memory pool of ";
37839 0 : std::cout << p_end_numeric_label->class_name() << std::endl;
37840 : }
37841 : }
37842 : else
37843 : {
37844 0 : std::cout << "SgWhileStmt :: " << std::flush;
37845 0 : std::cout << "SgLabelRefExp* p_end_numeric_label = " << p_end_numeric_label << " --> " << std::flush;
37846 0 : std::cout << " not valid " << std::endl;
37847 : }
37848 : }
37849 :
37850 0 : if ( p_symbol_table != NULL )
37851 : {
37852 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37853 : {
37854 0 : if ( p_symbol_table->isInMemoryPool() == false )
37855 : {
37856 0 : std::cout << "SgWhileStmt :: ";
37857 0 : std::cout << " p_symbol_table is not in memory pool of ";
37858 0 : std::cout << p_symbol_table->class_name() << std::endl;
37859 : }
37860 : }
37861 : else
37862 : {
37863 0 : std::cout << "SgWhileStmt :: " << std::flush;
37864 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
37865 0 : std::cout << " not valid " << std::endl;
37866 : }
37867 : }
37868 :
37869 0 : if ( p_type_table != NULL )
37870 : {
37871 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37872 : {
37873 0 : if ( p_type_table->isInMemoryPool() == false )
37874 : {
37875 0 : std::cout << "SgWhileStmt :: ";
37876 0 : std::cout << " p_type_table is not in memory pool of ";
37877 0 : std::cout << p_type_table->class_name() << std::endl;
37878 : }
37879 : }
37880 : else
37881 : {
37882 0 : std::cout << "SgWhileStmt :: " << std::flush;
37883 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
37884 0 : std::cout << " not valid " << std::endl;
37885 : }
37886 : }
37887 :
37888 0 : if ( p_pragma != NULL )
37889 : {
37890 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37891 : {
37892 0 : if ( p_pragma->isInMemoryPool() == false )
37893 : {
37894 0 : std::cout << "SgWhileStmt :: ";
37895 0 : std::cout << " p_pragma is not in memory pool of ";
37896 0 : std::cout << p_pragma->class_name() << std::endl;
37897 : }
37898 : }
37899 : else
37900 : {
37901 0 : std::cout << "SgWhileStmt :: " << std::flush;
37902 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
37903 0 : std::cout << " not valid " << std::endl;
37904 : }
37905 : }
37906 :
37907 0 : if ( p_numeric_label != NULL )
37908 : {
37909 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37910 : {
37911 0 : if ( p_numeric_label->isInMemoryPool() == false )
37912 : {
37913 0 : std::cout << "SgWhileStmt :: ";
37914 0 : std::cout << " p_numeric_label is not in memory pool of ";
37915 0 : std::cout << p_numeric_label->class_name() << std::endl;
37916 : }
37917 : }
37918 : else
37919 : {
37920 0 : std::cout << "SgWhileStmt :: " << std::flush;
37921 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
37922 0 : std::cout << " not valid " << std::endl;
37923 : }
37924 : }
37925 :
37926 0 : if ( p_startOfConstruct != NULL )
37927 : {
37928 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37929 : {
37930 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
37931 : {
37932 0 : std::cout << "SgWhileStmt :: ";
37933 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
37934 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
37935 : }
37936 : }
37937 : else
37938 : {
37939 0 : std::cout << "SgWhileStmt :: " << std::flush;
37940 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
37941 0 : std::cout << " not valid " << std::endl;
37942 : }
37943 : }
37944 :
37945 0 : if ( p_endOfConstruct != NULL )
37946 : {
37947 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37948 : {
37949 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
37950 : {
37951 0 : std::cout << "SgWhileStmt :: ";
37952 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
37953 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
37954 : }
37955 : }
37956 : else
37957 : {
37958 0 : std::cout << "SgWhileStmt :: " << std::flush;
37959 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
37960 0 : std::cout << " not valid " << std::endl;
37961 : }
37962 : }
37963 :
37964 0 : if ( p_parent != NULL )
37965 : {
37966 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
37967 : {
37968 0 : if ( p_parent->isInMemoryPool() == false )
37969 : {
37970 0 : std::cout << "SgWhileStmt :: ";
37971 0 : std::cout << " p_parent is not in memory pool of ";
37972 0 : std::cout << p_parent->class_name() << std::endl;
37973 : }
37974 : }
37975 : else
37976 : {
37977 0 : std::cout << "SgWhileStmt :: " << std::flush;
37978 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
37979 0 : std::cout << " not valid " << std::endl;
37980 : }
37981 : }
37982 :
37983 :
37984 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
37985 :
37986 0 : }
37987 :
37988 :
37989 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
37990 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
37991 : bool
37992 0 : SgWhileStmt::isInMemoryPool ()
37993 : {
37994 0 : typedef unsigned char* TestType;
37995 :
37996 0 : bool found = false;
37997 :
37998 0 : ROSE_ASSERT(this != NULL);
37999 :
38000 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
38001 :
38002 0 : TestType tested = (TestType) ( this ) ;
38003 :
38004 0 : std::vector < unsigned char* > :: const_iterator block = SgWhileStmt::pools.begin();
38005 :
38006 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
38007 : // while (found == false && block < Memory_Block_List.end())
38008 0 : while ( (found == false) && (block != SgWhileStmt::pools.end()) )
38009 : {
38010 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgWhileStmt::pool_size * sizeof(SgWhileStmt) ) ) ;
38011 0 : ++block;
38012 : }
38013 :
38014 : // Special handling for static data
38015 :
38016 :
38017 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
38018 0 : ROSE_ASSERT(found == true);
38019 :
38020 0 : return found;
38021 : }
38022 : /* #line 38023 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
38023 :
38024 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
38025 :
38026 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
38027 :
38028 : /* #line 38029 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
38029 :
38030 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
38031 :
38032 : void
38033 0 : SgDoWhileStmt::checkDataMemberPointersIfInMemoryPool()
38034 : {
38035 : // ------------ checking pointers of SgDoWhileStmt -------------------
38036 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38037 :
38038 0 : if ( p_body != NULL )
38039 : {
38040 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38041 : {
38042 0 : if ( p_body->isInMemoryPool() == false )
38043 : {
38044 0 : std::cout << "SgDoWhileStmt :: ";
38045 0 : std::cout << " p_body is not in memory pool of ";
38046 0 : std::cout << p_body->class_name() << std::endl;
38047 : }
38048 : }
38049 : else
38050 : {
38051 0 : std::cout << "SgDoWhileStmt :: " << std::flush;
38052 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
38053 0 : std::cout << " not valid " << std::endl;
38054 : }
38055 : }
38056 :
38057 0 : if ( p_condition != NULL )
38058 : {
38059 0 : if ( p_condition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38060 : {
38061 0 : if ( p_condition->isInMemoryPool() == false )
38062 : {
38063 0 : std::cout << "SgDoWhileStmt :: ";
38064 0 : std::cout << " p_condition is not in memory pool of ";
38065 0 : std::cout << p_condition->class_name() << std::endl;
38066 : }
38067 : }
38068 : else
38069 : {
38070 0 : std::cout << "SgDoWhileStmt :: " << std::flush;
38071 0 : std::cout << "SgStatement* p_condition = " << p_condition << " --> " << std::flush;
38072 0 : std::cout << " not valid " << std::endl;
38073 : }
38074 : }
38075 :
38076 0 : if ( p_symbol_table != NULL )
38077 : {
38078 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38079 : {
38080 0 : if ( p_symbol_table->isInMemoryPool() == false )
38081 : {
38082 0 : std::cout << "SgDoWhileStmt :: ";
38083 0 : std::cout << " p_symbol_table is not in memory pool of ";
38084 0 : std::cout << p_symbol_table->class_name() << std::endl;
38085 : }
38086 : }
38087 : else
38088 : {
38089 0 : std::cout << "SgDoWhileStmt :: " << std::flush;
38090 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
38091 0 : std::cout << " not valid " << std::endl;
38092 : }
38093 : }
38094 :
38095 0 : if ( p_type_table != NULL )
38096 : {
38097 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38098 : {
38099 0 : if ( p_type_table->isInMemoryPool() == false )
38100 : {
38101 0 : std::cout << "SgDoWhileStmt :: ";
38102 0 : std::cout << " p_type_table is not in memory pool of ";
38103 0 : std::cout << p_type_table->class_name() << std::endl;
38104 : }
38105 : }
38106 : else
38107 : {
38108 0 : std::cout << "SgDoWhileStmt :: " << std::flush;
38109 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
38110 0 : std::cout << " not valid " << std::endl;
38111 : }
38112 : }
38113 :
38114 0 : if ( p_pragma != NULL )
38115 : {
38116 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38117 : {
38118 0 : if ( p_pragma->isInMemoryPool() == false )
38119 : {
38120 0 : std::cout << "SgDoWhileStmt :: ";
38121 0 : std::cout << " p_pragma is not in memory pool of ";
38122 0 : std::cout << p_pragma->class_name() << std::endl;
38123 : }
38124 : }
38125 : else
38126 : {
38127 0 : std::cout << "SgDoWhileStmt :: " << std::flush;
38128 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
38129 0 : std::cout << " not valid " << std::endl;
38130 : }
38131 : }
38132 :
38133 0 : if ( p_numeric_label != NULL )
38134 : {
38135 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38136 : {
38137 0 : if ( p_numeric_label->isInMemoryPool() == false )
38138 : {
38139 0 : std::cout << "SgDoWhileStmt :: ";
38140 0 : std::cout << " p_numeric_label is not in memory pool of ";
38141 0 : std::cout << p_numeric_label->class_name() << std::endl;
38142 : }
38143 : }
38144 : else
38145 : {
38146 0 : std::cout << "SgDoWhileStmt :: " << std::flush;
38147 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
38148 0 : std::cout << " not valid " << std::endl;
38149 : }
38150 : }
38151 :
38152 0 : if ( p_startOfConstruct != NULL )
38153 : {
38154 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38155 : {
38156 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
38157 : {
38158 0 : std::cout << "SgDoWhileStmt :: ";
38159 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
38160 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
38161 : }
38162 : }
38163 : else
38164 : {
38165 0 : std::cout << "SgDoWhileStmt :: " << std::flush;
38166 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
38167 0 : std::cout << " not valid " << std::endl;
38168 : }
38169 : }
38170 :
38171 0 : if ( p_endOfConstruct != NULL )
38172 : {
38173 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38174 : {
38175 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
38176 : {
38177 0 : std::cout << "SgDoWhileStmt :: ";
38178 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
38179 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
38180 : }
38181 : }
38182 : else
38183 : {
38184 0 : std::cout << "SgDoWhileStmt :: " << std::flush;
38185 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
38186 0 : std::cout << " not valid " << std::endl;
38187 : }
38188 : }
38189 :
38190 0 : if ( p_parent != NULL )
38191 : {
38192 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38193 : {
38194 0 : if ( p_parent->isInMemoryPool() == false )
38195 : {
38196 0 : std::cout << "SgDoWhileStmt :: ";
38197 0 : std::cout << " p_parent is not in memory pool of ";
38198 0 : std::cout << p_parent->class_name() << std::endl;
38199 : }
38200 : }
38201 : else
38202 : {
38203 0 : std::cout << "SgDoWhileStmt :: " << std::flush;
38204 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
38205 0 : std::cout << " not valid " << std::endl;
38206 : }
38207 : }
38208 :
38209 :
38210 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
38211 :
38212 0 : }
38213 :
38214 :
38215 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
38216 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
38217 : bool
38218 0 : SgDoWhileStmt::isInMemoryPool ()
38219 : {
38220 0 : typedef unsigned char* TestType;
38221 :
38222 0 : bool found = false;
38223 :
38224 0 : ROSE_ASSERT(this != NULL);
38225 :
38226 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
38227 :
38228 0 : TestType tested = (TestType) ( this ) ;
38229 :
38230 0 : std::vector < unsigned char* > :: const_iterator block = SgDoWhileStmt::pools.begin();
38231 :
38232 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
38233 : // while (found == false && block < Memory_Block_List.end())
38234 0 : while ( (found == false) && (block != SgDoWhileStmt::pools.end()) )
38235 : {
38236 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDoWhileStmt::pool_size * sizeof(SgDoWhileStmt) ) ) ;
38237 0 : ++block;
38238 : }
38239 :
38240 : // Special handling for static data
38241 :
38242 :
38243 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
38244 0 : ROSE_ASSERT(found == true);
38245 :
38246 0 : return found;
38247 : }
38248 : /* #line 38249 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
38249 :
38250 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
38251 :
38252 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
38253 :
38254 : /* #line 38255 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
38255 :
38256 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
38257 :
38258 : void
38259 0 : SgSwitchStatement::checkDataMemberPointersIfInMemoryPool()
38260 : {
38261 : // ------------ checking pointers of SgSwitchStatement -------------------
38262 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38263 :
38264 0 : if ( p_item_selector != NULL )
38265 : {
38266 0 : if ( p_item_selector->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38267 : {
38268 0 : if ( p_item_selector->isInMemoryPool() == false )
38269 : {
38270 0 : std::cout << "SgSwitchStatement :: ";
38271 0 : std::cout << " p_item_selector is not in memory pool of ";
38272 0 : std::cout << p_item_selector->class_name() << std::endl;
38273 : }
38274 : }
38275 : else
38276 : {
38277 0 : std::cout << "SgSwitchStatement :: " << std::flush;
38278 0 : std::cout << "SgStatement* p_item_selector = " << p_item_selector << " --> " << std::flush;
38279 0 : std::cout << " not valid " << std::endl;
38280 : }
38281 : }
38282 :
38283 0 : if ( p_body != NULL )
38284 : {
38285 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38286 : {
38287 0 : if ( p_body->isInMemoryPool() == false )
38288 : {
38289 0 : std::cout << "SgSwitchStatement :: ";
38290 0 : std::cout << " p_body is not in memory pool of ";
38291 0 : std::cout << p_body->class_name() << std::endl;
38292 : }
38293 : }
38294 : else
38295 : {
38296 0 : std::cout << "SgSwitchStatement :: " << std::flush;
38297 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
38298 0 : std::cout << " not valid " << std::endl;
38299 : }
38300 : }
38301 :
38302 0 : if ( p_end_numeric_label != NULL )
38303 : {
38304 0 : if ( p_end_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38305 : {
38306 0 : if ( p_end_numeric_label->isInMemoryPool() == false )
38307 : {
38308 0 : std::cout << "SgSwitchStatement :: ";
38309 0 : std::cout << " p_end_numeric_label is not in memory pool of ";
38310 0 : std::cout << p_end_numeric_label->class_name() << std::endl;
38311 : }
38312 : }
38313 : else
38314 : {
38315 0 : std::cout << "SgSwitchStatement :: " << std::flush;
38316 0 : std::cout << "SgLabelRefExp* p_end_numeric_label = " << p_end_numeric_label << " --> " << std::flush;
38317 0 : std::cout << " not valid " << std::endl;
38318 : }
38319 : }
38320 :
38321 0 : if ( p_symbol_table != NULL )
38322 : {
38323 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38324 : {
38325 0 : if ( p_symbol_table->isInMemoryPool() == false )
38326 : {
38327 0 : std::cout << "SgSwitchStatement :: ";
38328 0 : std::cout << " p_symbol_table is not in memory pool of ";
38329 0 : std::cout << p_symbol_table->class_name() << std::endl;
38330 : }
38331 : }
38332 : else
38333 : {
38334 0 : std::cout << "SgSwitchStatement :: " << std::flush;
38335 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
38336 0 : std::cout << " not valid " << std::endl;
38337 : }
38338 : }
38339 :
38340 0 : if ( p_type_table != NULL )
38341 : {
38342 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38343 : {
38344 0 : if ( p_type_table->isInMemoryPool() == false )
38345 : {
38346 0 : std::cout << "SgSwitchStatement :: ";
38347 0 : std::cout << " p_type_table is not in memory pool of ";
38348 0 : std::cout << p_type_table->class_name() << std::endl;
38349 : }
38350 : }
38351 : else
38352 : {
38353 0 : std::cout << "SgSwitchStatement :: " << std::flush;
38354 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
38355 0 : std::cout << " not valid " << std::endl;
38356 : }
38357 : }
38358 :
38359 0 : if ( p_pragma != NULL )
38360 : {
38361 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38362 : {
38363 0 : if ( p_pragma->isInMemoryPool() == false )
38364 : {
38365 0 : std::cout << "SgSwitchStatement :: ";
38366 0 : std::cout << " p_pragma is not in memory pool of ";
38367 0 : std::cout << p_pragma->class_name() << std::endl;
38368 : }
38369 : }
38370 : else
38371 : {
38372 0 : std::cout << "SgSwitchStatement :: " << std::flush;
38373 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
38374 0 : std::cout << " not valid " << std::endl;
38375 : }
38376 : }
38377 :
38378 0 : if ( p_numeric_label != NULL )
38379 : {
38380 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38381 : {
38382 0 : if ( p_numeric_label->isInMemoryPool() == false )
38383 : {
38384 0 : std::cout << "SgSwitchStatement :: ";
38385 0 : std::cout << " p_numeric_label is not in memory pool of ";
38386 0 : std::cout << p_numeric_label->class_name() << std::endl;
38387 : }
38388 : }
38389 : else
38390 : {
38391 0 : std::cout << "SgSwitchStatement :: " << std::flush;
38392 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
38393 0 : std::cout << " not valid " << std::endl;
38394 : }
38395 : }
38396 :
38397 0 : if ( p_startOfConstruct != NULL )
38398 : {
38399 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38400 : {
38401 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
38402 : {
38403 0 : std::cout << "SgSwitchStatement :: ";
38404 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
38405 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
38406 : }
38407 : }
38408 : else
38409 : {
38410 0 : std::cout << "SgSwitchStatement :: " << std::flush;
38411 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
38412 0 : std::cout << " not valid " << std::endl;
38413 : }
38414 : }
38415 :
38416 0 : if ( p_endOfConstruct != NULL )
38417 : {
38418 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38419 : {
38420 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
38421 : {
38422 0 : std::cout << "SgSwitchStatement :: ";
38423 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
38424 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
38425 : }
38426 : }
38427 : else
38428 : {
38429 0 : std::cout << "SgSwitchStatement :: " << std::flush;
38430 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
38431 0 : std::cout << " not valid " << std::endl;
38432 : }
38433 : }
38434 :
38435 0 : if ( p_parent != NULL )
38436 : {
38437 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38438 : {
38439 0 : if ( p_parent->isInMemoryPool() == false )
38440 : {
38441 0 : std::cout << "SgSwitchStatement :: ";
38442 0 : std::cout << " p_parent is not in memory pool of ";
38443 0 : std::cout << p_parent->class_name() << std::endl;
38444 : }
38445 : }
38446 : else
38447 : {
38448 0 : std::cout << "SgSwitchStatement :: " << std::flush;
38449 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
38450 0 : std::cout << " not valid " << std::endl;
38451 : }
38452 : }
38453 :
38454 :
38455 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
38456 :
38457 0 : }
38458 :
38459 :
38460 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
38461 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
38462 : bool
38463 0 : SgSwitchStatement::isInMemoryPool ()
38464 : {
38465 0 : typedef unsigned char* TestType;
38466 :
38467 0 : bool found = false;
38468 :
38469 0 : ROSE_ASSERT(this != NULL);
38470 :
38471 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
38472 :
38473 0 : TestType tested = (TestType) ( this ) ;
38474 :
38475 0 : std::vector < unsigned char* > :: const_iterator block = SgSwitchStatement::pools.begin();
38476 :
38477 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
38478 : // while (found == false && block < Memory_Block_List.end())
38479 0 : while ( (found == false) && (block != SgSwitchStatement::pools.end()) )
38480 : {
38481 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSwitchStatement::pool_size * sizeof(SgSwitchStatement) ) ) ;
38482 0 : ++block;
38483 : }
38484 :
38485 : // Special handling for static data
38486 :
38487 :
38488 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
38489 0 : ROSE_ASSERT(found == true);
38490 :
38491 0 : return found;
38492 : }
38493 : /* #line 38494 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
38494 :
38495 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
38496 :
38497 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
38498 :
38499 : /* #line 38500 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
38500 :
38501 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
38502 :
38503 : void
38504 0 : SgCatchOptionStmt::checkDataMemberPointersIfInMemoryPool()
38505 : {
38506 : // ------------ checking pointers of SgCatchOptionStmt -------------------
38507 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38508 :
38509 0 : if ( p_condition != NULL )
38510 : {
38511 0 : if ( p_condition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38512 : {
38513 0 : if ( p_condition->isInMemoryPool() == false )
38514 : {
38515 0 : std::cout << "SgCatchOptionStmt :: ";
38516 0 : std::cout << " p_condition is not in memory pool of ";
38517 0 : std::cout << p_condition->class_name() << std::endl;
38518 : }
38519 : }
38520 : else
38521 : {
38522 0 : std::cout << "SgCatchOptionStmt :: " << std::flush;
38523 0 : std::cout << "SgVariableDeclaration* p_condition = " << p_condition << " --> " << std::flush;
38524 0 : std::cout << " not valid " << std::endl;
38525 : }
38526 : }
38527 :
38528 0 : if ( p_body != NULL )
38529 : {
38530 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38531 : {
38532 0 : if ( p_body->isInMemoryPool() == false )
38533 : {
38534 0 : std::cout << "SgCatchOptionStmt :: ";
38535 0 : std::cout << " p_body is not in memory pool of ";
38536 0 : std::cout << p_body->class_name() << std::endl;
38537 : }
38538 : }
38539 : else
38540 : {
38541 0 : std::cout << "SgCatchOptionStmt :: " << std::flush;
38542 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
38543 0 : std::cout << " not valid " << std::endl;
38544 : }
38545 : }
38546 :
38547 0 : if ( p_trystmt != NULL )
38548 : {
38549 0 : if ( p_trystmt->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38550 : {
38551 0 : if ( p_trystmt->isInMemoryPool() == false )
38552 : {
38553 0 : std::cout << "SgCatchOptionStmt :: ";
38554 0 : std::cout << " p_trystmt is not in memory pool of ";
38555 0 : std::cout << p_trystmt->class_name() << std::endl;
38556 : }
38557 : }
38558 : else
38559 : {
38560 0 : std::cout << "SgCatchOptionStmt :: " << std::flush;
38561 0 : std::cout << "SgTryStmt* p_trystmt = " << p_trystmt << " --> " << std::flush;
38562 0 : std::cout << " not valid " << std::endl;
38563 : }
38564 : }
38565 :
38566 0 : if ( p_symbol_table != NULL )
38567 : {
38568 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38569 : {
38570 0 : if ( p_symbol_table->isInMemoryPool() == false )
38571 : {
38572 0 : std::cout << "SgCatchOptionStmt :: ";
38573 0 : std::cout << " p_symbol_table is not in memory pool of ";
38574 0 : std::cout << p_symbol_table->class_name() << std::endl;
38575 : }
38576 : }
38577 : else
38578 : {
38579 0 : std::cout << "SgCatchOptionStmt :: " << std::flush;
38580 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
38581 0 : std::cout << " not valid " << std::endl;
38582 : }
38583 : }
38584 :
38585 0 : if ( p_type_table != NULL )
38586 : {
38587 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38588 : {
38589 0 : if ( p_type_table->isInMemoryPool() == false )
38590 : {
38591 0 : std::cout << "SgCatchOptionStmt :: ";
38592 0 : std::cout << " p_type_table is not in memory pool of ";
38593 0 : std::cout << p_type_table->class_name() << std::endl;
38594 : }
38595 : }
38596 : else
38597 : {
38598 0 : std::cout << "SgCatchOptionStmt :: " << std::flush;
38599 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
38600 0 : std::cout << " not valid " << std::endl;
38601 : }
38602 : }
38603 :
38604 0 : if ( p_pragma != NULL )
38605 : {
38606 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38607 : {
38608 0 : if ( p_pragma->isInMemoryPool() == false )
38609 : {
38610 0 : std::cout << "SgCatchOptionStmt :: ";
38611 0 : std::cout << " p_pragma is not in memory pool of ";
38612 0 : std::cout << p_pragma->class_name() << std::endl;
38613 : }
38614 : }
38615 : else
38616 : {
38617 0 : std::cout << "SgCatchOptionStmt :: " << std::flush;
38618 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
38619 0 : std::cout << " not valid " << std::endl;
38620 : }
38621 : }
38622 :
38623 0 : if ( p_numeric_label != NULL )
38624 : {
38625 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38626 : {
38627 0 : if ( p_numeric_label->isInMemoryPool() == false )
38628 : {
38629 0 : std::cout << "SgCatchOptionStmt :: ";
38630 0 : std::cout << " p_numeric_label is not in memory pool of ";
38631 0 : std::cout << p_numeric_label->class_name() << std::endl;
38632 : }
38633 : }
38634 : else
38635 : {
38636 0 : std::cout << "SgCatchOptionStmt :: " << std::flush;
38637 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
38638 0 : std::cout << " not valid " << std::endl;
38639 : }
38640 : }
38641 :
38642 0 : if ( p_startOfConstruct != NULL )
38643 : {
38644 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38645 : {
38646 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
38647 : {
38648 0 : std::cout << "SgCatchOptionStmt :: ";
38649 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
38650 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
38651 : }
38652 : }
38653 : else
38654 : {
38655 0 : std::cout << "SgCatchOptionStmt :: " << std::flush;
38656 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
38657 0 : std::cout << " not valid " << std::endl;
38658 : }
38659 : }
38660 :
38661 0 : if ( p_endOfConstruct != NULL )
38662 : {
38663 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38664 : {
38665 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
38666 : {
38667 0 : std::cout << "SgCatchOptionStmt :: ";
38668 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
38669 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
38670 : }
38671 : }
38672 : else
38673 : {
38674 0 : std::cout << "SgCatchOptionStmt :: " << std::flush;
38675 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
38676 0 : std::cout << " not valid " << std::endl;
38677 : }
38678 : }
38679 :
38680 0 : if ( p_parent != NULL )
38681 : {
38682 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38683 : {
38684 0 : if ( p_parent->isInMemoryPool() == false )
38685 : {
38686 0 : std::cout << "SgCatchOptionStmt :: ";
38687 0 : std::cout << " p_parent is not in memory pool of ";
38688 0 : std::cout << p_parent->class_name() << std::endl;
38689 : }
38690 : }
38691 : else
38692 : {
38693 0 : std::cout << "SgCatchOptionStmt :: " << std::flush;
38694 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
38695 0 : std::cout << " not valid " << std::endl;
38696 : }
38697 : }
38698 :
38699 :
38700 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
38701 :
38702 0 : }
38703 :
38704 :
38705 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
38706 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
38707 : bool
38708 0 : SgCatchOptionStmt::isInMemoryPool ()
38709 : {
38710 0 : typedef unsigned char* TestType;
38711 :
38712 0 : bool found = false;
38713 :
38714 0 : ROSE_ASSERT(this != NULL);
38715 :
38716 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
38717 :
38718 0 : TestType tested = (TestType) ( this ) ;
38719 :
38720 0 : std::vector < unsigned char* > :: const_iterator block = SgCatchOptionStmt::pools.begin();
38721 :
38722 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
38723 : // while (found == false && block < Memory_Block_List.end())
38724 0 : while ( (found == false) && (block != SgCatchOptionStmt::pools.end()) )
38725 : {
38726 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCatchOptionStmt::pool_size * sizeof(SgCatchOptionStmt) ) ) ;
38727 0 : ++block;
38728 : }
38729 :
38730 : // Special handling for static data
38731 :
38732 :
38733 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
38734 0 : ROSE_ASSERT(found == true);
38735 :
38736 0 : return found;
38737 : }
38738 : /* #line 38739 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
38739 :
38740 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
38741 :
38742 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
38743 :
38744 : /* #line 38745 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
38745 :
38746 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
38747 :
38748 : void
38749 0 : SgNamespaceDefinitionStatement::checkDataMemberPointersIfInMemoryPool()
38750 : {
38751 : // ------------ checking pointers of SgNamespaceDefinitionStatement -------------------
38752 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38753 :
38754 0 : SgDeclarationStatementPtrList::iterator i_declarations = p_declarations.begin() ;
38755 0 : for ( ; i_declarations != p_declarations.end(); ++i_declarations )
38756 : {
38757 0 : if ( (*i_declarations) != NULL )
38758 : {
38759 0 : if ( (*i_declarations)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38760 : {
38761 0 : if ( (*i_declarations)->isInMemoryPool() == false )
38762 : {
38763 0 : std::cout << "SgNamespaceDefinitionStatement :: ";
38764 0 : std::cout << " p_declarations ( list of poitners to IR nodes ), entry is not in memory pool of ";
38765 0 : std::cout << (*i_declarations)->class_name() << std::endl;
38766 : }
38767 : }
38768 : else
38769 : {
38770 0 : std::cout << "SgNamespaceDefinitionStatement :: " << std::flush;
38771 0 : std::cout << "SgDeclarationStatementPtrList p_declarations --> " << std::flush;
38772 0 : std::cout << " entry not valid " << std::endl;
38773 : }
38774 : }
38775 : else
38776 : {
38777 0 : std::cout << "SgDeclarationStatementPtrList p_declarations --> NULL " << std::endl;
38778 : }
38779 : }
38780 :
38781 0 : if ( p_namespaceDeclaration != NULL )
38782 : {
38783 0 : if ( p_namespaceDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38784 : {
38785 0 : if ( p_namespaceDeclaration->isInMemoryPool() == false )
38786 : {
38787 0 : std::cout << "SgNamespaceDefinitionStatement :: ";
38788 0 : std::cout << " p_namespaceDeclaration is not in memory pool of ";
38789 0 : std::cout << p_namespaceDeclaration->class_name() << std::endl;
38790 : }
38791 : }
38792 : else
38793 : {
38794 0 : std::cout << "SgNamespaceDefinitionStatement :: " << std::flush;
38795 0 : std::cout << "SgNamespaceDeclarationStatement* p_namespaceDeclaration = " << p_namespaceDeclaration << " --> " << std::flush;
38796 0 : std::cout << " not valid " << std::endl;
38797 : }
38798 : }
38799 :
38800 0 : if ( p_previousNamespaceDefinition != NULL )
38801 : {
38802 0 : if ( p_previousNamespaceDefinition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38803 : {
38804 0 : if ( p_previousNamespaceDefinition->isInMemoryPool() == false )
38805 : {
38806 0 : std::cout << "SgNamespaceDefinitionStatement :: ";
38807 0 : std::cout << " p_previousNamespaceDefinition is not in memory pool of ";
38808 0 : std::cout << p_previousNamespaceDefinition->class_name() << std::endl;
38809 : }
38810 : }
38811 : else
38812 : {
38813 0 : std::cout << "SgNamespaceDefinitionStatement :: " << std::flush;
38814 0 : std::cout << "SgNamespaceDefinitionStatement* p_previousNamespaceDefinition = " << p_previousNamespaceDefinition << " --> " << std::flush;
38815 0 : std::cout << " not valid " << std::endl;
38816 : }
38817 : }
38818 :
38819 0 : if ( p_nextNamespaceDefinition != NULL )
38820 : {
38821 0 : if ( p_nextNamespaceDefinition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38822 : {
38823 0 : if ( p_nextNamespaceDefinition->isInMemoryPool() == false )
38824 : {
38825 0 : std::cout << "SgNamespaceDefinitionStatement :: ";
38826 0 : std::cout << " p_nextNamespaceDefinition is not in memory pool of ";
38827 0 : std::cout << p_nextNamespaceDefinition->class_name() << std::endl;
38828 : }
38829 : }
38830 : else
38831 : {
38832 0 : std::cout << "SgNamespaceDefinitionStatement :: " << std::flush;
38833 0 : std::cout << "SgNamespaceDefinitionStatement* p_nextNamespaceDefinition = " << p_nextNamespaceDefinition << " --> " << std::flush;
38834 0 : std::cout << " not valid " << std::endl;
38835 : }
38836 : }
38837 :
38838 0 : if ( p_global_definition != NULL )
38839 : {
38840 0 : if ( p_global_definition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38841 : {
38842 0 : if ( p_global_definition->isInMemoryPool() == false )
38843 : {
38844 0 : std::cout << "SgNamespaceDefinitionStatement :: ";
38845 0 : std::cout << " p_global_definition is not in memory pool of ";
38846 0 : std::cout << p_global_definition->class_name() << std::endl;
38847 : }
38848 : }
38849 : else
38850 : {
38851 0 : std::cout << "SgNamespaceDefinitionStatement :: " << std::flush;
38852 0 : std::cout << "SgNamespaceDefinitionStatement* p_global_definition = " << p_global_definition << " --> " << std::flush;
38853 0 : std::cout << " not valid " << std::endl;
38854 : }
38855 : }
38856 :
38857 0 : if ( p_symbol_table != NULL )
38858 : {
38859 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38860 : {
38861 0 : if ( p_symbol_table->isInMemoryPool() == false )
38862 : {
38863 0 : std::cout << "SgNamespaceDefinitionStatement :: ";
38864 0 : std::cout << " p_symbol_table is not in memory pool of ";
38865 0 : std::cout << p_symbol_table->class_name() << std::endl;
38866 : }
38867 : }
38868 : else
38869 : {
38870 0 : std::cout << "SgNamespaceDefinitionStatement :: " << std::flush;
38871 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
38872 0 : std::cout << " not valid " << std::endl;
38873 : }
38874 : }
38875 :
38876 0 : if ( p_type_table != NULL )
38877 : {
38878 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38879 : {
38880 0 : if ( p_type_table->isInMemoryPool() == false )
38881 : {
38882 0 : std::cout << "SgNamespaceDefinitionStatement :: ";
38883 0 : std::cout << " p_type_table is not in memory pool of ";
38884 0 : std::cout << p_type_table->class_name() << std::endl;
38885 : }
38886 : }
38887 : else
38888 : {
38889 0 : std::cout << "SgNamespaceDefinitionStatement :: " << std::flush;
38890 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
38891 0 : std::cout << " not valid " << std::endl;
38892 : }
38893 : }
38894 :
38895 0 : if ( p_pragma != NULL )
38896 : {
38897 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38898 : {
38899 0 : if ( p_pragma->isInMemoryPool() == false )
38900 : {
38901 0 : std::cout << "SgNamespaceDefinitionStatement :: ";
38902 0 : std::cout << " p_pragma is not in memory pool of ";
38903 0 : std::cout << p_pragma->class_name() << std::endl;
38904 : }
38905 : }
38906 : else
38907 : {
38908 0 : std::cout << "SgNamespaceDefinitionStatement :: " << std::flush;
38909 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
38910 0 : std::cout << " not valid " << std::endl;
38911 : }
38912 : }
38913 :
38914 0 : if ( p_numeric_label != NULL )
38915 : {
38916 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38917 : {
38918 0 : if ( p_numeric_label->isInMemoryPool() == false )
38919 : {
38920 0 : std::cout << "SgNamespaceDefinitionStatement :: ";
38921 0 : std::cout << " p_numeric_label is not in memory pool of ";
38922 0 : std::cout << p_numeric_label->class_name() << std::endl;
38923 : }
38924 : }
38925 : else
38926 : {
38927 0 : std::cout << "SgNamespaceDefinitionStatement :: " << std::flush;
38928 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
38929 0 : std::cout << " not valid " << std::endl;
38930 : }
38931 : }
38932 :
38933 0 : if ( p_startOfConstruct != NULL )
38934 : {
38935 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38936 : {
38937 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
38938 : {
38939 0 : std::cout << "SgNamespaceDefinitionStatement :: ";
38940 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
38941 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
38942 : }
38943 : }
38944 : else
38945 : {
38946 0 : std::cout << "SgNamespaceDefinitionStatement :: " << std::flush;
38947 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
38948 0 : std::cout << " not valid " << std::endl;
38949 : }
38950 : }
38951 :
38952 0 : if ( p_endOfConstruct != NULL )
38953 : {
38954 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38955 : {
38956 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
38957 : {
38958 0 : std::cout << "SgNamespaceDefinitionStatement :: ";
38959 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
38960 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
38961 : }
38962 : }
38963 : else
38964 : {
38965 0 : std::cout << "SgNamespaceDefinitionStatement :: " << std::flush;
38966 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
38967 0 : std::cout << " not valid " << std::endl;
38968 : }
38969 : }
38970 :
38971 0 : if ( p_parent != NULL )
38972 : {
38973 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
38974 : {
38975 0 : if ( p_parent->isInMemoryPool() == false )
38976 : {
38977 0 : std::cout << "SgNamespaceDefinitionStatement :: ";
38978 0 : std::cout << " p_parent is not in memory pool of ";
38979 0 : std::cout << p_parent->class_name() << std::endl;
38980 : }
38981 : }
38982 : else
38983 : {
38984 0 : std::cout << "SgNamespaceDefinitionStatement :: " << std::flush;
38985 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
38986 0 : std::cout << " not valid " << std::endl;
38987 : }
38988 : }
38989 :
38990 :
38991 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
38992 :
38993 0 : }
38994 :
38995 :
38996 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
38997 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
38998 : bool
38999 0 : SgNamespaceDefinitionStatement::isInMemoryPool ()
39000 : {
39001 0 : typedef unsigned char* TestType;
39002 :
39003 0 : bool found = false;
39004 :
39005 0 : ROSE_ASSERT(this != NULL);
39006 :
39007 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
39008 :
39009 0 : TestType tested = (TestType) ( this ) ;
39010 :
39011 0 : std::vector < unsigned char* > :: const_iterator block = SgNamespaceDefinitionStatement::pools.begin();
39012 :
39013 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
39014 : // while (found == false && block < Memory_Block_List.end())
39015 0 : while ( (found == false) && (block != SgNamespaceDefinitionStatement::pools.end()) )
39016 : {
39017 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNamespaceDefinitionStatement::pool_size * sizeof(SgNamespaceDefinitionStatement) ) ) ;
39018 0 : ++block;
39019 : }
39020 :
39021 : // Special handling for static data
39022 :
39023 :
39024 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
39025 0 : ROSE_ASSERT(found == true);
39026 :
39027 0 : return found;
39028 : }
39029 : /* #line 39030 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
39030 :
39031 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
39032 :
39033 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
39034 :
39035 : /* #line 39036 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
39036 :
39037 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
39038 :
39039 : void
39040 0 : SgBlockDataStatement::checkDataMemberPointersIfInMemoryPool()
39041 : {
39042 : // ------------ checking pointers of SgBlockDataStatement -------------------
39043 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39044 :
39045 0 : if ( p_body != NULL )
39046 : {
39047 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39048 : {
39049 0 : if ( p_body->isInMemoryPool() == false )
39050 : {
39051 0 : std::cout << "SgBlockDataStatement :: ";
39052 0 : std::cout << " p_body is not in memory pool of ";
39053 0 : std::cout << p_body->class_name() << std::endl;
39054 : }
39055 : }
39056 : else
39057 : {
39058 0 : std::cout << "SgBlockDataStatement :: " << std::flush;
39059 0 : std::cout << "SgBasicBlock* p_body = " << p_body << " --> " << std::flush;
39060 0 : std::cout << " not valid " << std::endl;
39061 : }
39062 : }
39063 :
39064 0 : if ( p_symbol_table != NULL )
39065 : {
39066 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39067 : {
39068 0 : if ( p_symbol_table->isInMemoryPool() == false )
39069 : {
39070 0 : std::cout << "SgBlockDataStatement :: ";
39071 0 : std::cout << " p_symbol_table is not in memory pool of ";
39072 0 : std::cout << p_symbol_table->class_name() << std::endl;
39073 : }
39074 : }
39075 : else
39076 : {
39077 0 : std::cout << "SgBlockDataStatement :: " << std::flush;
39078 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
39079 0 : std::cout << " not valid " << std::endl;
39080 : }
39081 : }
39082 :
39083 0 : if ( p_type_table != NULL )
39084 : {
39085 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39086 : {
39087 0 : if ( p_type_table->isInMemoryPool() == false )
39088 : {
39089 0 : std::cout << "SgBlockDataStatement :: ";
39090 0 : std::cout << " p_type_table is not in memory pool of ";
39091 0 : std::cout << p_type_table->class_name() << std::endl;
39092 : }
39093 : }
39094 : else
39095 : {
39096 0 : std::cout << "SgBlockDataStatement :: " << std::flush;
39097 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
39098 0 : std::cout << " not valid " << std::endl;
39099 : }
39100 : }
39101 :
39102 0 : if ( p_pragma != NULL )
39103 : {
39104 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39105 : {
39106 0 : if ( p_pragma->isInMemoryPool() == false )
39107 : {
39108 0 : std::cout << "SgBlockDataStatement :: ";
39109 0 : std::cout << " p_pragma is not in memory pool of ";
39110 0 : std::cout << p_pragma->class_name() << std::endl;
39111 : }
39112 : }
39113 : else
39114 : {
39115 0 : std::cout << "SgBlockDataStatement :: " << std::flush;
39116 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
39117 0 : std::cout << " not valid " << std::endl;
39118 : }
39119 : }
39120 :
39121 0 : if ( p_numeric_label != NULL )
39122 : {
39123 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39124 : {
39125 0 : if ( p_numeric_label->isInMemoryPool() == false )
39126 : {
39127 0 : std::cout << "SgBlockDataStatement :: ";
39128 0 : std::cout << " p_numeric_label is not in memory pool of ";
39129 0 : std::cout << p_numeric_label->class_name() << std::endl;
39130 : }
39131 : }
39132 : else
39133 : {
39134 0 : std::cout << "SgBlockDataStatement :: " << std::flush;
39135 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
39136 0 : std::cout << " not valid " << std::endl;
39137 : }
39138 : }
39139 :
39140 0 : if ( p_startOfConstruct != NULL )
39141 : {
39142 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39143 : {
39144 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
39145 : {
39146 0 : std::cout << "SgBlockDataStatement :: ";
39147 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
39148 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
39149 : }
39150 : }
39151 : else
39152 : {
39153 0 : std::cout << "SgBlockDataStatement :: " << std::flush;
39154 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
39155 0 : std::cout << " not valid " << std::endl;
39156 : }
39157 : }
39158 :
39159 0 : if ( p_endOfConstruct != NULL )
39160 : {
39161 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39162 : {
39163 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
39164 : {
39165 0 : std::cout << "SgBlockDataStatement :: ";
39166 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
39167 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
39168 : }
39169 : }
39170 : else
39171 : {
39172 0 : std::cout << "SgBlockDataStatement :: " << std::flush;
39173 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
39174 0 : std::cout << " not valid " << std::endl;
39175 : }
39176 : }
39177 :
39178 0 : if ( p_parent != NULL )
39179 : {
39180 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39181 : {
39182 0 : if ( p_parent->isInMemoryPool() == false )
39183 : {
39184 0 : std::cout << "SgBlockDataStatement :: ";
39185 0 : std::cout << " p_parent is not in memory pool of ";
39186 0 : std::cout << p_parent->class_name() << std::endl;
39187 : }
39188 : }
39189 : else
39190 : {
39191 0 : std::cout << "SgBlockDataStatement :: " << std::flush;
39192 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
39193 0 : std::cout << " not valid " << std::endl;
39194 : }
39195 : }
39196 :
39197 :
39198 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
39199 :
39200 0 : }
39201 :
39202 :
39203 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
39204 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
39205 : bool
39206 0 : SgBlockDataStatement::isInMemoryPool ()
39207 : {
39208 0 : typedef unsigned char* TestType;
39209 :
39210 0 : bool found = false;
39211 :
39212 0 : ROSE_ASSERT(this != NULL);
39213 :
39214 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
39215 :
39216 0 : TestType tested = (TestType) ( this ) ;
39217 :
39218 0 : std::vector < unsigned char* > :: const_iterator block = SgBlockDataStatement::pools.begin();
39219 :
39220 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
39221 : // while (found == false && block < Memory_Block_List.end())
39222 0 : while ( (found == false) && (block != SgBlockDataStatement::pools.end()) )
39223 : {
39224 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgBlockDataStatement::pool_size * sizeof(SgBlockDataStatement) ) ) ;
39225 0 : ++block;
39226 : }
39227 :
39228 : // Special handling for static data
39229 :
39230 :
39231 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
39232 0 : ROSE_ASSERT(found == true);
39233 :
39234 0 : return found;
39235 : }
39236 : /* #line 39237 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
39237 :
39238 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
39239 :
39240 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
39241 :
39242 : /* #line 39243 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
39243 :
39244 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
39245 :
39246 : void
39247 0 : SgAssociateStatement::checkDataMemberPointersIfInMemoryPool()
39248 : {
39249 : // ------------ checking pointers of SgAssociateStatement -------------------
39250 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39251 :
39252 0 : SgDeclarationStatementPtrList::iterator i_associates = p_associates.begin() ;
39253 0 : for ( ; i_associates != p_associates.end(); ++i_associates )
39254 : {
39255 0 : if ( (*i_associates) != NULL )
39256 : {
39257 0 : if ( (*i_associates)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39258 : {
39259 0 : if ( (*i_associates)->isInMemoryPool() == false )
39260 : {
39261 0 : std::cout << "SgAssociateStatement :: ";
39262 0 : std::cout << " p_associates ( list of poitners to IR nodes ), entry is not in memory pool of ";
39263 0 : std::cout << (*i_associates)->class_name() << std::endl;
39264 : }
39265 : }
39266 : else
39267 : {
39268 0 : std::cout << "SgAssociateStatement :: " << std::flush;
39269 0 : std::cout << "SgDeclarationStatementPtrList p_associates --> " << std::flush;
39270 0 : std::cout << " entry not valid " << std::endl;
39271 : }
39272 : }
39273 : else
39274 : {
39275 0 : std::cout << "SgDeclarationStatementPtrList p_associates --> NULL " << std::endl;
39276 : }
39277 : }
39278 :
39279 0 : if ( p_body != NULL )
39280 : {
39281 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39282 : {
39283 0 : if ( p_body->isInMemoryPool() == false )
39284 : {
39285 0 : std::cout << "SgAssociateStatement :: ";
39286 0 : std::cout << " p_body is not in memory pool of ";
39287 0 : std::cout << p_body->class_name() << std::endl;
39288 : }
39289 : }
39290 : else
39291 : {
39292 0 : std::cout << "SgAssociateStatement :: " << std::flush;
39293 0 : std::cout << "SgBasicBlock* p_body = " << p_body << " --> " << std::flush;
39294 0 : std::cout << " not valid " << std::endl;
39295 : }
39296 : }
39297 :
39298 0 : if ( p_symbol_table != NULL )
39299 : {
39300 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39301 : {
39302 0 : if ( p_symbol_table->isInMemoryPool() == false )
39303 : {
39304 0 : std::cout << "SgAssociateStatement :: ";
39305 0 : std::cout << " p_symbol_table is not in memory pool of ";
39306 0 : std::cout << p_symbol_table->class_name() << std::endl;
39307 : }
39308 : }
39309 : else
39310 : {
39311 0 : std::cout << "SgAssociateStatement :: " << std::flush;
39312 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
39313 0 : std::cout << " not valid " << std::endl;
39314 : }
39315 : }
39316 :
39317 0 : if ( p_type_table != NULL )
39318 : {
39319 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39320 : {
39321 0 : if ( p_type_table->isInMemoryPool() == false )
39322 : {
39323 0 : std::cout << "SgAssociateStatement :: ";
39324 0 : std::cout << " p_type_table is not in memory pool of ";
39325 0 : std::cout << p_type_table->class_name() << std::endl;
39326 : }
39327 : }
39328 : else
39329 : {
39330 0 : std::cout << "SgAssociateStatement :: " << std::flush;
39331 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
39332 0 : std::cout << " not valid " << std::endl;
39333 : }
39334 : }
39335 :
39336 0 : if ( p_pragma != NULL )
39337 : {
39338 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39339 : {
39340 0 : if ( p_pragma->isInMemoryPool() == false )
39341 : {
39342 0 : std::cout << "SgAssociateStatement :: ";
39343 0 : std::cout << " p_pragma is not in memory pool of ";
39344 0 : std::cout << p_pragma->class_name() << std::endl;
39345 : }
39346 : }
39347 : else
39348 : {
39349 0 : std::cout << "SgAssociateStatement :: " << std::flush;
39350 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
39351 0 : std::cout << " not valid " << std::endl;
39352 : }
39353 : }
39354 :
39355 0 : if ( p_numeric_label != NULL )
39356 : {
39357 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39358 : {
39359 0 : if ( p_numeric_label->isInMemoryPool() == false )
39360 : {
39361 0 : std::cout << "SgAssociateStatement :: ";
39362 0 : std::cout << " p_numeric_label is not in memory pool of ";
39363 0 : std::cout << p_numeric_label->class_name() << std::endl;
39364 : }
39365 : }
39366 : else
39367 : {
39368 0 : std::cout << "SgAssociateStatement :: " << std::flush;
39369 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
39370 0 : std::cout << " not valid " << std::endl;
39371 : }
39372 : }
39373 :
39374 0 : if ( p_startOfConstruct != NULL )
39375 : {
39376 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39377 : {
39378 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
39379 : {
39380 0 : std::cout << "SgAssociateStatement :: ";
39381 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
39382 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
39383 : }
39384 : }
39385 : else
39386 : {
39387 0 : std::cout << "SgAssociateStatement :: " << std::flush;
39388 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
39389 0 : std::cout << " not valid " << std::endl;
39390 : }
39391 : }
39392 :
39393 0 : if ( p_endOfConstruct != NULL )
39394 : {
39395 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39396 : {
39397 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
39398 : {
39399 0 : std::cout << "SgAssociateStatement :: ";
39400 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
39401 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
39402 : }
39403 : }
39404 : else
39405 : {
39406 0 : std::cout << "SgAssociateStatement :: " << std::flush;
39407 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
39408 0 : std::cout << " not valid " << std::endl;
39409 : }
39410 : }
39411 :
39412 0 : if ( p_parent != NULL )
39413 : {
39414 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39415 : {
39416 0 : if ( p_parent->isInMemoryPool() == false )
39417 : {
39418 0 : std::cout << "SgAssociateStatement :: ";
39419 0 : std::cout << " p_parent is not in memory pool of ";
39420 0 : std::cout << p_parent->class_name() << std::endl;
39421 : }
39422 : }
39423 : else
39424 : {
39425 0 : std::cout << "SgAssociateStatement :: " << std::flush;
39426 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
39427 0 : std::cout << " not valid " << std::endl;
39428 : }
39429 : }
39430 :
39431 :
39432 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
39433 :
39434 0 : }
39435 :
39436 :
39437 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
39438 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
39439 : bool
39440 0 : SgAssociateStatement::isInMemoryPool ()
39441 : {
39442 0 : typedef unsigned char* TestType;
39443 :
39444 0 : bool found = false;
39445 :
39446 0 : ROSE_ASSERT(this != NULL);
39447 :
39448 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
39449 :
39450 0 : TestType tested = (TestType) ( this ) ;
39451 :
39452 0 : std::vector < unsigned char* > :: const_iterator block = SgAssociateStatement::pools.begin();
39453 :
39454 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
39455 : // while (found == false && block < Memory_Block_List.end())
39456 0 : while ( (found == false) && (block != SgAssociateStatement::pools.end()) )
39457 : {
39458 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAssociateStatement::pool_size * sizeof(SgAssociateStatement) ) ) ;
39459 0 : ++block;
39460 : }
39461 :
39462 : // Special handling for static data
39463 :
39464 :
39465 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
39466 0 : ROSE_ASSERT(found == true);
39467 :
39468 0 : return found;
39469 : }
39470 : /* #line 39471 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
39471 :
39472 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
39473 :
39474 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
39475 :
39476 : /* #line 39477 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
39477 :
39478 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
39479 :
39480 : void
39481 0 : SgFortranDo::checkDataMemberPointersIfInMemoryPool()
39482 : {
39483 : // ------------ checking pointers of SgFortranDo -------------------
39484 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39485 :
39486 0 : if ( p_initialization != NULL )
39487 : {
39488 0 : if ( p_initialization->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39489 : {
39490 0 : if ( p_initialization->isInMemoryPool() == false )
39491 : {
39492 0 : std::cout << "SgFortranDo :: ";
39493 0 : std::cout << " p_initialization is not in memory pool of ";
39494 0 : std::cout << p_initialization->class_name() << std::endl;
39495 : }
39496 : }
39497 : else
39498 : {
39499 0 : std::cout << "SgFortranDo :: " << std::flush;
39500 0 : std::cout << "SgExpression* p_initialization = " << p_initialization << " --> " << std::flush;
39501 0 : std::cout << " not valid " << std::endl;
39502 : }
39503 : }
39504 :
39505 0 : if ( p_bound != NULL )
39506 : {
39507 0 : if ( p_bound->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39508 : {
39509 0 : if ( p_bound->isInMemoryPool() == false )
39510 : {
39511 0 : std::cout << "SgFortranDo :: ";
39512 0 : std::cout << " p_bound is not in memory pool of ";
39513 0 : std::cout << p_bound->class_name() << std::endl;
39514 : }
39515 : }
39516 : else
39517 : {
39518 0 : std::cout << "SgFortranDo :: " << std::flush;
39519 0 : std::cout << "SgExpression* p_bound = " << p_bound << " --> " << std::flush;
39520 0 : std::cout << " not valid " << std::endl;
39521 : }
39522 : }
39523 :
39524 0 : if ( p_increment != NULL )
39525 : {
39526 0 : if ( p_increment->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39527 : {
39528 0 : if ( p_increment->isInMemoryPool() == false )
39529 : {
39530 0 : std::cout << "SgFortranDo :: ";
39531 0 : std::cout << " p_increment is not in memory pool of ";
39532 0 : std::cout << p_increment->class_name() << std::endl;
39533 : }
39534 : }
39535 : else
39536 : {
39537 0 : std::cout << "SgFortranDo :: " << std::flush;
39538 0 : std::cout << "SgExpression* p_increment = " << p_increment << " --> " << std::flush;
39539 0 : std::cout << " not valid " << std::endl;
39540 : }
39541 : }
39542 :
39543 0 : if ( p_body != NULL )
39544 : {
39545 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39546 : {
39547 0 : if ( p_body->isInMemoryPool() == false )
39548 : {
39549 0 : std::cout << "SgFortranDo :: ";
39550 0 : std::cout << " p_body is not in memory pool of ";
39551 0 : std::cout << p_body->class_name() << std::endl;
39552 : }
39553 : }
39554 : else
39555 : {
39556 0 : std::cout << "SgFortranDo :: " << std::flush;
39557 0 : std::cout << "SgBasicBlock* p_body = " << p_body << " --> " << std::flush;
39558 0 : std::cout << " not valid " << std::endl;
39559 : }
39560 : }
39561 :
39562 0 : if ( p_end_numeric_label != NULL )
39563 : {
39564 0 : if ( p_end_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39565 : {
39566 0 : if ( p_end_numeric_label->isInMemoryPool() == false )
39567 : {
39568 0 : std::cout << "SgFortranDo :: ";
39569 0 : std::cout << " p_end_numeric_label is not in memory pool of ";
39570 0 : std::cout << p_end_numeric_label->class_name() << std::endl;
39571 : }
39572 : }
39573 : else
39574 : {
39575 0 : std::cout << "SgFortranDo :: " << std::flush;
39576 0 : std::cout << "SgLabelRefExp* p_end_numeric_label = " << p_end_numeric_label << " --> " << std::flush;
39577 0 : std::cout << " not valid " << std::endl;
39578 : }
39579 : }
39580 :
39581 0 : if ( p_symbol_table != NULL )
39582 : {
39583 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39584 : {
39585 0 : if ( p_symbol_table->isInMemoryPool() == false )
39586 : {
39587 0 : std::cout << "SgFortranDo :: ";
39588 0 : std::cout << " p_symbol_table is not in memory pool of ";
39589 0 : std::cout << p_symbol_table->class_name() << std::endl;
39590 : }
39591 : }
39592 : else
39593 : {
39594 0 : std::cout << "SgFortranDo :: " << std::flush;
39595 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
39596 0 : std::cout << " not valid " << std::endl;
39597 : }
39598 : }
39599 :
39600 0 : if ( p_type_table != NULL )
39601 : {
39602 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39603 : {
39604 0 : if ( p_type_table->isInMemoryPool() == false )
39605 : {
39606 0 : std::cout << "SgFortranDo :: ";
39607 0 : std::cout << " p_type_table is not in memory pool of ";
39608 0 : std::cout << p_type_table->class_name() << std::endl;
39609 : }
39610 : }
39611 : else
39612 : {
39613 0 : std::cout << "SgFortranDo :: " << std::flush;
39614 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
39615 0 : std::cout << " not valid " << std::endl;
39616 : }
39617 : }
39618 :
39619 0 : if ( p_pragma != NULL )
39620 : {
39621 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39622 : {
39623 0 : if ( p_pragma->isInMemoryPool() == false )
39624 : {
39625 0 : std::cout << "SgFortranDo :: ";
39626 0 : std::cout << " p_pragma is not in memory pool of ";
39627 0 : std::cout << p_pragma->class_name() << std::endl;
39628 : }
39629 : }
39630 : else
39631 : {
39632 0 : std::cout << "SgFortranDo :: " << std::flush;
39633 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
39634 0 : std::cout << " not valid " << std::endl;
39635 : }
39636 : }
39637 :
39638 0 : if ( p_numeric_label != NULL )
39639 : {
39640 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39641 : {
39642 0 : if ( p_numeric_label->isInMemoryPool() == false )
39643 : {
39644 0 : std::cout << "SgFortranDo :: ";
39645 0 : std::cout << " p_numeric_label is not in memory pool of ";
39646 0 : std::cout << p_numeric_label->class_name() << std::endl;
39647 : }
39648 : }
39649 : else
39650 : {
39651 0 : std::cout << "SgFortranDo :: " << std::flush;
39652 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
39653 0 : std::cout << " not valid " << std::endl;
39654 : }
39655 : }
39656 :
39657 0 : if ( p_startOfConstruct != NULL )
39658 : {
39659 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39660 : {
39661 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
39662 : {
39663 0 : std::cout << "SgFortranDo :: ";
39664 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
39665 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
39666 : }
39667 : }
39668 : else
39669 : {
39670 0 : std::cout << "SgFortranDo :: " << std::flush;
39671 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
39672 0 : std::cout << " not valid " << std::endl;
39673 : }
39674 : }
39675 :
39676 0 : if ( p_endOfConstruct != NULL )
39677 : {
39678 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39679 : {
39680 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
39681 : {
39682 0 : std::cout << "SgFortranDo :: ";
39683 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
39684 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
39685 : }
39686 : }
39687 : else
39688 : {
39689 0 : std::cout << "SgFortranDo :: " << std::flush;
39690 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
39691 0 : std::cout << " not valid " << std::endl;
39692 : }
39693 : }
39694 :
39695 0 : if ( p_parent != NULL )
39696 : {
39697 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39698 : {
39699 0 : if ( p_parent->isInMemoryPool() == false )
39700 : {
39701 0 : std::cout << "SgFortranDo :: ";
39702 0 : std::cout << " p_parent is not in memory pool of ";
39703 0 : std::cout << p_parent->class_name() << std::endl;
39704 : }
39705 : }
39706 : else
39707 : {
39708 0 : std::cout << "SgFortranDo :: " << std::flush;
39709 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
39710 0 : std::cout << " not valid " << std::endl;
39711 : }
39712 : }
39713 :
39714 :
39715 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
39716 :
39717 0 : }
39718 :
39719 :
39720 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
39721 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
39722 : bool
39723 0 : SgFortranDo::isInMemoryPool ()
39724 : {
39725 0 : typedef unsigned char* TestType;
39726 :
39727 0 : bool found = false;
39728 :
39729 0 : ROSE_ASSERT(this != NULL);
39730 :
39731 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
39732 :
39733 0 : TestType tested = (TestType) ( this ) ;
39734 :
39735 0 : std::vector < unsigned char* > :: const_iterator block = SgFortranDo::pools.begin();
39736 :
39737 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
39738 : // while (found == false && block < Memory_Block_List.end())
39739 0 : while ( (found == false) && (block != SgFortranDo::pools.end()) )
39740 : {
39741 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFortranDo::pool_size * sizeof(SgFortranDo) ) ) ;
39742 0 : ++block;
39743 : }
39744 :
39745 : // Special handling for static data
39746 :
39747 :
39748 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
39749 0 : ROSE_ASSERT(found == true);
39750 :
39751 0 : return found;
39752 : }
39753 : /* #line 39754 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
39754 :
39755 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
39756 :
39757 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
39758 :
39759 : /* #line 39760 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
39760 :
39761 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
39762 :
39763 : void
39764 0 : SgFortranNonblockedDo::checkDataMemberPointersIfInMemoryPool()
39765 : {
39766 : // ------------ checking pointers of SgFortranNonblockedDo -------------------
39767 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39768 :
39769 0 : if ( p_end_statement != NULL )
39770 : {
39771 0 : if ( p_end_statement->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39772 : {
39773 0 : if ( p_end_statement->isInMemoryPool() == false )
39774 : {
39775 0 : std::cout << "SgFortranNonblockedDo :: ";
39776 0 : std::cout << " p_end_statement is not in memory pool of ";
39777 0 : std::cout << p_end_statement->class_name() << std::endl;
39778 : }
39779 : }
39780 : else
39781 : {
39782 0 : std::cout << "SgFortranNonblockedDo :: " << std::flush;
39783 0 : std::cout << "SgStatement* p_end_statement = " << p_end_statement << " --> " << std::flush;
39784 0 : std::cout << " not valid " << std::endl;
39785 : }
39786 : }
39787 :
39788 0 : if ( p_initialization != NULL )
39789 : {
39790 0 : if ( p_initialization->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39791 : {
39792 0 : if ( p_initialization->isInMemoryPool() == false )
39793 : {
39794 0 : std::cout << "SgFortranNonblockedDo :: ";
39795 0 : std::cout << " p_initialization is not in memory pool of ";
39796 0 : std::cout << p_initialization->class_name() << std::endl;
39797 : }
39798 : }
39799 : else
39800 : {
39801 0 : std::cout << "SgFortranNonblockedDo :: " << std::flush;
39802 0 : std::cout << "SgExpression* p_initialization = " << p_initialization << " --> " << std::flush;
39803 0 : std::cout << " not valid " << std::endl;
39804 : }
39805 : }
39806 :
39807 0 : if ( p_bound != NULL )
39808 : {
39809 0 : if ( p_bound->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39810 : {
39811 0 : if ( p_bound->isInMemoryPool() == false )
39812 : {
39813 0 : std::cout << "SgFortranNonblockedDo :: ";
39814 0 : std::cout << " p_bound is not in memory pool of ";
39815 0 : std::cout << p_bound->class_name() << std::endl;
39816 : }
39817 : }
39818 : else
39819 : {
39820 0 : std::cout << "SgFortranNonblockedDo :: " << std::flush;
39821 0 : std::cout << "SgExpression* p_bound = " << p_bound << " --> " << std::flush;
39822 0 : std::cout << " not valid " << std::endl;
39823 : }
39824 : }
39825 :
39826 0 : if ( p_increment != NULL )
39827 : {
39828 0 : if ( p_increment->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39829 : {
39830 0 : if ( p_increment->isInMemoryPool() == false )
39831 : {
39832 0 : std::cout << "SgFortranNonblockedDo :: ";
39833 0 : std::cout << " p_increment is not in memory pool of ";
39834 0 : std::cout << p_increment->class_name() << std::endl;
39835 : }
39836 : }
39837 : else
39838 : {
39839 0 : std::cout << "SgFortranNonblockedDo :: " << std::flush;
39840 0 : std::cout << "SgExpression* p_increment = " << p_increment << " --> " << std::flush;
39841 0 : std::cout << " not valid " << std::endl;
39842 : }
39843 : }
39844 :
39845 0 : if ( p_body != NULL )
39846 : {
39847 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39848 : {
39849 0 : if ( p_body->isInMemoryPool() == false )
39850 : {
39851 0 : std::cout << "SgFortranNonblockedDo :: ";
39852 0 : std::cout << " p_body is not in memory pool of ";
39853 0 : std::cout << p_body->class_name() << std::endl;
39854 : }
39855 : }
39856 : else
39857 : {
39858 0 : std::cout << "SgFortranNonblockedDo :: " << std::flush;
39859 0 : std::cout << "SgBasicBlock* p_body = " << p_body << " --> " << std::flush;
39860 0 : std::cout << " not valid " << std::endl;
39861 : }
39862 : }
39863 :
39864 0 : if ( p_end_numeric_label != NULL )
39865 : {
39866 0 : if ( p_end_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39867 : {
39868 0 : if ( p_end_numeric_label->isInMemoryPool() == false )
39869 : {
39870 0 : std::cout << "SgFortranNonblockedDo :: ";
39871 0 : std::cout << " p_end_numeric_label is not in memory pool of ";
39872 0 : std::cout << p_end_numeric_label->class_name() << std::endl;
39873 : }
39874 : }
39875 : else
39876 : {
39877 0 : std::cout << "SgFortranNonblockedDo :: " << std::flush;
39878 0 : std::cout << "SgLabelRefExp* p_end_numeric_label = " << p_end_numeric_label << " --> " << std::flush;
39879 0 : std::cout << " not valid " << std::endl;
39880 : }
39881 : }
39882 :
39883 0 : if ( p_symbol_table != NULL )
39884 : {
39885 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39886 : {
39887 0 : if ( p_symbol_table->isInMemoryPool() == false )
39888 : {
39889 0 : std::cout << "SgFortranNonblockedDo :: ";
39890 0 : std::cout << " p_symbol_table is not in memory pool of ";
39891 0 : std::cout << p_symbol_table->class_name() << std::endl;
39892 : }
39893 : }
39894 : else
39895 : {
39896 0 : std::cout << "SgFortranNonblockedDo :: " << std::flush;
39897 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
39898 0 : std::cout << " not valid " << std::endl;
39899 : }
39900 : }
39901 :
39902 0 : if ( p_type_table != NULL )
39903 : {
39904 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39905 : {
39906 0 : if ( p_type_table->isInMemoryPool() == false )
39907 : {
39908 0 : std::cout << "SgFortranNonblockedDo :: ";
39909 0 : std::cout << " p_type_table is not in memory pool of ";
39910 0 : std::cout << p_type_table->class_name() << std::endl;
39911 : }
39912 : }
39913 : else
39914 : {
39915 0 : std::cout << "SgFortranNonblockedDo :: " << std::flush;
39916 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
39917 0 : std::cout << " not valid " << std::endl;
39918 : }
39919 : }
39920 :
39921 0 : if ( p_pragma != NULL )
39922 : {
39923 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39924 : {
39925 0 : if ( p_pragma->isInMemoryPool() == false )
39926 : {
39927 0 : std::cout << "SgFortranNonblockedDo :: ";
39928 0 : std::cout << " p_pragma is not in memory pool of ";
39929 0 : std::cout << p_pragma->class_name() << std::endl;
39930 : }
39931 : }
39932 : else
39933 : {
39934 0 : std::cout << "SgFortranNonblockedDo :: " << std::flush;
39935 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
39936 0 : std::cout << " not valid " << std::endl;
39937 : }
39938 : }
39939 :
39940 0 : if ( p_numeric_label != NULL )
39941 : {
39942 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39943 : {
39944 0 : if ( p_numeric_label->isInMemoryPool() == false )
39945 : {
39946 0 : std::cout << "SgFortranNonblockedDo :: ";
39947 0 : std::cout << " p_numeric_label is not in memory pool of ";
39948 0 : std::cout << p_numeric_label->class_name() << std::endl;
39949 : }
39950 : }
39951 : else
39952 : {
39953 0 : std::cout << "SgFortranNonblockedDo :: " << std::flush;
39954 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
39955 0 : std::cout << " not valid " << std::endl;
39956 : }
39957 : }
39958 :
39959 0 : if ( p_startOfConstruct != NULL )
39960 : {
39961 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39962 : {
39963 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
39964 : {
39965 0 : std::cout << "SgFortranNonblockedDo :: ";
39966 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
39967 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
39968 : }
39969 : }
39970 : else
39971 : {
39972 0 : std::cout << "SgFortranNonblockedDo :: " << std::flush;
39973 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
39974 0 : std::cout << " not valid " << std::endl;
39975 : }
39976 : }
39977 :
39978 0 : if ( p_endOfConstruct != NULL )
39979 : {
39980 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
39981 : {
39982 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
39983 : {
39984 0 : std::cout << "SgFortranNonblockedDo :: ";
39985 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
39986 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
39987 : }
39988 : }
39989 : else
39990 : {
39991 0 : std::cout << "SgFortranNonblockedDo :: " << std::flush;
39992 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
39993 0 : std::cout << " not valid " << std::endl;
39994 : }
39995 : }
39996 :
39997 0 : if ( p_parent != NULL )
39998 : {
39999 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40000 : {
40001 0 : if ( p_parent->isInMemoryPool() == false )
40002 : {
40003 0 : std::cout << "SgFortranNonblockedDo :: ";
40004 0 : std::cout << " p_parent is not in memory pool of ";
40005 0 : std::cout << p_parent->class_name() << std::endl;
40006 : }
40007 : }
40008 : else
40009 : {
40010 0 : std::cout << "SgFortranNonblockedDo :: " << std::flush;
40011 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
40012 0 : std::cout << " not valid " << std::endl;
40013 : }
40014 : }
40015 :
40016 :
40017 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
40018 :
40019 0 : }
40020 :
40021 :
40022 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
40023 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
40024 : bool
40025 0 : SgFortranNonblockedDo::isInMemoryPool ()
40026 : {
40027 0 : typedef unsigned char* TestType;
40028 :
40029 0 : bool found = false;
40030 :
40031 0 : ROSE_ASSERT(this != NULL);
40032 :
40033 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
40034 :
40035 0 : TestType tested = (TestType) ( this ) ;
40036 :
40037 0 : std::vector < unsigned char* > :: const_iterator block = SgFortranNonblockedDo::pools.begin();
40038 :
40039 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
40040 : // while (found == false && block < Memory_Block_List.end())
40041 0 : while ( (found == false) && (block != SgFortranNonblockedDo::pools.end()) )
40042 : {
40043 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFortranNonblockedDo::pool_size * sizeof(SgFortranNonblockedDo) ) ) ;
40044 0 : ++block;
40045 : }
40046 :
40047 : // Special handling for static data
40048 :
40049 :
40050 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
40051 0 : ROSE_ASSERT(found == true);
40052 :
40053 0 : return found;
40054 : }
40055 : /* #line 40056 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
40056 :
40057 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
40058 :
40059 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
40060 :
40061 : /* #line 40062 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
40062 :
40063 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
40064 :
40065 : void
40066 0 : SgForAllStatement::checkDataMemberPointersIfInMemoryPool()
40067 : {
40068 : // ------------ checking pointers of SgForAllStatement -------------------
40069 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40070 :
40071 0 : if ( p_forall_header != NULL )
40072 : {
40073 0 : if ( p_forall_header->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40074 : {
40075 0 : if ( p_forall_header->isInMemoryPool() == false )
40076 : {
40077 0 : std::cout << "SgForAllStatement :: ";
40078 0 : std::cout << " p_forall_header is not in memory pool of ";
40079 0 : std::cout << p_forall_header->class_name() << std::endl;
40080 : }
40081 : }
40082 : else
40083 : {
40084 0 : std::cout << "SgForAllStatement :: " << std::flush;
40085 0 : std::cout << "SgExprListExp* p_forall_header = " << p_forall_header << " --> " << std::flush;
40086 0 : std::cout << " not valid " << std::endl;
40087 : }
40088 : }
40089 :
40090 0 : if ( p_body != NULL )
40091 : {
40092 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40093 : {
40094 0 : if ( p_body->isInMemoryPool() == false )
40095 : {
40096 0 : std::cout << "SgForAllStatement :: ";
40097 0 : std::cout << " p_body is not in memory pool of ";
40098 0 : std::cout << p_body->class_name() << std::endl;
40099 : }
40100 : }
40101 : else
40102 : {
40103 0 : std::cout << "SgForAllStatement :: " << std::flush;
40104 0 : std::cout << "SgBasicBlock* p_body = " << p_body << " --> " << std::flush;
40105 0 : std::cout << " not valid " << std::endl;
40106 : }
40107 : }
40108 :
40109 0 : if ( p_end_numeric_label != NULL )
40110 : {
40111 0 : if ( p_end_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40112 : {
40113 0 : if ( p_end_numeric_label->isInMemoryPool() == false )
40114 : {
40115 0 : std::cout << "SgForAllStatement :: ";
40116 0 : std::cout << " p_end_numeric_label is not in memory pool of ";
40117 0 : std::cout << p_end_numeric_label->class_name() << std::endl;
40118 : }
40119 : }
40120 : else
40121 : {
40122 0 : std::cout << "SgForAllStatement :: " << std::flush;
40123 0 : std::cout << "SgLabelRefExp* p_end_numeric_label = " << p_end_numeric_label << " --> " << std::flush;
40124 0 : std::cout << " not valid " << std::endl;
40125 : }
40126 : }
40127 :
40128 0 : if ( p_symbol_table != NULL )
40129 : {
40130 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40131 : {
40132 0 : if ( p_symbol_table->isInMemoryPool() == false )
40133 : {
40134 0 : std::cout << "SgForAllStatement :: ";
40135 0 : std::cout << " p_symbol_table is not in memory pool of ";
40136 0 : std::cout << p_symbol_table->class_name() << std::endl;
40137 : }
40138 : }
40139 : else
40140 : {
40141 0 : std::cout << "SgForAllStatement :: " << std::flush;
40142 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
40143 0 : std::cout << " not valid " << std::endl;
40144 : }
40145 : }
40146 :
40147 0 : if ( p_type_table != NULL )
40148 : {
40149 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40150 : {
40151 0 : if ( p_type_table->isInMemoryPool() == false )
40152 : {
40153 0 : std::cout << "SgForAllStatement :: ";
40154 0 : std::cout << " p_type_table is not in memory pool of ";
40155 0 : std::cout << p_type_table->class_name() << std::endl;
40156 : }
40157 : }
40158 : else
40159 : {
40160 0 : std::cout << "SgForAllStatement :: " << std::flush;
40161 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
40162 0 : std::cout << " not valid " << std::endl;
40163 : }
40164 : }
40165 :
40166 0 : if ( p_pragma != NULL )
40167 : {
40168 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40169 : {
40170 0 : if ( p_pragma->isInMemoryPool() == false )
40171 : {
40172 0 : std::cout << "SgForAllStatement :: ";
40173 0 : std::cout << " p_pragma is not in memory pool of ";
40174 0 : std::cout << p_pragma->class_name() << std::endl;
40175 : }
40176 : }
40177 : else
40178 : {
40179 0 : std::cout << "SgForAllStatement :: " << std::flush;
40180 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
40181 0 : std::cout << " not valid " << std::endl;
40182 : }
40183 : }
40184 :
40185 0 : if ( p_numeric_label != NULL )
40186 : {
40187 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40188 : {
40189 0 : if ( p_numeric_label->isInMemoryPool() == false )
40190 : {
40191 0 : std::cout << "SgForAllStatement :: ";
40192 0 : std::cout << " p_numeric_label is not in memory pool of ";
40193 0 : std::cout << p_numeric_label->class_name() << std::endl;
40194 : }
40195 : }
40196 : else
40197 : {
40198 0 : std::cout << "SgForAllStatement :: " << std::flush;
40199 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
40200 0 : std::cout << " not valid " << std::endl;
40201 : }
40202 : }
40203 :
40204 0 : if ( p_startOfConstruct != NULL )
40205 : {
40206 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40207 : {
40208 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
40209 : {
40210 0 : std::cout << "SgForAllStatement :: ";
40211 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
40212 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
40213 : }
40214 : }
40215 : else
40216 : {
40217 0 : std::cout << "SgForAllStatement :: " << std::flush;
40218 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
40219 0 : std::cout << " not valid " << std::endl;
40220 : }
40221 : }
40222 :
40223 0 : if ( p_endOfConstruct != NULL )
40224 : {
40225 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40226 : {
40227 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
40228 : {
40229 0 : std::cout << "SgForAllStatement :: ";
40230 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
40231 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
40232 : }
40233 : }
40234 : else
40235 : {
40236 0 : std::cout << "SgForAllStatement :: " << std::flush;
40237 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
40238 0 : std::cout << " not valid " << std::endl;
40239 : }
40240 : }
40241 :
40242 0 : if ( p_parent != NULL )
40243 : {
40244 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40245 : {
40246 0 : if ( p_parent->isInMemoryPool() == false )
40247 : {
40248 0 : std::cout << "SgForAllStatement :: ";
40249 0 : std::cout << " p_parent is not in memory pool of ";
40250 0 : std::cout << p_parent->class_name() << std::endl;
40251 : }
40252 : }
40253 : else
40254 : {
40255 0 : std::cout << "SgForAllStatement :: " << std::flush;
40256 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
40257 0 : std::cout << " not valid " << std::endl;
40258 : }
40259 : }
40260 :
40261 :
40262 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
40263 :
40264 0 : }
40265 :
40266 :
40267 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
40268 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
40269 : bool
40270 0 : SgForAllStatement::isInMemoryPool ()
40271 : {
40272 0 : typedef unsigned char* TestType;
40273 :
40274 0 : bool found = false;
40275 :
40276 0 : ROSE_ASSERT(this != NULL);
40277 :
40278 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
40279 :
40280 0 : TestType tested = (TestType) ( this ) ;
40281 :
40282 0 : std::vector < unsigned char* > :: const_iterator block = SgForAllStatement::pools.begin();
40283 :
40284 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
40285 : // while (found == false && block < Memory_Block_List.end())
40286 0 : while ( (found == false) && (block != SgForAllStatement::pools.end()) )
40287 : {
40288 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgForAllStatement::pool_size * sizeof(SgForAllStatement) ) ) ;
40289 0 : ++block;
40290 : }
40291 :
40292 : // Special handling for static data
40293 :
40294 :
40295 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
40296 0 : ROSE_ASSERT(found == true);
40297 :
40298 0 : return found;
40299 : }
40300 : /* #line 40301 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
40301 :
40302 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
40303 :
40304 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
40305 :
40306 : /* #line 40307 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
40307 :
40308 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
40309 :
40310 : void
40311 0 : SgUpcForAllStatement::checkDataMemberPointersIfInMemoryPool()
40312 : {
40313 : // ------------ checking pointers of SgUpcForAllStatement -------------------
40314 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40315 :
40316 0 : if ( p_for_init_stmt != NULL )
40317 : {
40318 0 : if ( p_for_init_stmt->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40319 : {
40320 0 : if ( p_for_init_stmt->isInMemoryPool() == false )
40321 : {
40322 0 : std::cout << "SgUpcForAllStatement :: ";
40323 0 : std::cout << " p_for_init_stmt is not in memory pool of ";
40324 0 : std::cout << p_for_init_stmt->class_name() << std::endl;
40325 : }
40326 : }
40327 : else
40328 : {
40329 0 : std::cout << "SgUpcForAllStatement :: " << std::flush;
40330 0 : std::cout << "SgForInitStatement* p_for_init_stmt = " << p_for_init_stmt << " --> " << std::flush;
40331 0 : std::cout << " not valid " << std::endl;
40332 : }
40333 : }
40334 :
40335 0 : if ( p_test != NULL )
40336 : {
40337 0 : if ( p_test->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40338 : {
40339 0 : if ( p_test->isInMemoryPool() == false )
40340 : {
40341 0 : std::cout << "SgUpcForAllStatement :: ";
40342 0 : std::cout << " p_test is not in memory pool of ";
40343 0 : std::cout << p_test->class_name() << std::endl;
40344 : }
40345 : }
40346 : else
40347 : {
40348 0 : std::cout << "SgUpcForAllStatement :: " << std::flush;
40349 0 : std::cout << "SgStatement* p_test = " << p_test << " --> " << std::flush;
40350 0 : std::cout << " not valid " << std::endl;
40351 : }
40352 : }
40353 :
40354 0 : if ( p_increment != NULL )
40355 : {
40356 0 : if ( p_increment->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40357 : {
40358 0 : if ( p_increment->isInMemoryPool() == false )
40359 : {
40360 0 : std::cout << "SgUpcForAllStatement :: ";
40361 0 : std::cout << " p_increment is not in memory pool of ";
40362 0 : std::cout << p_increment->class_name() << std::endl;
40363 : }
40364 : }
40365 : else
40366 : {
40367 0 : std::cout << "SgUpcForAllStatement :: " << std::flush;
40368 0 : std::cout << "SgExpression* p_increment = " << p_increment << " --> " << std::flush;
40369 0 : std::cout << " not valid " << std::endl;
40370 : }
40371 : }
40372 :
40373 0 : if ( p_affinity != NULL )
40374 : {
40375 0 : if ( p_affinity->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40376 : {
40377 0 : if ( p_affinity->isInMemoryPool() == false )
40378 : {
40379 0 : std::cout << "SgUpcForAllStatement :: ";
40380 0 : std::cout << " p_affinity is not in memory pool of ";
40381 0 : std::cout << p_affinity->class_name() << std::endl;
40382 : }
40383 : }
40384 : else
40385 : {
40386 0 : std::cout << "SgUpcForAllStatement :: " << std::flush;
40387 0 : std::cout << "SgExpression* p_affinity = " << p_affinity << " --> " << std::flush;
40388 0 : std::cout << " not valid " << std::endl;
40389 : }
40390 : }
40391 :
40392 0 : if ( p_loop_body != NULL )
40393 : {
40394 0 : if ( p_loop_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40395 : {
40396 0 : if ( p_loop_body->isInMemoryPool() == false )
40397 : {
40398 0 : std::cout << "SgUpcForAllStatement :: ";
40399 0 : std::cout << " p_loop_body is not in memory pool of ";
40400 0 : std::cout << p_loop_body->class_name() << std::endl;
40401 : }
40402 : }
40403 : else
40404 : {
40405 0 : std::cout << "SgUpcForAllStatement :: " << std::flush;
40406 0 : std::cout << "SgStatement* p_loop_body = " << p_loop_body << " --> " << std::flush;
40407 0 : std::cout << " not valid " << std::endl;
40408 : }
40409 : }
40410 :
40411 0 : if ( p_symbol_table != NULL )
40412 : {
40413 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40414 : {
40415 0 : if ( p_symbol_table->isInMemoryPool() == false )
40416 : {
40417 0 : std::cout << "SgUpcForAllStatement :: ";
40418 0 : std::cout << " p_symbol_table is not in memory pool of ";
40419 0 : std::cout << p_symbol_table->class_name() << std::endl;
40420 : }
40421 : }
40422 : else
40423 : {
40424 0 : std::cout << "SgUpcForAllStatement :: " << std::flush;
40425 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
40426 0 : std::cout << " not valid " << std::endl;
40427 : }
40428 : }
40429 :
40430 0 : if ( p_type_table != NULL )
40431 : {
40432 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40433 : {
40434 0 : if ( p_type_table->isInMemoryPool() == false )
40435 : {
40436 0 : std::cout << "SgUpcForAllStatement :: ";
40437 0 : std::cout << " p_type_table is not in memory pool of ";
40438 0 : std::cout << p_type_table->class_name() << std::endl;
40439 : }
40440 : }
40441 : else
40442 : {
40443 0 : std::cout << "SgUpcForAllStatement :: " << std::flush;
40444 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
40445 0 : std::cout << " not valid " << std::endl;
40446 : }
40447 : }
40448 :
40449 0 : if ( p_pragma != NULL )
40450 : {
40451 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40452 : {
40453 0 : if ( p_pragma->isInMemoryPool() == false )
40454 : {
40455 0 : std::cout << "SgUpcForAllStatement :: ";
40456 0 : std::cout << " p_pragma is not in memory pool of ";
40457 0 : std::cout << p_pragma->class_name() << std::endl;
40458 : }
40459 : }
40460 : else
40461 : {
40462 0 : std::cout << "SgUpcForAllStatement :: " << std::flush;
40463 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
40464 0 : std::cout << " not valid " << std::endl;
40465 : }
40466 : }
40467 :
40468 0 : if ( p_numeric_label != NULL )
40469 : {
40470 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40471 : {
40472 0 : if ( p_numeric_label->isInMemoryPool() == false )
40473 : {
40474 0 : std::cout << "SgUpcForAllStatement :: ";
40475 0 : std::cout << " p_numeric_label is not in memory pool of ";
40476 0 : std::cout << p_numeric_label->class_name() << std::endl;
40477 : }
40478 : }
40479 : else
40480 : {
40481 0 : std::cout << "SgUpcForAllStatement :: " << std::flush;
40482 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
40483 0 : std::cout << " not valid " << std::endl;
40484 : }
40485 : }
40486 :
40487 0 : if ( p_startOfConstruct != NULL )
40488 : {
40489 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40490 : {
40491 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
40492 : {
40493 0 : std::cout << "SgUpcForAllStatement :: ";
40494 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
40495 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
40496 : }
40497 : }
40498 : else
40499 : {
40500 0 : std::cout << "SgUpcForAllStatement :: " << std::flush;
40501 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
40502 0 : std::cout << " not valid " << std::endl;
40503 : }
40504 : }
40505 :
40506 0 : if ( p_endOfConstruct != NULL )
40507 : {
40508 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40509 : {
40510 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
40511 : {
40512 0 : std::cout << "SgUpcForAllStatement :: ";
40513 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
40514 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
40515 : }
40516 : }
40517 : else
40518 : {
40519 0 : std::cout << "SgUpcForAllStatement :: " << std::flush;
40520 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
40521 0 : std::cout << " not valid " << std::endl;
40522 : }
40523 : }
40524 :
40525 0 : if ( p_parent != NULL )
40526 : {
40527 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40528 : {
40529 0 : if ( p_parent->isInMemoryPool() == false )
40530 : {
40531 0 : std::cout << "SgUpcForAllStatement :: ";
40532 0 : std::cout << " p_parent is not in memory pool of ";
40533 0 : std::cout << p_parent->class_name() << std::endl;
40534 : }
40535 : }
40536 : else
40537 : {
40538 0 : std::cout << "SgUpcForAllStatement :: " << std::flush;
40539 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
40540 0 : std::cout << " not valid " << std::endl;
40541 : }
40542 : }
40543 :
40544 :
40545 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
40546 :
40547 0 : }
40548 :
40549 :
40550 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
40551 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
40552 : bool
40553 0 : SgUpcForAllStatement::isInMemoryPool ()
40554 : {
40555 0 : typedef unsigned char* TestType;
40556 :
40557 0 : bool found = false;
40558 :
40559 0 : ROSE_ASSERT(this != NULL);
40560 :
40561 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
40562 :
40563 0 : TestType tested = (TestType) ( this ) ;
40564 :
40565 0 : std::vector < unsigned char* > :: const_iterator block = SgUpcForAllStatement::pools.begin();
40566 :
40567 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
40568 : // while (found == false && block < Memory_Block_List.end())
40569 0 : while ( (found == false) && (block != SgUpcForAllStatement::pools.end()) )
40570 : {
40571 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpcForAllStatement::pool_size * sizeof(SgUpcForAllStatement) ) ) ;
40572 0 : ++block;
40573 : }
40574 :
40575 : // Special handling for static data
40576 :
40577 :
40578 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
40579 0 : ROSE_ASSERT(found == true);
40580 :
40581 0 : return found;
40582 : }
40583 : /* #line 40584 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
40584 :
40585 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
40586 :
40587 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
40588 :
40589 : /* #line 40590 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
40590 :
40591 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
40592 :
40593 : void
40594 0 : SgCAFWithTeamStatement::checkDataMemberPointersIfInMemoryPool()
40595 : {
40596 : // ------------ checking pointers of SgCAFWithTeamStatement -------------------
40597 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40598 :
40599 0 : if ( p_teamId != NULL )
40600 : {
40601 0 : if ( p_teamId->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40602 : {
40603 0 : if ( p_teamId->isInMemoryPool() == false )
40604 : {
40605 0 : std::cout << "SgCAFWithTeamStatement :: ";
40606 0 : std::cout << " p_teamId is not in memory pool of ";
40607 0 : std::cout << p_teamId->class_name() << std::endl;
40608 : }
40609 : }
40610 : else
40611 : {
40612 0 : std::cout << "SgCAFWithTeamStatement :: " << std::flush;
40613 0 : std::cout << "SgVarRefExp* p_teamId = " << p_teamId << " --> " << std::flush;
40614 0 : std::cout << " not valid " << std::endl;
40615 : }
40616 : }
40617 :
40618 0 : if ( p_body != NULL )
40619 : {
40620 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40621 : {
40622 0 : if ( p_body->isInMemoryPool() == false )
40623 : {
40624 0 : std::cout << "SgCAFWithTeamStatement :: ";
40625 0 : std::cout << " p_body is not in memory pool of ";
40626 0 : std::cout << p_body->class_name() << std::endl;
40627 : }
40628 : }
40629 : else
40630 : {
40631 0 : std::cout << "SgCAFWithTeamStatement :: " << std::flush;
40632 0 : std::cout << "SgBasicBlock* p_body = " << p_body << " --> " << std::flush;
40633 0 : std::cout << " not valid " << std::endl;
40634 : }
40635 : }
40636 :
40637 0 : if ( p_symbol_table != NULL )
40638 : {
40639 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40640 : {
40641 0 : if ( p_symbol_table->isInMemoryPool() == false )
40642 : {
40643 0 : std::cout << "SgCAFWithTeamStatement :: ";
40644 0 : std::cout << " p_symbol_table is not in memory pool of ";
40645 0 : std::cout << p_symbol_table->class_name() << std::endl;
40646 : }
40647 : }
40648 : else
40649 : {
40650 0 : std::cout << "SgCAFWithTeamStatement :: " << std::flush;
40651 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
40652 0 : std::cout << " not valid " << std::endl;
40653 : }
40654 : }
40655 :
40656 0 : if ( p_type_table != NULL )
40657 : {
40658 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40659 : {
40660 0 : if ( p_type_table->isInMemoryPool() == false )
40661 : {
40662 0 : std::cout << "SgCAFWithTeamStatement :: ";
40663 0 : std::cout << " p_type_table is not in memory pool of ";
40664 0 : std::cout << p_type_table->class_name() << std::endl;
40665 : }
40666 : }
40667 : else
40668 : {
40669 0 : std::cout << "SgCAFWithTeamStatement :: " << std::flush;
40670 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
40671 0 : std::cout << " not valid " << std::endl;
40672 : }
40673 : }
40674 :
40675 0 : if ( p_pragma != NULL )
40676 : {
40677 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40678 : {
40679 0 : if ( p_pragma->isInMemoryPool() == false )
40680 : {
40681 0 : std::cout << "SgCAFWithTeamStatement :: ";
40682 0 : std::cout << " p_pragma is not in memory pool of ";
40683 0 : std::cout << p_pragma->class_name() << std::endl;
40684 : }
40685 : }
40686 : else
40687 : {
40688 0 : std::cout << "SgCAFWithTeamStatement :: " << std::flush;
40689 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
40690 0 : std::cout << " not valid " << std::endl;
40691 : }
40692 : }
40693 :
40694 0 : if ( p_numeric_label != NULL )
40695 : {
40696 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40697 : {
40698 0 : if ( p_numeric_label->isInMemoryPool() == false )
40699 : {
40700 0 : std::cout << "SgCAFWithTeamStatement :: ";
40701 0 : std::cout << " p_numeric_label is not in memory pool of ";
40702 0 : std::cout << p_numeric_label->class_name() << std::endl;
40703 : }
40704 : }
40705 : else
40706 : {
40707 0 : std::cout << "SgCAFWithTeamStatement :: " << std::flush;
40708 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
40709 0 : std::cout << " not valid " << std::endl;
40710 : }
40711 : }
40712 :
40713 0 : if ( p_startOfConstruct != NULL )
40714 : {
40715 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40716 : {
40717 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
40718 : {
40719 0 : std::cout << "SgCAFWithTeamStatement :: ";
40720 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
40721 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
40722 : }
40723 : }
40724 : else
40725 : {
40726 0 : std::cout << "SgCAFWithTeamStatement :: " << std::flush;
40727 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
40728 0 : std::cout << " not valid " << std::endl;
40729 : }
40730 : }
40731 :
40732 0 : if ( p_endOfConstruct != NULL )
40733 : {
40734 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40735 : {
40736 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
40737 : {
40738 0 : std::cout << "SgCAFWithTeamStatement :: ";
40739 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
40740 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
40741 : }
40742 : }
40743 : else
40744 : {
40745 0 : std::cout << "SgCAFWithTeamStatement :: " << std::flush;
40746 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
40747 0 : std::cout << " not valid " << std::endl;
40748 : }
40749 : }
40750 :
40751 0 : if ( p_parent != NULL )
40752 : {
40753 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40754 : {
40755 0 : if ( p_parent->isInMemoryPool() == false )
40756 : {
40757 0 : std::cout << "SgCAFWithTeamStatement :: ";
40758 0 : std::cout << " p_parent is not in memory pool of ";
40759 0 : std::cout << p_parent->class_name() << std::endl;
40760 : }
40761 : }
40762 : else
40763 : {
40764 0 : std::cout << "SgCAFWithTeamStatement :: " << std::flush;
40765 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
40766 0 : std::cout << " not valid " << std::endl;
40767 : }
40768 : }
40769 :
40770 :
40771 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
40772 :
40773 0 : }
40774 :
40775 :
40776 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
40777 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
40778 : bool
40779 0 : SgCAFWithTeamStatement::isInMemoryPool ()
40780 : {
40781 0 : typedef unsigned char* TestType;
40782 :
40783 0 : bool found = false;
40784 :
40785 0 : ROSE_ASSERT(this != NULL);
40786 :
40787 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
40788 :
40789 0 : TestType tested = (TestType) ( this ) ;
40790 :
40791 0 : std::vector < unsigned char* > :: const_iterator block = SgCAFWithTeamStatement::pools.begin();
40792 :
40793 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
40794 : // while (found == false && block < Memory_Block_List.end())
40795 0 : while ( (found == false) && (block != SgCAFWithTeamStatement::pools.end()) )
40796 : {
40797 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCAFWithTeamStatement::pool_size * sizeof(SgCAFWithTeamStatement) ) ) ;
40798 0 : ++block;
40799 : }
40800 :
40801 : // Special handling for static data
40802 :
40803 :
40804 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
40805 0 : ROSE_ASSERT(found == true);
40806 :
40807 0 : return found;
40808 : }
40809 : /* #line 40810 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
40810 :
40811 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
40812 :
40813 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
40814 :
40815 : /* #line 40816 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
40816 :
40817 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
40818 :
40819 : void
40820 0 : SgFunctionParameterScope::checkDataMemberPointersIfInMemoryPool()
40821 : {
40822 : // ------------ checking pointers of SgFunctionParameterScope -------------------
40823 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40824 :
40825 0 : SgDeclarationStatementPtrList::iterator i_declarations = p_declarations.begin() ;
40826 0 : for ( ; i_declarations != p_declarations.end(); ++i_declarations )
40827 : {
40828 0 : if ( (*i_declarations) != NULL )
40829 : {
40830 0 : if ( (*i_declarations)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40831 : {
40832 0 : if ( (*i_declarations)->isInMemoryPool() == false )
40833 : {
40834 0 : std::cout << "SgFunctionParameterScope :: ";
40835 0 : std::cout << " p_declarations ( list of poitners to IR nodes ), entry is not in memory pool of ";
40836 0 : std::cout << (*i_declarations)->class_name() << std::endl;
40837 : }
40838 : }
40839 : else
40840 : {
40841 0 : std::cout << "SgFunctionParameterScope :: " << std::flush;
40842 0 : std::cout << "SgDeclarationStatementPtrList p_declarations --> " << std::flush;
40843 0 : std::cout << " entry not valid " << std::endl;
40844 : }
40845 : }
40846 : else
40847 : {
40848 0 : std::cout << "SgDeclarationStatementPtrList p_declarations --> NULL " << std::endl;
40849 : }
40850 : }
40851 :
40852 0 : if ( p_symbol_table != NULL )
40853 : {
40854 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40855 : {
40856 0 : if ( p_symbol_table->isInMemoryPool() == false )
40857 : {
40858 0 : std::cout << "SgFunctionParameterScope :: ";
40859 0 : std::cout << " p_symbol_table is not in memory pool of ";
40860 0 : std::cout << p_symbol_table->class_name() << std::endl;
40861 : }
40862 : }
40863 : else
40864 : {
40865 0 : std::cout << "SgFunctionParameterScope :: " << std::flush;
40866 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
40867 0 : std::cout << " not valid " << std::endl;
40868 : }
40869 : }
40870 :
40871 0 : if ( p_type_table != NULL )
40872 : {
40873 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40874 : {
40875 0 : if ( p_type_table->isInMemoryPool() == false )
40876 : {
40877 0 : std::cout << "SgFunctionParameterScope :: ";
40878 0 : std::cout << " p_type_table is not in memory pool of ";
40879 0 : std::cout << p_type_table->class_name() << std::endl;
40880 : }
40881 : }
40882 : else
40883 : {
40884 0 : std::cout << "SgFunctionParameterScope :: " << std::flush;
40885 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
40886 0 : std::cout << " not valid " << std::endl;
40887 : }
40888 : }
40889 :
40890 0 : if ( p_pragma != NULL )
40891 : {
40892 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40893 : {
40894 0 : if ( p_pragma->isInMemoryPool() == false )
40895 : {
40896 0 : std::cout << "SgFunctionParameterScope :: ";
40897 0 : std::cout << " p_pragma is not in memory pool of ";
40898 0 : std::cout << p_pragma->class_name() << std::endl;
40899 : }
40900 : }
40901 : else
40902 : {
40903 0 : std::cout << "SgFunctionParameterScope :: " << std::flush;
40904 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
40905 0 : std::cout << " not valid " << std::endl;
40906 : }
40907 : }
40908 :
40909 0 : if ( p_numeric_label != NULL )
40910 : {
40911 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40912 : {
40913 0 : if ( p_numeric_label->isInMemoryPool() == false )
40914 : {
40915 0 : std::cout << "SgFunctionParameterScope :: ";
40916 0 : std::cout << " p_numeric_label is not in memory pool of ";
40917 0 : std::cout << p_numeric_label->class_name() << std::endl;
40918 : }
40919 : }
40920 : else
40921 : {
40922 0 : std::cout << "SgFunctionParameterScope :: " << std::flush;
40923 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
40924 0 : std::cout << " not valid " << std::endl;
40925 : }
40926 : }
40927 :
40928 0 : if ( p_startOfConstruct != NULL )
40929 : {
40930 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40931 : {
40932 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
40933 : {
40934 0 : std::cout << "SgFunctionParameterScope :: ";
40935 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
40936 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
40937 : }
40938 : }
40939 : else
40940 : {
40941 0 : std::cout << "SgFunctionParameterScope :: " << std::flush;
40942 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
40943 0 : std::cout << " not valid " << std::endl;
40944 : }
40945 : }
40946 :
40947 0 : if ( p_endOfConstruct != NULL )
40948 : {
40949 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40950 : {
40951 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
40952 : {
40953 0 : std::cout << "SgFunctionParameterScope :: ";
40954 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
40955 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
40956 : }
40957 : }
40958 : else
40959 : {
40960 0 : std::cout << "SgFunctionParameterScope :: " << std::flush;
40961 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
40962 0 : std::cout << " not valid " << std::endl;
40963 : }
40964 : }
40965 :
40966 0 : if ( p_parent != NULL )
40967 : {
40968 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
40969 : {
40970 0 : if ( p_parent->isInMemoryPool() == false )
40971 : {
40972 0 : std::cout << "SgFunctionParameterScope :: ";
40973 0 : std::cout << " p_parent is not in memory pool of ";
40974 0 : std::cout << p_parent->class_name() << std::endl;
40975 : }
40976 : }
40977 : else
40978 : {
40979 0 : std::cout << "SgFunctionParameterScope :: " << std::flush;
40980 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
40981 0 : std::cout << " not valid " << std::endl;
40982 : }
40983 : }
40984 :
40985 :
40986 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
40987 :
40988 0 : }
40989 :
40990 :
40991 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
40992 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
40993 : bool
40994 0 : SgFunctionParameterScope::isInMemoryPool ()
40995 : {
40996 0 : typedef unsigned char* TestType;
40997 :
40998 0 : bool found = false;
40999 :
41000 0 : ROSE_ASSERT(this != NULL);
41001 :
41002 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
41003 :
41004 0 : TestType tested = (TestType) ( this ) ;
41005 :
41006 0 : std::vector < unsigned char* > :: const_iterator block = SgFunctionParameterScope::pools.begin();
41007 :
41008 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
41009 : // while (found == false && block < Memory_Block_List.end())
41010 0 : while ( (found == false) && (block != SgFunctionParameterScope::pools.end()) )
41011 : {
41012 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFunctionParameterScope::pool_size * sizeof(SgFunctionParameterScope) ) ) ;
41013 0 : ++block;
41014 : }
41015 :
41016 : // Special handling for static data
41017 :
41018 :
41019 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
41020 0 : ROSE_ASSERT(found == true);
41021 :
41022 0 : return found;
41023 : }
41024 : /* #line 41025 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
41025 :
41026 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
41027 :
41028 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
41029 :
41030 : /* #line 41031 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
41031 :
41032 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
41033 :
41034 : void
41035 0 : SgDeclarationScope::checkDataMemberPointersIfInMemoryPool()
41036 : {
41037 : // ------------ checking pointers of SgDeclarationScope -------------------
41038 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41039 :
41040 0 : if ( p_symbol_table != NULL )
41041 : {
41042 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41043 : {
41044 0 : if ( p_symbol_table->isInMemoryPool() == false )
41045 : {
41046 0 : std::cout << "SgDeclarationScope :: ";
41047 0 : std::cout << " p_symbol_table is not in memory pool of ";
41048 0 : std::cout << p_symbol_table->class_name() << std::endl;
41049 : }
41050 : }
41051 : else
41052 : {
41053 0 : std::cout << "SgDeclarationScope :: " << std::flush;
41054 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
41055 0 : std::cout << " not valid " << std::endl;
41056 : }
41057 : }
41058 :
41059 0 : if ( p_type_table != NULL )
41060 : {
41061 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41062 : {
41063 0 : if ( p_type_table->isInMemoryPool() == false )
41064 : {
41065 0 : std::cout << "SgDeclarationScope :: ";
41066 0 : std::cout << " p_type_table is not in memory pool of ";
41067 0 : std::cout << p_type_table->class_name() << std::endl;
41068 : }
41069 : }
41070 : else
41071 : {
41072 0 : std::cout << "SgDeclarationScope :: " << std::flush;
41073 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
41074 0 : std::cout << " not valid " << std::endl;
41075 : }
41076 : }
41077 :
41078 0 : if ( p_pragma != NULL )
41079 : {
41080 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41081 : {
41082 0 : if ( p_pragma->isInMemoryPool() == false )
41083 : {
41084 0 : std::cout << "SgDeclarationScope :: ";
41085 0 : std::cout << " p_pragma is not in memory pool of ";
41086 0 : std::cout << p_pragma->class_name() << std::endl;
41087 : }
41088 : }
41089 : else
41090 : {
41091 0 : std::cout << "SgDeclarationScope :: " << std::flush;
41092 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
41093 0 : std::cout << " not valid " << std::endl;
41094 : }
41095 : }
41096 :
41097 0 : if ( p_numeric_label != NULL )
41098 : {
41099 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41100 : {
41101 0 : if ( p_numeric_label->isInMemoryPool() == false )
41102 : {
41103 0 : std::cout << "SgDeclarationScope :: ";
41104 0 : std::cout << " p_numeric_label is not in memory pool of ";
41105 0 : std::cout << p_numeric_label->class_name() << std::endl;
41106 : }
41107 : }
41108 : else
41109 : {
41110 0 : std::cout << "SgDeclarationScope :: " << std::flush;
41111 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
41112 0 : std::cout << " not valid " << std::endl;
41113 : }
41114 : }
41115 :
41116 0 : if ( p_startOfConstruct != NULL )
41117 : {
41118 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41119 : {
41120 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
41121 : {
41122 0 : std::cout << "SgDeclarationScope :: ";
41123 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
41124 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
41125 : }
41126 : }
41127 : else
41128 : {
41129 0 : std::cout << "SgDeclarationScope :: " << std::flush;
41130 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
41131 0 : std::cout << " not valid " << std::endl;
41132 : }
41133 : }
41134 :
41135 0 : if ( p_endOfConstruct != NULL )
41136 : {
41137 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41138 : {
41139 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
41140 : {
41141 0 : std::cout << "SgDeclarationScope :: ";
41142 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
41143 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
41144 : }
41145 : }
41146 : else
41147 : {
41148 0 : std::cout << "SgDeclarationScope :: " << std::flush;
41149 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
41150 0 : std::cout << " not valid " << std::endl;
41151 : }
41152 : }
41153 :
41154 0 : if ( p_parent != NULL )
41155 : {
41156 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41157 : {
41158 0 : if ( p_parent->isInMemoryPool() == false )
41159 : {
41160 0 : std::cout << "SgDeclarationScope :: ";
41161 0 : std::cout << " p_parent is not in memory pool of ";
41162 0 : std::cout << p_parent->class_name() << std::endl;
41163 : }
41164 : }
41165 : else
41166 : {
41167 0 : std::cout << "SgDeclarationScope :: " << std::flush;
41168 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
41169 0 : std::cout << " not valid " << std::endl;
41170 : }
41171 : }
41172 :
41173 :
41174 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
41175 :
41176 0 : }
41177 :
41178 :
41179 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
41180 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
41181 : bool
41182 0 : SgDeclarationScope::isInMemoryPool ()
41183 : {
41184 0 : typedef unsigned char* TestType;
41185 :
41186 0 : bool found = false;
41187 :
41188 0 : ROSE_ASSERT(this != NULL);
41189 :
41190 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
41191 :
41192 0 : TestType tested = (TestType) ( this ) ;
41193 :
41194 0 : std::vector < unsigned char* > :: const_iterator block = SgDeclarationScope::pools.begin();
41195 :
41196 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
41197 : // while (found == false && block < Memory_Block_List.end())
41198 0 : while ( (found == false) && (block != SgDeclarationScope::pools.end()) )
41199 : {
41200 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDeclarationScope::pool_size * sizeof(SgDeclarationScope) ) ) ;
41201 0 : ++block;
41202 : }
41203 :
41204 : // Special handling for static data
41205 :
41206 :
41207 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
41208 0 : ROSE_ASSERT(found == true);
41209 :
41210 0 : return found;
41211 : }
41212 : /* #line 41213 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
41213 :
41214 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
41215 :
41216 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
41217 :
41218 : /* #line 41219 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
41219 :
41220 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
41221 :
41222 : void
41223 0 : SgRangeBasedForStatement::checkDataMemberPointersIfInMemoryPool()
41224 : {
41225 : // ------------ checking pointers of SgRangeBasedForStatement -------------------
41226 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41227 :
41228 0 : if ( p_iterator_declaration != NULL )
41229 : {
41230 0 : if ( p_iterator_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41231 : {
41232 0 : if ( p_iterator_declaration->isInMemoryPool() == false )
41233 : {
41234 0 : std::cout << "SgRangeBasedForStatement :: ";
41235 0 : std::cout << " p_iterator_declaration is not in memory pool of ";
41236 0 : std::cout << p_iterator_declaration->class_name() << std::endl;
41237 : }
41238 : }
41239 : else
41240 : {
41241 0 : std::cout << "SgRangeBasedForStatement :: " << std::flush;
41242 0 : std::cout << "SgVariableDeclaration* p_iterator_declaration = " << p_iterator_declaration << " --> " << std::flush;
41243 0 : std::cout << " not valid " << std::endl;
41244 : }
41245 : }
41246 :
41247 0 : if ( p_range_declaration != NULL )
41248 : {
41249 0 : if ( p_range_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41250 : {
41251 0 : if ( p_range_declaration->isInMemoryPool() == false )
41252 : {
41253 0 : std::cout << "SgRangeBasedForStatement :: ";
41254 0 : std::cout << " p_range_declaration is not in memory pool of ";
41255 0 : std::cout << p_range_declaration->class_name() << std::endl;
41256 : }
41257 : }
41258 : else
41259 : {
41260 0 : std::cout << "SgRangeBasedForStatement :: " << std::flush;
41261 0 : std::cout << "SgVariableDeclaration* p_range_declaration = " << p_range_declaration << " --> " << std::flush;
41262 0 : std::cout << " not valid " << std::endl;
41263 : }
41264 : }
41265 :
41266 0 : if ( p_begin_declaration != NULL )
41267 : {
41268 0 : if ( p_begin_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41269 : {
41270 0 : if ( p_begin_declaration->isInMemoryPool() == false )
41271 : {
41272 0 : std::cout << "SgRangeBasedForStatement :: ";
41273 0 : std::cout << " p_begin_declaration is not in memory pool of ";
41274 0 : std::cout << p_begin_declaration->class_name() << std::endl;
41275 : }
41276 : }
41277 : else
41278 : {
41279 0 : std::cout << "SgRangeBasedForStatement :: " << std::flush;
41280 0 : std::cout << "SgVariableDeclaration* p_begin_declaration = " << p_begin_declaration << " --> " << std::flush;
41281 0 : std::cout << " not valid " << std::endl;
41282 : }
41283 : }
41284 :
41285 0 : if ( p_end_declaration != NULL )
41286 : {
41287 0 : if ( p_end_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41288 : {
41289 0 : if ( p_end_declaration->isInMemoryPool() == false )
41290 : {
41291 0 : std::cout << "SgRangeBasedForStatement :: ";
41292 0 : std::cout << " p_end_declaration is not in memory pool of ";
41293 0 : std::cout << p_end_declaration->class_name() << std::endl;
41294 : }
41295 : }
41296 : else
41297 : {
41298 0 : std::cout << "SgRangeBasedForStatement :: " << std::flush;
41299 0 : std::cout << "SgVariableDeclaration* p_end_declaration = " << p_end_declaration << " --> " << std::flush;
41300 0 : std::cout << " not valid " << std::endl;
41301 : }
41302 : }
41303 :
41304 0 : if ( p_not_equal_expression != NULL )
41305 : {
41306 0 : if ( p_not_equal_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41307 : {
41308 0 : if ( p_not_equal_expression->isInMemoryPool() == false )
41309 : {
41310 0 : std::cout << "SgRangeBasedForStatement :: ";
41311 0 : std::cout << " p_not_equal_expression is not in memory pool of ";
41312 0 : std::cout << p_not_equal_expression->class_name() << std::endl;
41313 : }
41314 : }
41315 : else
41316 : {
41317 0 : std::cout << "SgRangeBasedForStatement :: " << std::flush;
41318 0 : std::cout << "SgExpression* p_not_equal_expression = " << p_not_equal_expression << " --> " << std::flush;
41319 0 : std::cout << " not valid " << std::endl;
41320 : }
41321 : }
41322 :
41323 0 : if ( p_increment_expression != NULL )
41324 : {
41325 0 : if ( p_increment_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41326 : {
41327 0 : if ( p_increment_expression->isInMemoryPool() == false )
41328 : {
41329 0 : std::cout << "SgRangeBasedForStatement :: ";
41330 0 : std::cout << " p_increment_expression is not in memory pool of ";
41331 0 : std::cout << p_increment_expression->class_name() << std::endl;
41332 : }
41333 : }
41334 : else
41335 : {
41336 0 : std::cout << "SgRangeBasedForStatement :: " << std::flush;
41337 0 : std::cout << "SgExpression* p_increment_expression = " << p_increment_expression << " --> " << std::flush;
41338 0 : std::cout << " not valid " << std::endl;
41339 : }
41340 : }
41341 :
41342 0 : if ( p_loop_body != NULL )
41343 : {
41344 0 : if ( p_loop_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41345 : {
41346 0 : if ( p_loop_body->isInMemoryPool() == false )
41347 : {
41348 0 : std::cout << "SgRangeBasedForStatement :: ";
41349 0 : std::cout << " p_loop_body is not in memory pool of ";
41350 0 : std::cout << p_loop_body->class_name() << std::endl;
41351 : }
41352 : }
41353 : else
41354 : {
41355 0 : std::cout << "SgRangeBasedForStatement :: " << std::flush;
41356 0 : std::cout << "SgStatement* p_loop_body = " << p_loop_body << " --> " << std::flush;
41357 0 : std::cout << " not valid " << std::endl;
41358 : }
41359 : }
41360 :
41361 0 : if ( p_symbol_table != NULL )
41362 : {
41363 0 : if ( p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41364 : {
41365 0 : if ( p_symbol_table->isInMemoryPool() == false )
41366 : {
41367 0 : std::cout << "SgRangeBasedForStatement :: ";
41368 0 : std::cout << " p_symbol_table is not in memory pool of ";
41369 0 : std::cout << p_symbol_table->class_name() << std::endl;
41370 : }
41371 : }
41372 : else
41373 : {
41374 0 : std::cout << "SgRangeBasedForStatement :: " << std::flush;
41375 0 : std::cout << "SgSymbolTable* p_symbol_table = " << p_symbol_table << " --> " << std::flush;
41376 0 : std::cout << " not valid " << std::endl;
41377 : }
41378 : }
41379 :
41380 0 : if ( p_type_table != NULL )
41381 : {
41382 0 : if ( p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41383 : {
41384 0 : if ( p_type_table->isInMemoryPool() == false )
41385 : {
41386 0 : std::cout << "SgRangeBasedForStatement :: ";
41387 0 : std::cout << " p_type_table is not in memory pool of ";
41388 0 : std::cout << p_type_table->class_name() << std::endl;
41389 : }
41390 : }
41391 : else
41392 : {
41393 0 : std::cout << "SgRangeBasedForStatement :: " << std::flush;
41394 0 : std::cout << "SgTypeTable* p_type_table = " << p_type_table << " --> " << std::flush;
41395 0 : std::cout << " not valid " << std::endl;
41396 : }
41397 : }
41398 :
41399 0 : if ( p_pragma != NULL )
41400 : {
41401 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41402 : {
41403 0 : if ( p_pragma->isInMemoryPool() == false )
41404 : {
41405 0 : std::cout << "SgRangeBasedForStatement :: ";
41406 0 : std::cout << " p_pragma is not in memory pool of ";
41407 0 : std::cout << p_pragma->class_name() << std::endl;
41408 : }
41409 : }
41410 : else
41411 : {
41412 0 : std::cout << "SgRangeBasedForStatement :: " << std::flush;
41413 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
41414 0 : std::cout << " not valid " << std::endl;
41415 : }
41416 : }
41417 :
41418 0 : if ( p_numeric_label != NULL )
41419 : {
41420 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41421 : {
41422 0 : if ( p_numeric_label->isInMemoryPool() == false )
41423 : {
41424 0 : std::cout << "SgRangeBasedForStatement :: ";
41425 0 : std::cout << " p_numeric_label is not in memory pool of ";
41426 0 : std::cout << p_numeric_label->class_name() << std::endl;
41427 : }
41428 : }
41429 : else
41430 : {
41431 0 : std::cout << "SgRangeBasedForStatement :: " << std::flush;
41432 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
41433 0 : std::cout << " not valid " << std::endl;
41434 : }
41435 : }
41436 :
41437 0 : if ( p_startOfConstruct != NULL )
41438 : {
41439 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41440 : {
41441 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
41442 : {
41443 0 : std::cout << "SgRangeBasedForStatement :: ";
41444 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
41445 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
41446 : }
41447 : }
41448 : else
41449 : {
41450 0 : std::cout << "SgRangeBasedForStatement :: " << std::flush;
41451 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
41452 0 : std::cout << " not valid " << std::endl;
41453 : }
41454 : }
41455 :
41456 0 : if ( p_endOfConstruct != NULL )
41457 : {
41458 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41459 : {
41460 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
41461 : {
41462 0 : std::cout << "SgRangeBasedForStatement :: ";
41463 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
41464 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
41465 : }
41466 : }
41467 : else
41468 : {
41469 0 : std::cout << "SgRangeBasedForStatement :: " << std::flush;
41470 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
41471 0 : std::cout << " not valid " << std::endl;
41472 : }
41473 : }
41474 :
41475 0 : if ( p_parent != NULL )
41476 : {
41477 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41478 : {
41479 0 : if ( p_parent->isInMemoryPool() == false )
41480 : {
41481 0 : std::cout << "SgRangeBasedForStatement :: ";
41482 0 : std::cout << " p_parent is not in memory pool of ";
41483 0 : std::cout << p_parent->class_name() << std::endl;
41484 : }
41485 : }
41486 : else
41487 : {
41488 0 : std::cout << "SgRangeBasedForStatement :: " << std::flush;
41489 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
41490 0 : std::cout << " not valid " << std::endl;
41491 : }
41492 : }
41493 :
41494 :
41495 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
41496 :
41497 0 : }
41498 :
41499 :
41500 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
41501 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
41502 : bool
41503 0 : SgRangeBasedForStatement::isInMemoryPool ()
41504 : {
41505 0 : typedef unsigned char* TestType;
41506 :
41507 0 : bool found = false;
41508 :
41509 0 : ROSE_ASSERT(this != NULL);
41510 :
41511 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
41512 :
41513 0 : TestType tested = (TestType) ( this ) ;
41514 :
41515 0 : std::vector < unsigned char* > :: const_iterator block = SgRangeBasedForStatement::pools.begin();
41516 :
41517 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
41518 : // while (found == false && block < Memory_Block_List.end())
41519 0 : while ( (found == false) && (block != SgRangeBasedForStatement::pools.end()) )
41520 : {
41521 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgRangeBasedForStatement::pool_size * sizeof(SgRangeBasedForStatement) ) ) ;
41522 0 : ++block;
41523 : }
41524 :
41525 : // Special handling for static data
41526 :
41527 :
41528 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
41529 0 : ROSE_ASSERT(found == true);
41530 :
41531 0 : return found;
41532 : }
41533 : /* #line 41534 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
41534 :
41535 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
41536 :
41537 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
41538 :
41539 : /* #line 41540 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
41540 :
41541 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
41542 :
41543 : void
41544 0 : SgFunctionTypeTable::checkDataMemberPointersIfInMemoryPool()
41545 : {
41546 : // ------------ checking pointers of SgFunctionTypeTable -------------------
41547 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41548 :
41549 0 : if ( p_function_type_table != NULL )
41550 : {
41551 0 : if ( p_function_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41552 : {
41553 0 : if ( p_function_type_table->isInMemoryPool() == false )
41554 : {
41555 0 : std::cout << "SgFunctionTypeTable :: ";
41556 0 : std::cout << " p_function_type_table is not in memory pool of ";
41557 0 : std::cout << p_function_type_table->class_name() << std::endl;
41558 : }
41559 : }
41560 : else
41561 : {
41562 0 : std::cout << "SgFunctionTypeTable :: " << std::flush;
41563 0 : std::cout << "SgSymbolTable* p_function_type_table = " << p_function_type_table << " --> " << std::flush;
41564 0 : std::cout << " not valid " << std::endl;
41565 : }
41566 : }
41567 :
41568 0 : if ( p_numeric_label != NULL )
41569 : {
41570 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41571 : {
41572 0 : if ( p_numeric_label->isInMemoryPool() == false )
41573 : {
41574 0 : std::cout << "SgFunctionTypeTable :: ";
41575 0 : std::cout << " p_numeric_label is not in memory pool of ";
41576 0 : std::cout << p_numeric_label->class_name() << std::endl;
41577 : }
41578 : }
41579 : else
41580 : {
41581 0 : std::cout << "SgFunctionTypeTable :: " << std::flush;
41582 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
41583 0 : std::cout << " not valid " << std::endl;
41584 : }
41585 : }
41586 :
41587 0 : if ( p_startOfConstruct != NULL )
41588 : {
41589 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41590 : {
41591 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
41592 : {
41593 0 : std::cout << "SgFunctionTypeTable :: ";
41594 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
41595 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
41596 : }
41597 : }
41598 : else
41599 : {
41600 0 : std::cout << "SgFunctionTypeTable :: " << std::flush;
41601 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
41602 0 : std::cout << " not valid " << std::endl;
41603 : }
41604 : }
41605 :
41606 0 : if ( p_endOfConstruct != NULL )
41607 : {
41608 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41609 : {
41610 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
41611 : {
41612 0 : std::cout << "SgFunctionTypeTable :: ";
41613 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
41614 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
41615 : }
41616 : }
41617 : else
41618 : {
41619 0 : std::cout << "SgFunctionTypeTable :: " << std::flush;
41620 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
41621 0 : std::cout << " not valid " << std::endl;
41622 : }
41623 : }
41624 :
41625 0 : if ( p_parent != NULL )
41626 : {
41627 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41628 : {
41629 0 : if ( p_parent->isInMemoryPool() == false )
41630 : {
41631 0 : std::cout << "SgFunctionTypeTable :: ";
41632 0 : std::cout << " p_parent is not in memory pool of ";
41633 0 : std::cout << p_parent->class_name() << std::endl;
41634 : }
41635 : }
41636 : else
41637 : {
41638 0 : std::cout << "SgFunctionTypeTable :: " << std::flush;
41639 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
41640 0 : std::cout << " not valid " << std::endl;
41641 : }
41642 : }
41643 :
41644 :
41645 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
41646 :
41647 0 : }
41648 :
41649 :
41650 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
41651 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
41652 : bool
41653 0 : SgFunctionTypeTable::isInMemoryPool ()
41654 : {
41655 0 : typedef unsigned char* TestType;
41656 :
41657 0 : bool found = false;
41658 :
41659 0 : ROSE_ASSERT(this != NULL);
41660 :
41661 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
41662 :
41663 0 : TestType tested = (TestType) ( this ) ;
41664 :
41665 0 : std::vector < unsigned char* > :: const_iterator block = SgFunctionTypeTable::pools.begin();
41666 :
41667 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
41668 : // while (found == false && block < Memory_Block_List.end())
41669 0 : while ( (found == false) && (block != SgFunctionTypeTable::pools.end()) )
41670 : {
41671 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFunctionTypeTable::pool_size * sizeof(SgFunctionTypeTable) ) ) ;
41672 0 : ++block;
41673 : }
41674 :
41675 : // Special handling for static data
41676 :
41677 :
41678 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
41679 0 : ROSE_ASSERT(found == true);
41680 :
41681 0 : return found;
41682 : }
41683 : /* #line 41684 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
41684 :
41685 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
41686 :
41687 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
41688 :
41689 : /* #line 41690 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
41690 :
41691 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
41692 :
41693 : void
41694 0 : SgDeclarationStatement::checkDataMemberPointersIfInMemoryPool()
41695 : {
41696 : // ------------ checking pointers of SgDeclarationStatement -------------------
41697 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41698 :
41699 0 : if ( p_definingDeclaration != NULL )
41700 : {
41701 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41702 : {
41703 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
41704 : {
41705 0 : std::cout << "SgDeclarationStatement :: ";
41706 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
41707 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
41708 : }
41709 : }
41710 : else
41711 : {
41712 0 : std::cout << "SgDeclarationStatement :: " << std::flush;
41713 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
41714 0 : std::cout << " not valid " << std::endl;
41715 : }
41716 : }
41717 :
41718 0 : if ( p_firstNondefiningDeclaration != NULL )
41719 : {
41720 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41721 : {
41722 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
41723 : {
41724 0 : std::cout << "SgDeclarationStatement :: ";
41725 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
41726 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
41727 : }
41728 : }
41729 : else
41730 : {
41731 0 : std::cout << "SgDeclarationStatement :: " << std::flush;
41732 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
41733 0 : std::cout << " not valid " << std::endl;
41734 : }
41735 : }
41736 :
41737 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
41738 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
41739 : {
41740 0 : if ( (*i_qualifiedNameList) != NULL )
41741 : {
41742 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41743 : {
41744 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
41745 : {
41746 0 : std::cout << "SgDeclarationStatement :: ";
41747 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
41748 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
41749 : }
41750 : }
41751 : else
41752 : {
41753 0 : std::cout << "SgDeclarationStatement :: " << std::flush;
41754 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
41755 0 : std::cout << " entry not valid " << std::endl;
41756 : }
41757 : }
41758 : else
41759 : {
41760 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
41761 : }
41762 : }
41763 :
41764 0 : if ( p_declarationScope != NULL )
41765 : {
41766 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41767 : {
41768 0 : if ( p_declarationScope->isInMemoryPool() == false )
41769 : {
41770 0 : std::cout << "SgDeclarationStatement :: ";
41771 0 : std::cout << " p_declarationScope is not in memory pool of ";
41772 0 : std::cout << p_declarationScope->class_name() << std::endl;
41773 : }
41774 : }
41775 : else
41776 : {
41777 0 : std::cout << "SgDeclarationStatement :: " << std::flush;
41778 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
41779 0 : std::cout << " not valid " << std::endl;
41780 : }
41781 : }
41782 :
41783 0 : if ( p_numeric_label != NULL )
41784 : {
41785 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41786 : {
41787 0 : if ( p_numeric_label->isInMemoryPool() == false )
41788 : {
41789 0 : std::cout << "SgDeclarationStatement :: ";
41790 0 : std::cout << " p_numeric_label is not in memory pool of ";
41791 0 : std::cout << p_numeric_label->class_name() << std::endl;
41792 : }
41793 : }
41794 : else
41795 : {
41796 0 : std::cout << "SgDeclarationStatement :: " << std::flush;
41797 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
41798 0 : std::cout << " not valid " << std::endl;
41799 : }
41800 : }
41801 :
41802 0 : if ( p_startOfConstruct != NULL )
41803 : {
41804 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41805 : {
41806 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
41807 : {
41808 0 : std::cout << "SgDeclarationStatement :: ";
41809 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
41810 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
41811 : }
41812 : }
41813 : else
41814 : {
41815 0 : std::cout << "SgDeclarationStatement :: " << std::flush;
41816 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
41817 0 : std::cout << " not valid " << std::endl;
41818 : }
41819 : }
41820 :
41821 0 : if ( p_endOfConstruct != NULL )
41822 : {
41823 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41824 : {
41825 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
41826 : {
41827 0 : std::cout << "SgDeclarationStatement :: ";
41828 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
41829 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
41830 : }
41831 : }
41832 : else
41833 : {
41834 0 : std::cout << "SgDeclarationStatement :: " << std::flush;
41835 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
41836 0 : std::cout << " not valid " << std::endl;
41837 : }
41838 : }
41839 :
41840 0 : if ( p_parent != NULL )
41841 : {
41842 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41843 : {
41844 0 : if ( p_parent->isInMemoryPool() == false )
41845 : {
41846 0 : std::cout << "SgDeclarationStatement :: ";
41847 0 : std::cout << " p_parent is not in memory pool of ";
41848 0 : std::cout << p_parent->class_name() << std::endl;
41849 : }
41850 : }
41851 : else
41852 : {
41853 0 : std::cout << "SgDeclarationStatement :: " << std::flush;
41854 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
41855 0 : std::cout << " not valid " << std::endl;
41856 : }
41857 : }
41858 :
41859 :
41860 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
41861 :
41862 0 : }
41863 :
41864 :
41865 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
41866 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
41867 : bool
41868 0 : SgDeclarationStatement::isInMemoryPool ()
41869 : {
41870 0 : typedef unsigned char* TestType;
41871 :
41872 0 : bool found = false;
41873 :
41874 0 : ROSE_ASSERT(this != NULL);
41875 :
41876 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
41877 :
41878 0 : TestType tested = (TestType) ( this ) ;
41879 :
41880 0 : std::vector < unsigned char* > :: const_iterator block = SgDeclarationStatement::pools.begin();
41881 :
41882 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
41883 : // while (found == false && block < Memory_Block_List.end())
41884 0 : while ( (found == false) && (block != SgDeclarationStatement::pools.end()) )
41885 : {
41886 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDeclarationStatement::pool_size * sizeof(SgDeclarationStatement) ) ) ;
41887 0 : ++block;
41888 : }
41889 :
41890 : // Special handling for static data
41891 :
41892 :
41893 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
41894 0 : ROSE_ASSERT(found == true);
41895 :
41896 0 : return found;
41897 : }
41898 : /* #line 41899 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
41899 :
41900 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
41901 :
41902 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
41903 :
41904 : /* #line 41905 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
41905 :
41906 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
41907 :
41908 : void
41909 0 : SgFunctionParameterList::checkDataMemberPointersIfInMemoryPool()
41910 : {
41911 : // ------------ checking pointers of SgFunctionParameterList -------------------
41912 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41913 :
41914 0 : SgInitializedNamePtrList::iterator i_args = p_args.begin() ;
41915 0 : for ( ; i_args != p_args.end(); ++i_args )
41916 : {
41917 0 : if ( (*i_args) != NULL )
41918 : {
41919 0 : if ( (*i_args)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41920 : {
41921 0 : if ( (*i_args)->isInMemoryPool() == false )
41922 : {
41923 0 : std::cout << "SgFunctionParameterList :: ";
41924 0 : std::cout << " p_args ( list of poitners to IR nodes ), entry is not in memory pool of ";
41925 0 : std::cout << (*i_args)->class_name() << std::endl;
41926 : }
41927 : }
41928 : else
41929 : {
41930 0 : std::cout << "SgFunctionParameterList :: " << std::flush;
41931 0 : std::cout << "SgInitializedNamePtrList p_args --> " << std::flush;
41932 0 : std::cout << " entry not valid " << std::endl;
41933 : }
41934 : }
41935 : else
41936 : {
41937 0 : std::cout << "SgInitializedNamePtrList p_args --> NULL " << std::endl;
41938 : }
41939 : }
41940 :
41941 0 : if ( p_definingDeclaration != NULL )
41942 : {
41943 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41944 : {
41945 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
41946 : {
41947 0 : std::cout << "SgFunctionParameterList :: ";
41948 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
41949 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
41950 : }
41951 : }
41952 : else
41953 : {
41954 0 : std::cout << "SgFunctionParameterList :: " << std::flush;
41955 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
41956 0 : std::cout << " not valid " << std::endl;
41957 : }
41958 : }
41959 :
41960 0 : if ( p_firstNondefiningDeclaration != NULL )
41961 : {
41962 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41963 : {
41964 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
41965 : {
41966 0 : std::cout << "SgFunctionParameterList :: ";
41967 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
41968 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
41969 : }
41970 : }
41971 : else
41972 : {
41973 0 : std::cout << "SgFunctionParameterList :: " << std::flush;
41974 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
41975 0 : std::cout << " not valid " << std::endl;
41976 : }
41977 : }
41978 :
41979 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
41980 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
41981 : {
41982 0 : if ( (*i_qualifiedNameList) != NULL )
41983 : {
41984 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
41985 : {
41986 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
41987 : {
41988 0 : std::cout << "SgFunctionParameterList :: ";
41989 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
41990 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
41991 : }
41992 : }
41993 : else
41994 : {
41995 0 : std::cout << "SgFunctionParameterList :: " << std::flush;
41996 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
41997 0 : std::cout << " entry not valid " << std::endl;
41998 : }
41999 : }
42000 : else
42001 : {
42002 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
42003 : }
42004 : }
42005 :
42006 0 : if ( p_declarationScope != NULL )
42007 : {
42008 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42009 : {
42010 0 : if ( p_declarationScope->isInMemoryPool() == false )
42011 : {
42012 0 : std::cout << "SgFunctionParameterList :: ";
42013 0 : std::cout << " p_declarationScope is not in memory pool of ";
42014 0 : std::cout << p_declarationScope->class_name() << std::endl;
42015 : }
42016 : }
42017 : else
42018 : {
42019 0 : std::cout << "SgFunctionParameterList :: " << std::flush;
42020 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
42021 0 : std::cout << " not valid " << std::endl;
42022 : }
42023 : }
42024 :
42025 0 : if ( p_numeric_label != NULL )
42026 : {
42027 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42028 : {
42029 0 : if ( p_numeric_label->isInMemoryPool() == false )
42030 : {
42031 0 : std::cout << "SgFunctionParameterList :: ";
42032 0 : std::cout << " p_numeric_label is not in memory pool of ";
42033 0 : std::cout << p_numeric_label->class_name() << std::endl;
42034 : }
42035 : }
42036 : else
42037 : {
42038 0 : std::cout << "SgFunctionParameterList :: " << std::flush;
42039 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
42040 0 : std::cout << " not valid " << std::endl;
42041 : }
42042 : }
42043 :
42044 0 : if ( p_startOfConstruct != NULL )
42045 : {
42046 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42047 : {
42048 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
42049 : {
42050 0 : std::cout << "SgFunctionParameterList :: ";
42051 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
42052 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
42053 : }
42054 : }
42055 : else
42056 : {
42057 0 : std::cout << "SgFunctionParameterList :: " << std::flush;
42058 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
42059 0 : std::cout << " not valid " << std::endl;
42060 : }
42061 : }
42062 :
42063 0 : if ( p_endOfConstruct != NULL )
42064 : {
42065 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42066 : {
42067 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
42068 : {
42069 0 : std::cout << "SgFunctionParameterList :: ";
42070 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
42071 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
42072 : }
42073 : }
42074 : else
42075 : {
42076 0 : std::cout << "SgFunctionParameterList :: " << std::flush;
42077 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
42078 0 : std::cout << " not valid " << std::endl;
42079 : }
42080 : }
42081 :
42082 0 : if ( p_parent != NULL )
42083 : {
42084 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42085 : {
42086 0 : if ( p_parent->isInMemoryPool() == false )
42087 : {
42088 0 : std::cout << "SgFunctionParameterList :: ";
42089 0 : std::cout << " p_parent is not in memory pool of ";
42090 0 : std::cout << p_parent->class_name() << std::endl;
42091 : }
42092 : }
42093 : else
42094 : {
42095 0 : std::cout << "SgFunctionParameterList :: " << std::flush;
42096 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
42097 0 : std::cout << " not valid " << std::endl;
42098 : }
42099 : }
42100 :
42101 :
42102 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
42103 :
42104 0 : }
42105 :
42106 :
42107 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
42108 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
42109 : bool
42110 0 : SgFunctionParameterList::isInMemoryPool ()
42111 : {
42112 0 : typedef unsigned char* TestType;
42113 :
42114 0 : bool found = false;
42115 :
42116 0 : ROSE_ASSERT(this != NULL);
42117 :
42118 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
42119 :
42120 0 : TestType tested = (TestType) ( this ) ;
42121 :
42122 0 : std::vector < unsigned char* > :: const_iterator block = SgFunctionParameterList::pools.begin();
42123 :
42124 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
42125 : // while (found == false && block < Memory_Block_List.end())
42126 0 : while ( (found == false) && (block != SgFunctionParameterList::pools.end()) )
42127 : {
42128 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFunctionParameterList::pool_size * sizeof(SgFunctionParameterList) ) ) ;
42129 0 : ++block;
42130 : }
42131 :
42132 : // Special handling for static data
42133 :
42134 :
42135 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
42136 0 : ROSE_ASSERT(found == true);
42137 :
42138 0 : return found;
42139 : }
42140 : /* #line 42141 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
42141 :
42142 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
42143 :
42144 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
42145 :
42146 : /* #line 42147 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
42147 :
42148 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
42149 :
42150 : void
42151 0 : SgVariableDeclaration::checkDataMemberPointersIfInMemoryPool()
42152 : {
42153 : // ------------ checking pointers of SgVariableDeclaration -------------------
42154 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42155 :
42156 0 : if ( p_baseTypeDefiningDeclaration != NULL )
42157 : {
42158 0 : if ( p_baseTypeDefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42159 : {
42160 0 : if ( p_baseTypeDefiningDeclaration->isInMemoryPool() == false )
42161 : {
42162 0 : std::cout << "SgVariableDeclaration :: ";
42163 0 : std::cout << " p_baseTypeDefiningDeclaration is not in memory pool of ";
42164 0 : std::cout << p_baseTypeDefiningDeclaration->class_name() << std::endl;
42165 : }
42166 : }
42167 : else
42168 : {
42169 0 : std::cout << "SgVariableDeclaration :: " << std::flush;
42170 0 : std::cout << "SgDeclarationStatement* p_baseTypeDefiningDeclaration = " << p_baseTypeDefiningDeclaration << " --> " << std::flush;
42171 0 : std::cout << " not valid " << std::endl;
42172 : }
42173 : }
42174 :
42175 0 : SgInitializedNamePtrList::iterator i_variables = p_variables.begin() ;
42176 0 : for ( ; i_variables != p_variables.end(); ++i_variables )
42177 : {
42178 0 : if ( (*i_variables) != NULL )
42179 : {
42180 0 : if ( (*i_variables)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42181 : {
42182 0 : if ( (*i_variables)->isInMemoryPool() == false )
42183 : {
42184 0 : std::cout << "SgVariableDeclaration :: ";
42185 0 : std::cout << " p_variables ( list of poitners to IR nodes ), entry is not in memory pool of ";
42186 0 : std::cout << (*i_variables)->class_name() << std::endl;
42187 : }
42188 : }
42189 : else
42190 : {
42191 0 : std::cout << "SgVariableDeclaration :: " << std::flush;
42192 0 : std::cout << "SgInitializedNamePtrList p_variables --> " << std::flush;
42193 0 : std::cout << " entry not valid " << std::endl;
42194 : }
42195 : }
42196 : else
42197 : {
42198 0 : std::cout << "SgInitializedNamePtrList p_variables --> NULL " << std::endl;
42199 : }
42200 : }
42201 :
42202 0 : if ( p_definingDeclaration != NULL )
42203 : {
42204 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42205 : {
42206 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
42207 : {
42208 0 : std::cout << "SgVariableDeclaration :: ";
42209 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
42210 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
42211 : }
42212 : }
42213 : else
42214 : {
42215 0 : std::cout << "SgVariableDeclaration :: " << std::flush;
42216 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
42217 0 : std::cout << " not valid " << std::endl;
42218 : }
42219 : }
42220 :
42221 0 : if ( p_firstNondefiningDeclaration != NULL )
42222 : {
42223 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42224 : {
42225 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
42226 : {
42227 0 : std::cout << "SgVariableDeclaration :: ";
42228 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
42229 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
42230 : }
42231 : }
42232 : else
42233 : {
42234 0 : std::cout << "SgVariableDeclaration :: " << std::flush;
42235 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
42236 0 : std::cout << " not valid " << std::endl;
42237 : }
42238 : }
42239 :
42240 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
42241 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
42242 : {
42243 0 : if ( (*i_qualifiedNameList) != NULL )
42244 : {
42245 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42246 : {
42247 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
42248 : {
42249 0 : std::cout << "SgVariableDeclaration :: ";
42250 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
42251 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
42252 : }
42253 : }
42254 : else
42255 : {
42256 0 : std::cout << "SgVariableDeclaration :: " << std::flush;
42257 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
42258 0 : std::cout << " entry not valid " << std::endl;
42259 : }
42260 : }
42261 : else
42262 : {
42263 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
42264 : }
42265 : }
42266 :
42267 0 : if ( p_declarationScope != NULL )
42268 : {
42269 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42270 : {
42271 0 : if ( p_declarationScope->isInMemoryPool() == false )
42272 : {
42273 0 : std::cout << "SgVariableDeclaration :: ";
42274 0 : std::cout << " p_declarationScope is not in memory pool of ";
42275 0 : std::cout << p_declarationScope->class_name() << std::endl;
42276 : }
42277 : }
42278 : else
42279 : {
42280 0 : std::cout << "SgVariableDeclaration :: " << std::flush;
42281 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
42282 0 : std::cout << " not valid " << std::endl;
42283 : }
42284 : }
42285 :
42286 0 : if ( p_numeric_label != NULL )
42287 : {
42288 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42289 : {
42290 0 : if ( p_numeric_label->isInMemoryPool() == false )
42291 : {
42292 0 : std::cout << "SgVariableDeclaration :: ";
42293 0 : std::cout << " p_numeric_label is not in memory pool of ";
42294 0 : std::cout << p_numeric_label->class_name() << std::endl;
42295 : }
42296 : }
42297 : else
42298 : {
42299 0 : std::cout << "SgVariableDeclaration :: " << std::flush;
42300 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
42301 0 : std::cout << " not valid " << std::endl;
42302 : }
42303 : }
42304 :
42305 0 : if ( p_startOfConstruct != NULL )
42306 : {
42307 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42308 : {
42309 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
42310 : {
42311 0 : std::cout << "SgVariableDeclaration :: ";
42312 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
42313 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
42314 : }
42315 : }
42316 : else
42317 : {
42318 0 : std::cout << "SgVariableDeclaration :: " << std::flush;
42319 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
42320 0 : std::cout << " not valid " << std::endl;
42321 : }
42322 : }
42323 :
42324 0 : if ( p_endOfConstruct != NULL )
42325 : {
42326 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42327 : {
42328 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
42329 : {
42330 0 : std::cout << "SgVariableDeclaration :: ";
42331 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
42332 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
42333 : }
42334 : }
42335 : else
42336 : {
42337 0 : std::cout << "SgVariableDeclaration :: " << std::flush;
42338 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
42339 0 : std::cout << " not valid " << std::endl;
42340 : }
42341 : }
42342 :
42343 0 : if ( p_parent != NULL )
42344 : {
42345 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42346 : {
42347 0 : if ( p_parent->isInMemoryPool() == false )
42348 : {
42349 0 : std::cout << "SgVariableDeclaration :: ";
42350 0 : std::cout << " p_parent is not in memory pool of ";
42351 0 : std::cout << p_parent->class_name() << std::endl;
42352 : }
42353 : }
42354 : else
42355 : {
42356 0 : std::cout << "SgVariableDeclaration :: " << std::flush;
42357 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
42358 0 : std::cout << " not valid " << std::endl;
42359 : }
42360 : }
42361 :
42362 :
42363 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
42364 :
42365 0 : }
42366 :
42367 :
42368 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
42369 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
42370 : bool
42371 0 : SgVariableDeclaration::isInMemoryPool ()
42372 : {
42373 0 : typedef unsigned char* TestType;
42374 :
42375 0 : bool found = false;
42376 :
42377 0 : ROSE_ASSERT(this != NULL);
42378 :
42379 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
42380 :
42381 0 : TestType tested = (TestType) ( this ) ;
42382 :
42383 0 : std::vector < unsigned char* > :: const_iterator block = SgVariableDeclaration::pools.begin();
42384 :
42385 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
42386 : // while (found == false && block < Memory_Block_List.end())
42387 0 : while ( (found == false) && (block != SgVariableDeclaration::pools.end()) )
42388 : {
42389 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgVariableDeclaration::pool_size * sizeof(SgVariableDeclaration) ) ) ;
42390 0 : ++block;
42391 : }
42392 :
42393 : // Special handling for static data
42394 :
42395 :
42396 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
42397 0 : ROSE_ASSERT(found == true);
42398 :
42399 0 : return found;
42400 : }
42401 : /* #line 42402 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
42402 :
42403 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
42404 :
42405 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
42406 :
42407 : /* #line 42408 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
42408 :
42409 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
42410 :
42411 : void
42412 0 : SgTemplateVariableDeclaration::checkDataMemberPointersIfInMemoryPool()
42413 : {
42414 : // ------------ checking pointers of SgTemplateVariableDeclaration -------------------
42415 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42416 :
42417 0 : SgTemplateParameterPtrList::iterator i_templateParameters = p_templateParameters.begin() ;
42418 0 : for ( ; i_templateParameters != p_templateParameters.end(); ++i_templateParameters )
42419 : {
42420 0 : if ( (*i_templateParameters) != NULL )
42421 : {
42422 0 : if ( (*i_templateParameters)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42423 : {
42424 0 : if ( (*i_templateParameters)->isInMemoryPool() == false )
42425 : {
42426 0 : std::cout << "SgTemplateVariableDeclaration :: ";
42427 0 : std::cout << " p_templateParameters ( list of poitners to IR nodes ), entry is not in memory pool of ";
42428 0 : std::cout << (*i_templateParameters)->class_name() << std::endl;
42429 : }
42430 : }
42431 : else
42432 : {
42433 0 : std::cout << "SgTemplateVariableDeclaration :: " << std::flush;
42434 0 : std::cout << "SgTemplateParameterPtrList p_templateParameters --> " << std::flush;
42435 0 : std::cout << " entry not valid " << std::endl;
42436 : }
42437 : }
42438 : else
42439 : {
42440 0 : std::cout << "SgTemplateParameterPtrList p_templateParameters --> NULL " << std::endl;
42441 : }
42442 : }
42443 :
42444 0 : SgTemplateArgumentPtrList::iterator i_templateSpecializationArguments = p_templateSpecializationArguments.begin() ;
42445 0 : for ( ; i_templateSpecializationArguments != p_templateSpecializationArguments.end(); ++i_templateSpecializationArguments )
42446 : {
42447 0 : if ( (*i_templateSpecializationArguments) != NULL )
42448 : {
42449 0 : if ( (*i_templateSpecializationArguments)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42450 : {
42451 0 : if ( (*i_templateSpecializationArguments)->isInMemoryPool() == false )
42452 : {
42453 0 : std::cout << "SgTemplateVariableDeclaration :: ";
42454 0 : std::cout << " p_templateSpecializationArguments ( list of poitners to IR nodes ), entry is not in memory pool of ";
42455 0 : std::cout << (*i_templateSpecializationArguments)->class_name() << std::endl;
42456 : }
42457 : }
42458 : else
42459 : {
42460 0 : std::cout << "SgTemplateVariableDeclaration :: " << std::flush;
42461 0 : std::cout << "SgTemplateArgumentPtrList p_templateSpecializationArguments --> " << std::flush;
42462 0 : std::cout << " entry not valid " << std::endl;
42463 : }
42464 : }
42465 : else
42466 : {
42467 0 : std::cout << "SgTemplateArgumentPtrList p_templateSpecializationArguments --> NULL " << std::endl;
42468 : }
42469 : }
42470 :
42471 0 : if ( p_nonreal_decl_scope != NULL )
42472 : {
42473 0 : if ( p_nonreal_decl_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42474 : {
42475 0 : if ( p_nonreal_decl_scope->isInMemoryPool() == false )
42476 : {
42477 0 : std::cout << "SgTemplateVariableDeclaration :: ";
42478 0 : std::cout << " p_nonreal_decl_scope is not in memory pool of ";
42479 0 : std::cout << p_nonreal_decl_scope->class_name() << std::endl;
42480 : }
42481 : }
42482 : else
42483 : {
42484 0 : std::cout << "SgTemplateVariableDeclaration :: " << std::flush;
42485 0 : std::cout << "SgDeclarationScope* p_nonreal_decl_scope = " << p_nonreal_decl_scope << " --> " << std::flush;
42486 0 : std::cout << " not valid " << std::endl;
42487 : }
42488 : }
42489 :
42490 0 : if ( p_baseTypeDefiningDeclaration != NULL )
42491 : {
42492 0 : if ( p_baseTypeDefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42493 : {
42494 0 : if ( p_baseTypeDefiningDeclaration->isInMemoryPool() == false )
42495 : {
42496 0 : std::cout << "SgTemplateVariableDeclaration :: ";
42497 0 : std::cout << " p_baseTypeDefiningDeclaration is not in memory pool of ";
42498 0 : std::cout << p_baseTypeDefiningDeclaration->class_name() << std::endl;
42499 : }
42500 : }
42501 : else
42502 : {
42503 0 : std::cout << "SgTemplateVariableDeclaration :: " << std::flush;
42504 0 : std::cout << "SgDeclarationStatement* p_baseTypeDefiningDeclaration = " << p_baseTypeDefiningDeclaration << " --> " << std::flush;
42505 0 : std::cout << " not valid " << std::endl;
42506 : }
42507 : }
42508 :
42509 0 : SgInitializedNamePtrList::iterator i_variables = p_variables.begin() ;
42510 0 : for ( ; i_variables != p_variables.end(); ++i_variables )
42511 : {
42512 0 : if ( (*i_variables) != NULL )
42513 : {
42514 0 : if ( (*i_variables)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42515 : {
42516 0 : if ( (*i_variables)->isInMemoryPool() == false )
42517 : {
42518 0 : std::cout << "SgTemplateVariableDeclaration :: ";
42519 0 : std::cout << " p_variables ( list of poitners to IR nodes ), entry is not in memory pool of ";
42520 0 : std::cout << (*i_variables)->class_name() << std::endl;
42521 : }
42522 : }
42523 : else
42524 : {
42525 0 : std::cout << "SgTemplateVariableDeclaration :: " << std::flush;
42526 0 : std::cout << "SgInitializedNamePtrList p_variables --> " << std::flush;
42527 0 : std::cout << " entry not valid " << std::endl;
42528 : }
42529 : }
42530 : else
42531 : {
42532 0 : std::cout << "SgInitializedNamePtrList p_variables --> NULL " << std::endl;
42533 : }
42534 : }
42535 :
42536 0 : if ( p_definingDeclaration != NULL )
42537 : {
42538 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42539 : {
42540 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
42541 : {
42542 0 : std::cout << "SgTemplateVariableDeclaration :: ";
42543 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
42544 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
42545 : }
42546 : }
42547 : else
42548 : {
42549 0 : std::cout << "SgTemplateVariableDeclaration :: " << std::flush;
42550 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
42551 0 : std::cout << " not valid " << std::endl;
42552 : }
42553 : }
42554 :
42555 0 : if ( p_firstNondefiningDeclaration != NULL )
42556 : {
42557 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42558 : {
42559 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
42560 : {
42561 0 : std::cout << "SgTemplateVariableDeclaration :: ";
42562 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
42563 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
42564 : }
42565 : }
42566 : else
42567 : {
42568 0 : std::cout << "SgTemplateVariableDeclaration :: " << std::flush;
42569 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
42570 0 : std::cout << " not valid " << std::endl;
42571 : }
42572 : }
42573 :
42574 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
42575 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
42576 : {
42577 0 : if ( (*i_qualifiedNameList) != NULL )
42578 : {
42579 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42580 : {
42581 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
42582 : {
42583 0 : std::cout << "SgTemplateVariableDeclaration :: ";
42584 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
42585 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
42586 : }
42587 : }
42588 : else
42589 : {
42590 0 : std::cout << "SgTemplateVariableDeclaration :: " << std::flush;
42591 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
42592 0 : std::cout << " entry not valid " << std::endl;
42593 : }
42594 : }
42595 : else
42596 : {
42597 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
42598 : }
42599 : }
42600 :
42601 0 : if ( p_declarationScope != NULL )
42602 : {
42603 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42604 : {
42605 0 : if ( p_declarationScope->isInMemoryPool() == false )
42606 : {
42607 0 : std::cout << "SgTemplateVariableDeclaration :: ";
42608 0 : std::cout << " p_declarationScope is not in memory pool of ";
42609 0 : std::cout << p_declarationScope->class_name() << std::endl;
42610 : }
42611 : }
42612 : else
42613 : {
42614 0 : std::cout << "SgTemplateVariableDeclaration :: " << std::flush;
42615 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
42616 0 : std::cout << " not valid " << std::endl;
42617 : }
42618 : }
42619 :
42620 0 : if ( p_numeric_label != NULL )
42621 : {
42622 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42623 : {
42624 0 : if ( p_numeric_label->isInMemoryPool() == false )
42625 : {
42626 0 : std::cout << "SgTemplateVariableDeclaration :: ";
42627 0 : std::cout << " p_numeric_label is not in memory pool of ";
42628 0 : std::cout << p_numeric_label->class_name() << std::endl;
42629 : }
42630 : }
42631 : else
42632 : {
42633 0 : std::cout << "SgTemplateVariableDeclaration :: " << std::flush;
42634 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
42635 0 : std::cout << " not valid " << std::endl;
42636 : }
42637 : }
42638 :
42639 0 : if ( p_startOfConstruct != NULL )
42640 : {
42641 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42642 : {
42643 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
42644 : {
42645 0 : std::cout << "SgTemplateVariableDeclaration :: ";
42646 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
42647 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
42648 : }
42649 : }
42650 : else
42651 : {
42652 0 : std::cout << "SgTemplateVariableDeclaration :: " << std::flush;
42653 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
42654 0 : std::cout << " not valid " << std::endl;
42655 : }
42656 : }
42657 :
42658 0 : if ( p_endOfConstruct != NULL )
42659 : {
42660 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42661 : {
42662 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
42663 : {
42664 0 : std::cout << "SgTemplateVariableDeclaration :: ";
42665 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
42666 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
42667 : }
42668 : }
42669 : else
42670 : {
42671 0 : std::cout << "SgTemplateVariableDeclaration :: " << std::flush;
42672 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
42673 0 : std::cout << " not valid " << std::endl;
42674 : }
42675 : }
42676 :
42677 0 : if ( p_parent != NULL )
42678 : {
42679 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42680 : {
42681 0 : if ( p_parent->isInMemoryPool() == false )
42682 : {
42683 0 : std::cout << "SgTemplateVariableDeclaration :: ";
42684 0 : std::cout << " p_parent is not in memory pool of ";
42685 0 : std::cout << p_parent->class_name() << std::endl;
42686 : }
42687 : }
42688 : else
42689 : {
42690 0 : std::cout << "SgTemplateVariableDeclaration :: " << std::flush;
42691 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
42692 0 : std::cout << " not valid " << std::endl;
42693 : }
42694 : }
42695 :
42696 :
42697 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
42698 :
42699 0 : }
42700 :
42701 :
42702 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
42703 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
42704 : bool
42705 0 : SgTemplateVariableDeclaration::isInMemoryPool ()
42706 : {
42707 0 : typedef unsigned char* TestType;
42708 :
42709 0 : bool found = false;
42710 :
42711 0 : ROSE_ASSERT(this != NULL);
42712 :
42713 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
42714 :
42715 0 : TestType tested = (TestType) ( this ) ;
42716 :
42717 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateVariableDeclaration::pools.begin();
42718 :
42719 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
42720 : // while (found == false && block < Memory_Block_List.end())
42721 0 : while ( (found == false) && (block != SgTemplateVariableDeclaration::pools.end()) )
42722 : {
42723 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateVariableDeclaration::pool_size * sizeof(SgTemplateVariableDeclaration) ) ) ;
42724 0 : ++block;
42725 : }
42726 :
42727 : // Special handling for static data
42728 :
42729 :
42730 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
42731 0 : ROSE_ASSERT(found == true);
42732 :
42733 0 : return found;
42734 : }
42735 : /* #line 42736 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
42736 :
42737 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
42738 :
42739 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
42740 :
42741 : /* #line 42742 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
42742 :
42743 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
42744 :
42745 : void
42746 0 : SgVariableDefinition::checkDataMemberPointersIfInMemoryPool()
42747 : {
42748 : // ------------ checking pointers of SgVariableDefinition -------------------
42749 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42750 :
42751 0 : if ( p_vardefn != NULL )
42752 : {
42753 0 : if ( p_vardefn->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42754 : {
42755 0 : if ( p_vardefn->isInMemoryPool() == false )
42756 : {
42757 0 : std::cout << "SgVariableDefinition :: ";
42758 0 : std::cout << " p_vardefn is not in memory pool of ";
42759 0 : std::cout << p_vardefn->class_name() << std::endl;
42760 : }
42761 : }
42762 : else
42763 : {
42764 0 : std::cout << "SgVariableDefinition :: " << std::flush;
42765 0 : std::cout << "SgInitializedName* p_vardefn = " << p_vardefn << " --> " << std::flush;
42766 0 : std::cout << " not valid " << std::endl;
42767 : }
42768 : }
42769 :
42770 0 : if ( p_bitfield != NULL )
42771 : {
42772 0 : if ( p_bitfield->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42773 : {
42774 0 : if ( p_bitfield->isInMemoryPool() == false )
42775 : {
42776 0 : std::cout << "SgVariableDefinition :: ";
42777 0 : std::cout << " p_bitfield is not in memory pool of ";
42778 0 : std::cout << p_bitfield->class_name() << std::endl;
42779 : }
42780 : }
42781 : else
42782 : {
42783 0 : std::cout << "SgVariableDefinition :: " << std::flush;
42784 0 : std::cout << "SgExpression* p_bitfield = " << p_bitfield << " --> " << std::flush;
42785 0 : std::cout << " not valid " << std::endl;
42786 : }
42787 : }
42788 :
42789 0 : if ( p_definingDeclaration != NULL )
42790 : {
42791 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42792 : {
42793 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
42794 : {
42795 0 : std::cout << "SgVariableDefinition :: ";
42796 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
42797 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
42798 : }
42799 : }
42800 : else
42801 : {
42802 0 : std::cout << "SgVariableDefinition :: " << std::flush;
42803 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
42804 0 : std::cout << " not valid " << std::endl;
42805 : }
42806 : }
42807 :
42808 0 : if ( p_firstNondefiningDeclaration != NULL )
42809 : {
42810 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42811 : {
42812 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
42813 : {
42814 0 : std::cout << "SgVariableDefinition :: ";
42815 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
42816 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
42817 : }
42818 : }
42819 : else
42820 : {
42821 0 : std::cout << "SgVariableDefinition :: " << std::flush;
42822 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
42823 0 : std::cout << " not valid " << std::endl;
42824 : }
42825 : }
42826 :
42827 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
42828 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
42829 : {
42830 0 : if ( (*i_qualifiedNameList) != NULL )
42831 : {
42832 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42833 : {
42834 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
42835 : {
42836 0 : std::cout << "SgVariableDefinition :: ";
42837 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
42838 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
42839 : }
42840 : }
42841 : else
42842 : {
42843 0 : std::cout << "SgVariableDefinition :: " << std::flush;
42844 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
42845 0 : std::cout << " entry not valid " << std::endl;
42846 : }
42847 : }
42848 : else
42849 : {
42850 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
42851 : }
42852 : }
42853 :
42854 0 : if ( p_declarationScope != NULL )
42855 : {
42856 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42857 : {
42858 0 : if ( p_declarationScope->isInMemoryPool() == false )
42859 : {
42860 0 : std::cout << "SgVariableDefinition :: ";
42861 0 : std::cout << " p_declarationScope is not in memory pool of ";
42862 0 : std::cout << p_declarationScope->class_name() << std::endl;
42863 : }
42864 : }
42865 : else
42866 : {
42867 0 : std::cout << "SgVariableDefinition :: " << std::flush;
42868 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
42869 0 : std::cout << " not valid " << std::endl;
42870 : }
42871 : }
42872 :
42873 0 : if ( p_numeric_label != NULL )
42874 : {
42875 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42876 : {
42877 0 : if ( p_numeric_label->isInMemoryPool() == false )
42878 : {
42879 0 : std::cout << "SgVariableDefinition :: ";
42880 0 : std::cout << " p_numeric_label is not in memory pool of ";
42881 0 : std::cout << p_numeric_label->class_name() << std::endl;
42882 : }
42883 : }
42884 : else
42885 : {
42886 0 : std::cout << "SgVariableDefinition :: " << std::flush;
42887 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
42888 0 : std::cout << " not valid " << std::endl;
42889 : }
42890 : }
42891 :
42892 0 : if ( p_startOfConstruct != NULL )
42893 : {
42894 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42895 : {
42896 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
42897 : {
42898 0 : std::cout << "SgVariableDefinition :: ";
42899 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
42900 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
42901 : }
42902 : }
42903 : else
42904 : {
42905 0 : std::cout << "SgVariableDefinition :: " << std::flush;
42906 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
42907 0 : std::cout << " not valid " << std::endl;
42908 : }
42909 : }
42910 :
42911 0 : if ( p_endOfConstruct != NULL )
42912 : {
42913 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42914 : {
42915 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
42916 : {
42917 0 : std::cout << "SgVariableDefinition :: ";
42918 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
42919 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
42920 : }
42921 : }
42922 : else
42923 : {
42924 0 : std::cout << "SgVariableDefinition :: " << std::flush;
42925 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
42926 0 : std::cout << " not valid " << std::endl;
42927 : }
42928 : }
42929 :
42930 0 : if ( p_parent != NULL )
42931 : {
42932 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
42933 : {
42934 0 : if ( p_parent->isInMemoryPool() == false )
42935 : {
42936 0 : std::cout << "SgVariableDefinition :: ";
42937 0 : std::cout << " p_parent is not in memory pool of ";
42938 0 : std::cout << p_parent->class_name() << std::endl;
42939 : }
42940 : }
42941 : else
42942 : {
42943 0 : std::cout << "SgVariableDefinition :: " << std::flush;
42944 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
42945 0 : std::cout << " not valid " << std::endl;
42946 : }
42947 : }
42948 :
42949 :
42950 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
42951 :
42952 0 : }
42953 :
42954 :
42955 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
42956 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
42957 : bool
42958 0 : SgVariableDefinition::isInMemoryPool ()
42959 : {
42960 0 : typedef unsigned char* TestType;
42961 :
42962 0 : bool found = false;
42963 :
42964 0 : ROSE_ASSERT(this != NULL);
42965 :
42966 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
42967 :
42968 0 : TestType tested = (TestType) ( this ) ;
42969 :
42970 0 : std::vector < unsigned char* > :: const_iterator block = SgVariableDefinition::pools.begin();
42971 :
42972 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
42973 : // while (found == false && block < Memory_Block_List.end())
42974 0 : while ( (found == false) && (block != SgVariableDefinition::pools.end()) )
42975 : {
42976 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgVariableDefinition::pool_size * sizeof(SgVariableDefinition) ) ) ;
42977 0 : ++block;
42978 : }
42979 :
42980 : // Special handling for static data
42981 :
42982 :
42983 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
42984 0 : ROSE_ASSERT(found == true);
42985 :
42986 0 : return found;
42987 : }
42988 : /* #line 42989 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
42989 :
42990 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
42991 :
42992 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
42993 :
42994 : /* #line 42995 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
42995 :
42996 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
42997 :
42998 : void
42999 0 : SgClinkageDeclarationStatement::checkDataMemberPointersIfInMemoryPool()
43000 : {
43001 : // ------------ checking pointers of SgClinkageDeclarationStatement -------------------
43002 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
43003 :
43004 0 : if ( p_definingDeclaration != NULL )
43005 : {
43006 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43007 : {
43008 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
43009 : {
43010 0 : std::cout << "SgClinkageDeclarationStatement :: ";
43011 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
43012 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
43013 : }
43014 : }
43015 : else
43016 : {
43017 0 : std::cout << "SgClinkageDeclarationStatement :: " << std::flush;
43018 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
43019 0 : std::cout << " not valid " << std::endl;
43020 : }
43021 : }
43022 :
43023 0 : if ( p_firstNondefiningDeclaration != NULL )
43024 : {
43025 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43026 : {
43027 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
43028 : {
43029 0 : std::cout << "SgClinkageDeclarationStatement :: ";
43030 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
43031 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
43032 : }
43033 : }
43034 : else
43035 : {
43036 0 : std::cout << "SgClinkageDeclarationStatement :: " << std::flush;
43037 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
43038 0 : std::cout << " not valid " << std::endl;
43039 : }
43040 : }
43041 :
43042 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
43043 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
43044 : {
43045 0 : if ( (*i_qualifiedNameList) != NULL )
43046 : {
43047 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43048 : {
43049 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
43050 : {
43051 0 : std::cout << "SgClinkageDeclarationStatement :: ";
43052 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
43053 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
43054 : }
43055 : }
43056 : else
43057 : {
43058 0 : std::cout << "SgClinkageDeclarationStatement :: " << std::flush;
43059 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
43060 0 : std::cout << " entry not valid " << std::endl;
43061 : }
43062 : }
43063 : else
43064 : {
43065 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
43066 : }
43067 : }
43068 :
43069 0 : if ( p_declarationScope != NULL )
43070 : {
43071 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43072 : {
43073 0 : if ( p_declarationScope->isInMemoryPool() == false )
43074 : {
43075 0 : std::cout << "SgClinkageDeclarationStatement :: ";
43076 0 : std::cout << " p_declarationScope is not in memory pool of ";
43077 0 : std::cout << p_declarationScope->class_name() << std::endl;
43078 : }
43079 : }
43080 : else
43081 : {
43082 0 : std::cout << "SgClinkageDeclarationStatement :: " << std::flush;
43083 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
43084 0 : std::cout << " not valid " << std::endl;
43085 : }
43086 : }
43087 :
43088 0 : if ( p_numeric_label != NULL )
43089 : {
43090 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43091 : {
43092 0 : if ( p_numeric_label->isInMemoryPool() == false )
43093 : {
43094 0 : std::cout << "SgClinkageDeclarationStatement :: ";
43095 0 : std::cout << " p_numeric_label is not in memory pool of ";
43096 0 : std::cout << p_numeric_label->class_name() << std::endl;
43097 : }
43098 : }
43099 : else
43100 : {
43101 0 : std::cout << "SgClinkageDeclarationStatement :: " << std::flush;
43102 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
43103 0 : std::cout << " not valid " << std::endl;
43104 : }
43105 : }
43106 :
43107 0 : if ( p_startOfConstruct != NULL )
43108 : {
43109 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43110 : {
43111 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
43112 : {
43113 0 : std::cout << "SgClinkageDeclarationStatement :: ";
43114 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
43115 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
43116 : }
43117 : }
43118 : else
43119 : {
43120 0 : std::cout << "SgClinkageDeclarationStatement :: " << std::flush;
43121 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
43122 0 : std::cout << " not valid " << std::endl;
43123 : }
43124 : }
43125 :
43126 0 : if ( p_endOfConstruct != NULL )
43127 : {
43128 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43129 : {
43130 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
43131 : {
43132 0 : std::cout << "SgClinkageDeclarationStatement :: ";
43133 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
43134 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
43135 : }
43136 : }
43137 : else
43138 : {
43139 0 : std::cout << "SgClinkageDeclarationStatement :: " << std::flush;
43140 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
43141 0 : std::cout << " not valid " << std::endl;
43142 : }
43143 : }
43144 :
43145 0 : if ( p_parent != NULL )
43146 : {
43147 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43148 : {
43149 0 : if ( p_parent->isInMemoryPool() == false )
43150 : {
43151 0 : std::cout << "SgClinkageDeclarationStatement :: ";
43152 0 : std::cout << " p_parent is not in memory pool of ";
43153 0 : std::cout << p_parent->class_name() << std::endl;
43154 : }
43155 : }
43156 : else
43157 : {
43158 0 : std::cout << "SgClinkageDeclarationStatement :: " << std::flush;
43159 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
43160 0 : std::cout << " not valid " << std::endl;
43161 : }
43162 : }
43163 :
43164 :
43165 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
43166 :
43167 0 : }
43168 :
43169 :
43170 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
43171 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
43172 : bool
43173 0 : SgClinkageDeclarationStatement::isInMemoryPool ()
43174 : {
43175 0 : typedef unsigned char* TestType;
43176 :
43177 0 : bool found = false;
43178 :
43179 0 : ROSE_ASSERT(this != NULL);
43180 :
43181 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
43182 :
43183 0 : TestType tested = (TestType) ( this ) ;
43184 :
43185 0 : std::vector < unsigned char* > :: const_iterator block = SgClinkageDeclarationStatement::pools.begin();
43186 :
43187 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
43188 : // while (found == false && block < Memory_Block_List.end())
43189 0 : while ( (found == false) && (block != SgClinkageDeclarationStatement::pools.end()) )
43190 : {
43191 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgClinkageDeclarationStatement::pool_size * sizeof(SgClinkageDeclarationStatement) ) ) ;
43192 0 : ++block;
43193 : }
43194 :
43195 : // Special handling for static data
43196 :
43197 :
43198 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
43199 0 : ROSE_ASSERT(found == true);
43200 :
43201 0 : return found;
43202 : }
43203 : /* #line 43204 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
43204 :
43205 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
43206 :
43207 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
43208 :
43209 : /* #line 43210 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
43210 :
43211 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
43212 :
43213 : void
43214 0 : SgClinkageStartStatement::checkDataMemberPointersIfInMemoryPool()
43215 : {
43216 : // ------------ checking pointers of SgClinkageStartStatement -------------------
43217 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
43218 :
43219 0 : if ( p_definingDeclaration != NULL )
43220 : {
43221 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43222 : {
43223 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
43224 : {
43225 0 : std::cout << "SgClinkageStartStatement :: ";
43226 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
43227 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
43228 : }
43229 : }
43230 : else
43231 : {
43232 0 : std::cout << "SgClinkageStartStatement :: " << std::flush;
43233 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
43234 0 : std::cout << " not valid " << std::endl;
43235 : }
43236 : }
43237 :
43238 0 : if ( p_firstNondefiningDeclaration != NULL )
43239 : {
43240 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43241 : {
43242 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
43243 : {
43244 0 : std::cout << "SgClinkageStartStatement :: ";
43245 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
43246 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
43247 : }
43248 : }
43249 : else
43250 : {
43251 0 : std::cout << "SgClinkageStartStatement :: " << std::flush;
43252 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
43253 0 : std::cout << " not valid " << std::endl;
43254 : }
43255 : }
43256 :
43257 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
43258 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
43259 : {
43260 0 : if ( (*i_qualifiedNameList) != NULL )
43261 : {
43262 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43263 : {
43264 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
43265 : {
43266 0 : std::cout << "SgClinkageStartStatement :: ";
43267 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
43268 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
43269 : }
43270 : }
43271 : else
43272 : {
43273 0 : std::cout << "SgClinkageStartStatement :: " << std::flush;
43274 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
43275 0 : std::cout << " entry not valid " << std::endl;
43276 : }
43277 : }
43278 : else
43279 : {
43280 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
43281 : }
43282 : }
43283 :
43284 0 : if ( p_declarationScope != NULL )
43285 : {
43286 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43287 : {
43288 0 : if ( p_declarationScope->isInMemoryPool() == false )
43289 : {
43290 0 : std::cout << "SgClinkageStartStatement :: ";
43291 0 : std::cout << " p_declarationScope is not in memory pool of ";
43292 0 : std::cout << p_declarationScope->class_name() << std::endl;
43293 : }
43294 : }
43295 : else
43296 : {
43297 0 : std::cout << "SgClinkageStartStatement :: " << std::flush;
43298 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
43299 0 : std::cout << " not valid " << std::endl;
43300 : }
43301 : }
43302 :
43303 0 : if ( p_numeric_label != NULL )
43304 : {
43305 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43306 : {
43307 0 : if ( p_numeric_label->isInMemoryPool() == false )
43308 : {
43309 0 : std::cout << "SgClinkageStartStatement :: ";
43310 0 : std::cout << " p_numeric_label is not in memory pool of ";
43311 0 : std::cout << p_numeric_label->class_name() << std::endl;
43312 : }
43313 : }
43314 : else
43315 : {
43316 0 : std::cout << "SgClinkageStartStatement :: " << std::flush;
43317 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
43318 0 : std::cout << " not valid " << std::endl;
43319 : }
43320 : }
43321 :
43322 0 : if ( p_startOfConstruct != NULL )
43323 : {
43324 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43325 : {
43326 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
43327 : {
43328 0 : std::cout << "SgClinkageStartStatement :: ";
43329 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
43330 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
43331 : }
43332 : }
43333 : else
43334 : {
43335 0 : std::cout << "SgClinkageStartStatement :: " << std::flush;
43336 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
43337 0 : std::cout << " not valid " << std::endl;
43338 : }
43339 : }
43340 :
43341 0 : if ( p_endOfConstruct != NULL )
43342 : {
43343 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43344 : {
43345 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
43346 : {
43347 0 : std::cout << "SgClinkageStartStatement :: ";
43348 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
43349 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
43350 : }
43351 : }
43352 : else
43353 : {
43354 0 : std::cout << "SgClinkageStartStatement :: " << std::flush;
43355 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
43356 0 : std::cout << " not valid " << std::endl;
43357 : }
43358 : }
43359 :
43360 0 : if ( p_parent != NULL )
43361 : {
43362 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43363 : {
43364 0 : if ( p_parent->isInMemoryPool() == false )
43365 : {
43366 0 : std::cout << "SgClinkageStartStatement :: ";
43367 0 : std::cout << " p_parent is not in memory pool of ";
43368 0 : std::cout << p_parent->class_name() << std::endl;
43369 : }
43370 : }
43371 : else
43372 : {
43373 0 : std::cout << "SgClinkageStartStatement :: " << std::flush;
43374 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
43375 0 : std::cout << " not valid " << std::endl;
43376 : }
43377 : }
43378 :
43379 :
43380 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
43381 :
43382 0 : }
43383 :
43384 :
43385 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
43386 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
43387 : bool
43388 0 : SgClinkageStartStatement::isInMemoryPool ()
43389 : {
43390 0 : typedef unsigned char* TestType;
43391 :
43392 0 : bool found = false;
43393 :
43394 0 : ROSE_ASSERT(this != NULL);
43395 :
43396 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
43397 :
43398 0 : TestType tested = (TestType) ( this ) ;
43399 :
43400 0 : std::vector < unsigned char* > :: const_iterator block = SgClinkageStartStatement::pools.begin();
43401 :
43402 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
43403 : // while (found == false && block < Memory_Block_List.end())
43404 0 : while ( (found == false) && (block != SgClinkageStartStatement::pools.end()) )
43405 : {
43406 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgClinkageStartStatement::pool_size * sizeof(SgClinkageStartStatement) ) ) ;
43407 0 : ++block;
43408 : }
43409 :
43410 : // Special handling for static data
43411 :
43412 :
43413 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
43414 0 : ROSE_ASSERT(found == true);
43415 :
43416 0 : return found;
43417 : }
43418 : /* #line 43419 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
43419 :
43420 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
43421 :
43422 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
43423 :
43424 : /* #line 43425 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
43425 :
43426 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
43427 :
43428 : void
43429 0 : SgClinkageEndStatement::checkDataMemberPointersIfInMemoryPool()
43430 : {
43431 : // ------------ checking pointers of SgClinkageEndStatement -------------------
43432 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
43433 :
43434 0 : if ( p_definingDeclaration != NULL )
43435 : {
43436 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43437 : {
43438 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
43439 : {
43440 0 : std::cout << "SgClinkageEndStatement :: ";
43441 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
43442 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
43443 : }
43444 : }
43445 : else
43446 : {
43447 0 : std::cout << "SgClinkageEndStatement :: " << std::flush;
43448 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
43449 0 : std::cout << " not valid " << std::endl;
43450 : }
43451 : }
43452 :
43453 0 : if ( p_firstNondefiningDeclaration != NULL )
43454 : {
43455 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43456 : {
43457 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
43458 : {
43459 0 : std::cout << "SgClinkageEndStatement :: ";
43460 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
43461 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
43462 : }
43463 : }
43464 : else
43465 : {
43466 0 : std::cout << "SgClinkageEndStatement :: " << std::flush;
43467 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
43468 0 : std::cout << " not valid " << std::endl;
43469 : }
43470 : }
43471 :
43472 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
43473 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
43474 : {
43475 0 : if ( (*i_qualifiedNameList) != NULL )
43476 : {
43477 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43478 : {
43479 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
43480 : {
43481 0 : std::cout << "SgClinkageEndStatement :: ";
43482 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
43483 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
43484 : }
43485 : }
43486 : else
43487 : {
43488 0 : std::cout << "SgClinkageEndStatement :: " << std::flush;
43489 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
43490 0 : std::cout << " entry not valid " << std::endl;
43491 : }
43492 : }
43493 : else
43494 : {
43495 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
43496 : }
43497 : }
43498 :
43499 0 : if ( p_declarationScope != NULL )
43500 : {
43501 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43502 : {
43503 0 : if ( p_declarationScope->isInMemoryPool() == false )
43504 : {
43505 0 : std::cout << "SgClinkageEndStatement :: ";
43506 0 : std::cout << " p_declarationScope is not in memory pool of ";
43507 0 : std::cout << p_declarationScope->class_name() << std::endl;
43508 : }
43509 : }
43510 : else
43511 : {
43512 0 : std::cout << "SgClinkageEndStatement :: " << std::flush;
43513 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
43514 0 : std::cout << " not valid " << std::endl;
43515 : }
43516 : }
43517 :
43518 0 : if ( p_numeric_label != NULL )
43519 : {
43520 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43521 : {
43522 0 : if ( p_numeric_label->isInMemoryPool() == false )
43523 : {
43524 0 : std::cout << "SgClinkageEndStatement :: ";
43525 0 : std::cout << " p_numeric_label is not in memory pool of ";
43526 0 : std::cout << p_numeric_label->class_name() << std::endl;
43527 : }
43528 : }
43529 : else
43530 : {
43531 0 : std::cout << "SgClinkageEndStatement :: " << std::flush;
43532 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
43533 0 : std::cout << " not valid " << std::endl;
43534 : }
43535 : }
43536 :
43537 0 : if ( p_startOfConstruct != NULL )
43538 : {
43539 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43540 : {
43541 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
43542 : {
43543 0 : std::cout << "SgClinkageEndStatement :: ";
43544 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
43545 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
43546 : }
43547 : }
43548 : else
43549 : {
43550 0 : std::cout << "SgClinkageEndStatement :: " << std::flush;
43551 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
43552 0 : std::cout << " not valid " << std::endl;
43553 : }
43554 : }
43555 :
43556 0 : if ( p_endOfConstruct != NULL )
43557 : {
43558 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43559 : {
43560 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
43561 : {
43562 0 : std::cout << "SgClinkageEndStatement :: ";
43563 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
43564 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
43565 : }
43566 : }
43567 : else
43568 : {
43569 0 : std::cout << "SgClinkageEndStatement :: " << std::flush;
43570 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
43571 0 : std::cout << " not valid " << std::endl;
43572 : }
43573 : }
43574 :
43575 0 : if ( p_parent != NULL )
43576 : {
43577 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43578 : {
43579 0 : if ( p_parent->isInMemoryPool() == false )
43580 : {
43581 0 : std::cout << "SgClinkageEndStatement :: ";
43582 0 : std::cout << " p_parent is not in memory pool of ";
43583 0 : std::cout << p_parent->class_name() << std::endl;
43584 : }
43585 : }
43586 : else
43587 : {
43588 0 : std::cout << "SgClinkageEndStatement :: " << std::flush;
43589 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
43590 0 : std::cout << " not valid " << std::endl;
43591 : }
43592 : }
43593 :
43594 :
43595 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
43596 :
43597 0 : }
43598 :
43599 :
43600 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
43601 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
43602 : bool
43603 0 : SgClinkageEndStatement::isInMemoryPool ()
43604 : {
43605 0 : typedef unsigned char* TestType;
43606 :
43607 0 : bool found = false;
43608 :
43609 0 : ROSE_ASSERT(this != NULL);
43610 :
43611 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
43612 :
43613 0 : TestType tested = (TestType) ( this ) ;
43614 :
43615 0 : std::vector < unsigned char* > :: const_iterator block = SgClinkageEndStatement::pools.begin();
43616 :
43617 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
43618 : // while (found == false && block < Memory_Block_List.end())
43619 0 : while ( (found == false) && (block != SgClinkageEndStatement::pools.end()) )
43620 : {
43621 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgClinkageEndStatement::pool_size * sizeof(SgClinkageEndStatement) ) ) ;
43622 0 : ++block;
43623 : }
43624 :
43625 : // Special handling for static data
43626 :
43627 :
43628 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
43629 0 : ROSE_ASSERT(found == true);
43630 :
43631 0 : return found;
43632 : }
43633 : /* #line 43634 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
43634 :
43635 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
43636 :
43637 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
43638 :
43639 : /* #line 43640 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
43640 :
43641 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
43642 :
43643 : void
43644 0 : SgEnumDeclaration::checkDataMemberPointersIfInMemoryPool()
43645 : {
43646 : // ------------ checking pointers of SgEnumDeclaration -------------------
43647 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
43648 :
43649 0 : if ( p_type != NULL )
43650 : {
43651 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43652 : {
43653 0 : if ( p_type->isInMemoryPool() == false )
43654 : {
43655 0 : std::cout << "SgEnumDeclaration :: ";
43656 0 : std::cout << " p_type is not in memory pool of ";
43657 0 : std::cout << p_type->class_name() << std::endl;
43658 : }
43659 : }
43660 : else
43661 : {
43662 0 : std::cout << "SgEnumDeclaration :: " << std::flush;
43663 0 : std::cout << "SgEnumType* p_type = " << p_type << " --> " << std::flush;
43664 0 : std::cout << " not valid " << std::endl;
43665 : }
43666 : }
43667 :
43668 0 : if ( p_adaParentType != NULL )
43669 : {
43670 0 : if ( p_adaParentType->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43671 : {
43672 0 : if ( p_adaParentType->isInMemoryPool() == false )
43673 : {
43674 0 : std::cout << "SgEnumDeclaration :: ";
43675 0 : std::cout << " p_adaParentType is not in memory pool of ";
43676 0 : std::cout << p_adaParentType->class_name() << std::endl;
43677 : }
43678 : }
43679 : else
43680 : {
43681 0 : std::cout << "SgEnumDeclaration :: " << std::flush;
43682 0 : std::cout << "SgType* p_adaParentType = " << p_adaParentType << " --> " << std::flush;
43683 0 : std::cout << " not valid " << std::endl;
43684 : }
43685 : }
43686 :
43687 0 : SgInitializedNamePtrList::iterator i_enumerators = p_enumerators.begin() ;
43688 0 : for ( ; i_enumerators != p_enumerators.end(); ++i_enumerators )
43689 : {
43690 0 : if ( (*i_enumerators) != NULL )
43691 : {
43692 0 : if ( (*i_enumerators)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43693 : {
43694 0 : if ( (*i_enumerators)->isInMemoryPool() == false )
43695 : {
43696 0 : std::cout << "SgEnumDeclaration :: ";
43697 0 : std::cout << " p_enumerators ( list of poitners to IR nodes ), entry is not in memory pool of ";
43698 0 : std::cout << (*i_enumerators)->class_name() << std::endl;
43699 : }
43700 : }
43701 : else
43702 : {
43703 0 : std::cout << "SgEnumDeclaration :: " << std::flush;
43704 0 : std::cout << "SgInitializedNamePtrList p_enumerators --> " << std::flush;
43705 0 : std::cout << " entry not valid " << std::endl;
43706 : }
43707 : }
43708 : else
43709 : {
43710 0 : std::cout << "SgInitializedNamePtrList p_enumerators --> NULL " << std::endl;
43711 : }
43712 : }
43713 :
43714 0 : if ( p_scope != NULL )
43715 : {
43716 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43717 : {
43718 0 : if ( p_scope->isInMemoryPool() == false )
43719 : {
43720 0 : std::cout << "SgEnumDeclaration :: ";
43721 0 : std::cout << " p_scope is not in memory pool of ";
43722 0 : std::cout << p_scope->class_name() << std::endl;
43723 : }
43724 : }
43725 : else
43726 : {
43727 0 : std::cout << "SgEnumDeclaration :: " << std::flush;
43728 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
43729 0 : std::cout << " not valid " << std::endl;
43730 : }
43731 : }
43732 :
43733 0 : if ( p_field_type != NULL )
43734 : {
43735 0 : if ( p_field_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43736 : {
43737 0 : if ( p_field_type->isInMemoryPool() == false )
43738 : {
43739 0 : std::cout << "SgEnumDeclaration :: ";
43740 0 : std::cout << " p_field_type is not in memory pool of ";
43741 0 : std::cout << p_field_type->class_name() << std::endl;
43742 : }
43743 : }
43744 : else
43745 : {
43746 0 : std::cout << "SgEnumDeclaration :: " << std::flush;
43747 0 : std::cout << "SgType* p_field_type = " << p_field_type << " --> " << std::flush;
43748 0 : std::cout << " not valid " << std::endl;
43749 : }
43750 : }
43751 :
43752 0 : if ( p_definingDeclaration != NULL )
43753 : {
43754 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43755 : {
43756 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
43757 : {
43758 0 : std::cout << "SgEnumDeclaration :: ";
43759 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
43760 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
43761 : }
43762 : }
43763 : else
43764 : {
43765 0 : std::cout << "SgEnumDeclaration :: " << std::flush;
43766 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
43767 0 : std::cout << " not valid " << std::endl;
43768 : }
43769 : }
43770 :
43771 0 : if ( p_firstNondefiningDeclaration != NULL )
43772 : {
43773 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43774 : {
43775 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
43776 : {
43777 0 : std::cout << "SgEnumDeclaration :: ";
43778 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
43779 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
43780 : }
43781 : }
43782 : else
43783 : {
43784 0 : std::cout << "SgEnumDeclaration :: " << std::flush;
43785 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
43786 0 : std::cout << " not valid " << std::endl;
43787 : }
43788 : }
43789 :
43790 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
43791 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
43792 : {
43793 0 : if ( (*i_qualifiedNameList) != NULL )
43794 : {
43795 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43796 : {
43797 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
43798 : {
43799 0 : std::cout << "SgEnumDeclaration :: ";
43800 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
43801 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
43802 : }
43803 : }
43804 : else
43805 : {
43806 0 : std::cout << "SgEnumDeclaration :: " << std::flush;
43807 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
43808 0 : std::cout << " entry not valid " << std::endl;
43809 : }
43810 : }
43811 : else
43812 : {
43813 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
43814 : }
43815 : }
43816 :
43817 0 : if ( p_declarationScope != NULL )
43818 : {
43819 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43820 : {
43821 0 : if ( p_declarationScope->isInMemoryPool() == false )
43822 : {
43823 0 : std::cout << "SgEnumDeclaration :: ";
43824 0 : std::cout << " p_declarationScope is not in memory pool of ";
43825 0 : std::cout << p_declarationScope->class_name() << std::endl;
43826 : }
43827 : }
43828 : else
43829 : {
43830 0 : std::cout << "SgEnumDeclaration :: " << std::flush;
43831 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
43832 0 : std::cout << " not valid " << std::endl;
43833 : }
43834 : }
43835 :
43836 0 : if ( p_numeric_label != NULL )
43837 : {
43838 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43839 : {
43840 0 : if ( p_numeric_label->isInMemoryPool() == false )
43841 : {
43842 0 : std::cout << "SgEnumDeclaration :: ";
43843 0 : std::cout << " p_numeric_label is not in memory pool of ";
43844 0 : std::cout << p_numeric_label->class_name() << std::endl;
43845 : }
43846 : }
43847 : else
43848 : {
43849 0 : std::cout << "SgEnumDeclaration :: " << std::flush;
43850 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
43851 0 : std::cout << " not valid " << std::endl;
43852 : }
43853 : }
43854 :
43855 0 : if ( p_startOfConstruct != NULL )
43856 : {
43857 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43858 : {
43859 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
43860 : {
43861 0 : std::cout << "SgEnumDeclaration :: ";
43862 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
43863 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
43864 : }
43865 : }
43866 : else
43867 : {
43868 0 : std::cout << "SgEnumDeclaration :: " << std::flush;
43869 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
43870 0 : std::cout << " not valid " << std::endl;
43871 : }
43872 : }
43873 :
43874 0 : if ( p_endOfConstruct != NULL )
43875 : {
43876 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43877 : {
43878 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
43879 : {
43880 0 : std::cout << "SgEnumDeclaration :: ";
43881 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
43882 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
43883 : }
43884 : }
43885 : else
43886 : {
43887 0 : std::cout << "SgEnumDeclaration :: " << std::flush;
43888 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
43889 0 : std::cout << " not valid " << std::endl;
43890 : }
43891 : }
43892 :
43893 0 : if ( p_parent != NULL )
43894 : {
43895 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43896 : {
43897 0 : if ( p_parent->isInMemoryPool() == false )
43898 : {
43899 0 : std::cout << "SgEnumDeclaration :: ";
43900 0 : std::cout << " p_parent is not in memory pool of ";
43901 0 : std::cout << p_parent->class_name() << std::endl;
43902 : }
43903 : }
43904 : else
43905 : {
43906 0 : std::cout << "SgEnumDeclaration :: " << std::flush;
43907 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
43908 0 : std::cout << " not valid " << std::endl;
43909 : }
43910 : }
43911 :
43912 :
43913 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
43914 :
43915 0 : }
43916 :
43917 :
43918 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
43919 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
43920 : bool
43921 0 : SgEnumDeclaration::isInMemoryPool ()
43922 : {
43923 0 : typedef unsigned char* TestType;
43924 :
43925 0 : bool found = false;
43926 :
43927 0 : ROSE_ASSERT(this != NULL);
43928 :
43929 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
43930 :
43931 0 : TestType tested = (TestType) ( this ) ;
43932 :
43933 0 : std::vector < unsigned char* > :: const_iterator block = SgEnumDeclaration::pools.begin();
43934 :
43935 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
43936 : // while (found == false && block < Memory_Block_List.end())
43937 0 : while ( (found == false) && (block != SgEnumDeclaration::pools.end()) )
43938 : {
43939 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgEnumDeclaration::pool_size * sizeof(SgEnumDeclaration) ) ) ;
43940 0 : ++block;
43941 : }
43942 :
43943 : // Special handling for static data
43944 :
43945 :
43946 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
43947 0 : ROSE_ASSERT(found == true);
43948 :
43949 0 : return found;
43950 : }
43951 : /* #line 43952 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
43952 :
43953 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
43954 :
43955 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
43956 :
43957 : /* #line 43958 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
43958 :
43959 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
43960 :
43961 : void
43962 0 : SgAsmStmt::checkDataMemberPointersIfInMemoryPool()
43963 : {
43964 : // ------------ checking pointers of SgAsmStmt -------------------
43965 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
43966 :
43967 0 : SgExpressionPtrList::iterator i_operands = p_operands.begin() ;
43968 0 : for ( ; i_operands != p_operands.end(); ++i_operands )
43969 : {
43970 0 : if ( (*i_operands) != NULL )
43971 : {
43972 0 : if ( (*i_operands)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43973 : {
43974 0 : if ( (*i_operands)->isInMemoryPool() == false )
43975 : {
43976 0 : std::cout << "SgAsmStmt :: ";
43977 0 : std::cout << " p_operands ( list of poitners to IR nodes ), entry is not in memory pool of ";
43978 0 : std::cout << (*i_operands)->class_name() << std::endl;
43979 : }
43980 : }
43981 : else
43982 : {
43983 0 : std::cout << "SgAsmStmt :: " << std::flush;
43984 0 : std::cout << "SgExpressionPtrList p_operands --> " << std::flush;
43985 0 : std::cout << " entry not valid " << std::endl;
43986 : }
43987 : }
43988 : else
43989 : {
43990 0 : std::cout << "SgExpressionPtrList p_operands --> NULL " << std::endl;
43991 : }
43992 : }
43993 :
43994 0 : if ( p_definingDeclaration != NULL )
43995 : {
43996 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
43997 : {
43998 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
43999 : {
44000 0 : std::cout << "SgAsmStmt :: ";
44001 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
44002 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
44003 : }
44004 : }
44005 : else
44006 : {
44007 0 : std::cout << "SgAsmStmt :: " << std::flush;
44008 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
44009 0 : std::cout << " not valid " << std::endl;
44010 : }
44011 : }
44012 :
44013 0 : if ( p_firstNondefiningDeclaration != NULL )
44014 : {
44015 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44016 : {
44017 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
44018 : {
44019 0 : std::cout << "SgAsmStmt :: ";
44020 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
44021 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
44022 : }
44023 : }
44024 : else
44025 : {
44026 0 : std::cout << "SgAsmStmt :: " << std::flush;
44027 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
44028 0 : std::cout << " not valid " << std::endl;
44029 : }
44030 : }
44031 :
44032 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
44033 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
44034 : {
44035 0 : if ( (*i_qualifiedNameList) != NULL )
44036 : {
44037 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44038 : {
44039 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
44040 : {
44041 0 : std::cout << "SgAsmStmt :: ";
44042 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
44043 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
44044 : }
44045 : }
44046 : else
44047 : {
44048 0 : std::cout << "SgAsmStmt :: " << std::flush;
44049 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
44050 0 : std::cout << " entry not valid " << std::endl;
44051 : }
44052 : }
44053 : else
44054 : {
44055 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
44056 : }
44057 : }
44058 :
44059 0 : if ( p_declarationScope != NULL )
44060 : {
44061 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44062 : {
44063 0 : if ( p_declarationScope->isInMemoryPool() == false )
44064 : {
44065 0 : std::cout << "SgAsmStmt :: ";
44066 0 : std::cout << " p_declarationScope is not in memory pool of ";
44067 0 : std::cout << p_declarationScope->class_name() << std::endl;
44068 : }
44069 : }
44070 : else
44071 : {
44072 0 : std::cout << "SgAsmStmt :: " << std::flush;
44073 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
44074 0 : std::cout << " not valid " << std::endl;
44075 : }
44076 : }
44077 :
44078 0 : if ( p_numeric_label != NULL )
44079 : {
44080 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44081 : {
44082 0 : if ( p_numeric_label->isInMemoryPool() == false )
44083 : {
44084 0 : std::cout << "SgAsmStmt :: ";
44085 0 : std::cout << " p_numeric_label is not in memory pool of ";
44086 0 : std::cout << p_numeric_label->class_name() << std::endl;
44087 : }
44088 : }
44089 : else
44090 : {
44091 0 : std::cout << "SgAsmStmt :: " << std::flush;
44092 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
44093 0 : std::cout << " not valid " << std::endl;
44094 : }
44095 : }
44096 :
44097 0 : if ( p_startOfConstruct != NULL )
44098 : {
44099 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44100 : {
44101 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
44102 : {
44103 0 : std::cout << "SgAsmStmt :: ";
44104 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
44105 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
44106 : }
44107 : }
44108 : else
44109 : {
44110 0 : std::cout << "SgAsmStmt :: " << std::flush;
44111 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
44112 0 : std::cout << " not valid " << std::endl;
44113 : }
44114 : }
44115 :
44116 0 : if ( p_endOfConstruct != NULL )
44117 : {
44118 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44119 : {
44120 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
44121 : {
44122 0 : std::cout << "SgAsmStmt :: ";
44123 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
44124 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
44125 : }
44126 : }
44127 : else
44128 : {
44129 0 : std::cout << "SgAsmStmt :: " << std::flush;
44130 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
44131 0 : std::cout << " not valid " << std::endl;
44132 : }
44133 : }
44134 :
44135 0 : if ( p_parent != NULL )
44136 : {
44137 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44138 : {
44139 0 : if ( p_parent->isInMemoryPool() == false )
44140 : {
44141 0 : std::cout << "SgAsmStmt :: ";
44142 0 : std::cout << " p_parent is not in memory pool of ";
44143 0 : std::cout << p_parent->class_name() << std::endl;
44144 : }
44145 : }
44146 : else
44147 : {
44148 0 : std::cout << "SgAsmStmt :: " << std::flush;
44149 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
44150 0 : std::cout << " not valid " << std::endl;
44151 : }
44152 : }
44153 :
44154 :
44155 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
44156 :
44157 0 : }
44158 :
44159 :
44160 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
44161 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
44162 : bool
44163 0 : SgAsmStmt::isInMemoryPool ()
44164 : {
44165 0 : typedef unsigned char* TestType;
44166 :
44167 0 : bool found = false;
44168 :
44169 0 : ROSE_ASSERT(this != NULL);
44170 :
44171 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
44172 :
44173 0 : TestType tested = (TestType) ( this ) ;
44174 :
44175 0 : std::vector < unsigned char* > :: const_iterator block = SgAsmStmt::pools.begin();
44176 :
44177 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
44178 : // while (found == false && block < Memory_Block_List.end())
44179 0 : while ( (found == false) && (block != SgAsmStmt::pools.end()) )
44180 : {
44181 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAsmStmt::pool_size * sizeof(SgAsmStmt) ) ) ;
44182 0 : ++block;
44183 : }
44184 :
44185 : // Special handling for static data
44186 :
44187 :
44188 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
44189 0 : ROSE_ASSERT(found == true);
44190 :
44191 0 : return found;
44192 : }
44193 : /* #line 44194 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
44194 :
44195 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
44196 :
44197 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
44198 :
44199 : /* #line 44200 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
44200 :
44201 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
44202 :
44203 : void
44204 0 : SgAttributeSpecificationStatement::checkDataMemberPointersIfInMemoryPool()
44205 : {
44206 : // ------------ checking pointers of SgAttributeSpecificationStatement -------------------
44207 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
44208 :
44209 0 : if ( p_parameter_list != NULL )
44210 : {
44211 0 : if ( p_parameter_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44212 : {
44213 0 : if ( p_parameter_list->isInMemoryPool() == false )
44214 : {
44215 0 : std::cout << "SgAttributeSpecificationStatement :: ";
44216 0 : std::cout << " p_parameter_list is not in memory pool of ";
44217 0 : std::cout << p_parameter_list->class_name() << std::endl;
44218 : }
44219 : }
44220 : else
44221 : {
44222 0 : std::cout << "SgAttributeSpecificationStatement :: " << std::flush;
44223 0 : std::cout << "SgExprListExp* p_parameter_list = " << p_parameter_list << " --> " << std::flush;
44224 0 : std::cout << " not valid " << std::endl;
44225 : }
44226 : }
44227 :
44228 0 : SgDataStatementGroupPtrList::iterator i_data_statement_group_list = p_data_statement_group_list.begin() ;
44229 0 : for ( ; i_data_statement_group_list != p_data_statement_group_list.end(); ++i_data_statement_group_list )
44230 : {
44231 0 : if ( (*i_data_statement_group_list) != NULL )
44232 : {
44233 0 : if ( (*i_data_statement_group_list)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44234 : {
44235 0 : if ( (*i_data_statement_group_list)->isInMemoryPool() == false )
44236 : {
44237 0 : std::cout << "SgAttributeSpecificationStatement :: ";
44238 0 : std::cout << " p_data_statement_group_list ( list of poitners to IR nodes ), entry is not in memory pool of ";
44239 0 : std::cout << (*i_data_statement_group_list)->class_name() << std::endl;
44240 : }
44241 : }
44242 : else
44243 : {
44244 0 : std::cout << "SgAttributeSpecificationStatement :: " << std::flush;
44245 0 : std::cout << "SgDataStatementGroupPtrList p_data_statement_group_list --> " << std::flush;
44246 0 : std::cout << " entry not valid " << std::endl;
44247 : }
44248 : }
44249 : else
44250 : {
44251 0 : std::cout << "SgDataStatementGroupPtrList p_data_statement_group_list --> NULL " << std::endl;
44252 : }
44253 : }
44254 :
44255 0 : if ( p_bind_list != NULL )
44256 : {
44257 0 : if ( p_bind_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44258 : {
44259 0 : if ( p_bind_list->isInMemoryPool() == false )
44260 : {
44261 0 : std::cout << "SgAttributeSpecificationStatement :: ";
44262 0 : std::cout << " p_bind_list is not in memory pool of ";
44263 0 : std::cout << p_bind_list->class_name() << std::endl;
44264 : }
44265 : }
44266 : else
44267 : {
44268 0 : std::cout << "SgAttributeSpecificationStatement :: " << std::flush;
44269 0 : std::cout << "SgExprListExp* p_bind_list = " << p_bind_list << " --> " << std::flush;
44270 0 : std::cout << " not valid " << std::endl;
44271 : }
44272 : }
44273 :
44274 0 : SgDimensionObjectPtrList::iterator i_dimension_object_list = p_dimension_object_list.begin() ;
44275 0 : for ( ; i_dimension_object_list != p_dimension_object_list.end(); ++i_dimension_object_list )
44276 : {
44277 0 : if ( (*i_dimension_object_list) != NULL )
44278 : {
44279 0 : if ( (*i_dimension_object_list)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44280 : {
44281 0 : if ( (*i_dimension_object_list)->isInMemoryPool() == false )
44282 : {
44283 0 : std::cout << "SgAttributeSpecificationStatement :: ";
44284 0 : std::cout << " p_dimension_object_list ( list of poitners to IR nodes ), entry is not in memory pool of ";
44285 0 : std::cout << (*i_dimension_object_list)->class_name() << std::endl;
44286 : }
44287 : }
44288 : else
44289 : {
44290 0 : std::cout << "SgAttributeSpecificationStatement :: " << std::flush;
44291 0 : std::cout << "SgDimensionObjectPtrList p_dimension_object_list --> " << std::flush;
44292 0 : std::cout << " entry not valid " << std::endl;
44293 : }
44294 : }
44295 : else
44296 : {
44297 0 : std::cout << "SgDimensionObjectPtrList p_dimension_object_list --> NULL " << std::endl;
44298 : }
44299 : }
44300 :
44301 0 : if ( p_definingDeclaration != NULL )
44302 : {
44303 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44304 : {
44305 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
44306 : {
44307 0 : std::cout << "SgAttributeSpecificationStatement :: ";
44308 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
44309 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
44310 : }
44311 : }
44312 : else
44313 : {
44314 0 : std::cout << "SgAttributeSpecificationStatement :: " << std::flush;
44315 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
44316 0 : std::cout << " not valid " << std::endl;
44317 : }
44318 : }
44319 :
44320 0 : if ( p_firstNondefiningDeclaration != NULL )
44321 : {
44322 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44323 : {
44324 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
44325 : {
44326 0 : std::cout << "SgAttributeSpecificationStatement :: ";
44327 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
44328 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
44329 : }
44330 : }
44331 : else
44332 : {
44333 0 : std::cout << "SgAttributeSpecificationStatement :: " << std::flush;
44334 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
44335 0 : std::cout << " not valid " << std::endl;
44336 : }
44337 : }
44338 :
44339 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
44340 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
44341 : {
44342 0 : if ( (*i_qualifiedNameList) != NULL )
44343 : {
44344 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44345 : {
44346 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
44347 : {
44348 0 : std::cout << "SgAttributeSpecificationStatement :: ";
44349 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
44350 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
44351 : }
44352 : }
44353 : else
44354 : {
44355 0 : std::cout << "SgAttributeSpecificationStatement :: " << std::flush;
44356 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
44357 0 : std::cout << " entry not valid " << std::endl;
44358 : }
44359 : }
44360 : else
44361 : {
44362 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
44363 : }
44364 : }
44365 :
44366 0 : if ( p_declarationScope != NULL )
44367 : {
44368 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44369 : {
44370 0 : if ( p_declarationScope->isInMemoryPool() == false )
44371 : {
44372 0 : std::cout << "SgAttributeSpecificationStatement :: ";
44373 0 : std::cout << " p_declarationScope is not in memory pool of ";
44374 0 : std::cout << p_declarationScope->class_name() << std::endl;
44375 : }
44376 : }
44377 : else
44378 : {
44379 0 : std::cout << "SgAttributeSpecificationStatement :: " << std::flush;
44380 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
44381 0 : std::cout << " not valid " << std::endl;
44382 : }
44383 : }
44384 :
44385 0 : if ( p_numeric_label != NULL )
44386 : {
44387 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44388 : {
44389 0 : if ( p_numeric_label->isInMemoryPool() == false )
44390 : {
44391 0 : std::cout << "SgAttributeSpecificationStatement :: ";
44392 0 : std::cout << " p_numeric_label is not in memory pool of ";
44393 0 : std::cout << p_numeric_label->class_name() << std::endl;
44394 : }
44395 : }
44396 : else
44397 : {
44398 0 : std::cout << "SgAttributeSpecificationStatement :: " << std::flush;
44399 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
44400 0 : std::cout << " not valid " << std::endl;
44401 : }
44402 : }
44403 :
44404 0 : if ( p_startOfConstruct != NULL )
44405 : {
44406 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44407 : {
44408 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
44409 : {
44410 0 : std::cout << "SgAttributeSpecificationStatement :: ";
44411 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
44412 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
44413 : }
44414 : }
44415 : else
44416 : {
44417 0 : std::cout << "SgAttributeSpecificationStatement :: " << std::flush;
44418 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
44419 0 : std::cout << " not valid " << std::endl;
44420 : }
44421 : }
44422 :
44423 0 : if ( p_endOfConstruct != NULL )
44424 : {
44425 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44426 : {
44427 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
44428 : {
44429 0 : std::cout << "SgAttributeSpecificationStatement :: ";
44430 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
44431 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
44432 : }
44433 : }
44434 : else
44435 : {
44436 0 : std::cout << "SgAttributeSpecificationStatement :: " << std::flush;
44437 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
44438 0 : std::cout << " not valid " << std::endl;
44439 : }
44440 : }
44441 :
44442 0 : if ( p_parent != NULL )
44443 : {
44444 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44445 : {
44446 0 : if ( p_parent->isInMemoryPool() == false )
44447 : {
44448 0 : std::cout << "SgAttributeSpecificationStatement :: ";
44449 0 : std::cout << " p_parent is not in memory pool of ";
44450 0 : std::cout << p_parent->class_name() << std::endl;
44451 : }
44452 : }
44453 : else
44454 : {
44455 0 : std::cout << "SgAttributeSpecificationStatement :: " << std::flush;
44456 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
44457 0 : std::cout << " not valid " << std::endl;
44458 : }
44459 : }
44460 :
44461 :
44462 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
44463 :
44464 0 : }
44465 :
44466 :
44467 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
44468 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
44469 : bool
44470 0 : SgAttributeSpecificationStatement::isInMemoryPool ()
44471 : {
44472 0 : typedef unsigned char* TestType;
44473 :
44474 0 : bool found = false;
44475 :
44476 0 : ROSE_ASSERT(this != NULL);
44477 :
44478 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
44479 :
44480 0 : TestType tested = (TestType) ( this ) ;
44481 :
44482 0 : std::vector < unsigned char* > :: const_iterator block = SgAttributeSpecificationStatement::pools.begin();
44483 :
44484 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
44485 : // while (found == false && block < Memory_Block_List.end())
44486 0 : while ( (found == false) && (block != SgAttributeSpecificationStatement::pools.end()) )
44487 : {
44488 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAttributeSpecificationStatement::pool_size * sizeof(SgAttributeSpecificationStatement) ) ) ;
44489 0 : ++block;
44490 : }
44491 :
44492 : // Special handling for static data
44493 :
44494 :
44495 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
44496 0 : ROSE_ASSERT(found == true);
44497 :
44498 0 : return found;
44499 : }
44500 : /* #line 44501 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
44501 :
44502 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
44503 :
44504 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
44505 :
44506 : /* #line 44507 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
44507 :
44508 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
44509 :
44510 : void
44511 0 : SgFormatStatement::checkDataMemberPointersIfInMemoryPool()
44512 : {
44513 : // ------------ checking pointers of SgFormatStatement -------------------
44514 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
44515 :
44516 0 : if ( p_format_item_list != NULL )
44517 : {
44518 0 : if ( p_format_item_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44519 : {
44520 0 : if ( p_format_item_list->isInMemoryPool() == false )
44521 : {
44522 0 : std::cout << "SgFormatStatement :: ";
44523 0 : std::cout << " p_format_item_list is not in memory pool of ";
44524 0 : std::cout << p_format_item_list->class_name() << std::endl;
44525 : }
44526 : }
44527 : else
44528 : {
44529 0 : std::cout << "SgFormatStatement :: " << std::flush;
44530 0 : std::cout << "SgFormatItemList* p_format_item_list = " << p_format_item_list << " --> " << std::flush;
44531 0 : std::cout << " not valid " << std::endl;
44532 : }
44533 : }
44534 :
44535 0 : if ( p_definingDeclaration != NULL )
44536 : {
44537 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44538 : {
44539 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
44540 : {
44541 0 : std::cout << "SgFormatStatement :: ";
44542 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
44543 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
44544 : }
44545 : }
44546 : else
44547 : {
44548 0 : std::cout << "SgFormatStatement :: " << std::flush;
44549 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
44550 0 : std::cout << " not valid " << std::endl;
44551 : }
44552 : }
44553 :
44554 0 : if ( p_firstNondefiningDeclaration != NULL )
44555 : {
44556 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44557 : {
44558 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
44559 : {
44560 0 : std::cout << "SgFormatStatement :: ";
44561 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
44562 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
44563 : }
44564 : }
44565 : else
44566 : {
44567 0 : std::cout << "SgFormatStatement :: " << std::flush;
44568 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
44569 0 : std::cout << " not valid " << std::endl;
44570 : }
44571 : }
44572 :
44573 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
44574 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
44575 : {
44576 0 : if ( (*i_qualifiedNameList) != NULL )
44577 : {
44578 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44579 : {
44580 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
44581 : {
44582 0 : std::cout << "SgFormatStatement :: ";
44583 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
44584 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
44585 : }
44586 : }
44587 : else
44588 : {
44589 0 : std::cout << "SgFormatStatement :: " << std::flush;
44590 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
44591 0 : std::cout << " entry not valid " << std::endl;
44592 : }
44593 : }
44594 : else
44595 : {
44596 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
44597 : }
44598 : }
44599 :
44600 0 : if ( p_declarationScope != NULL )
44601 : {
44602 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44603 : {
44604 0 : if ( p_declarationScope->isInMemoryPool() == false )
44605 : {
44606 0 : std::cout << "SgFormatStatement :: ";
44607 0 : std::cout << " p_declarationScope is not in memory pool of ";
44608 0 : std::cout << p_declarationScope->class_name() << std::endl;
44609 : }
44610 : }
44611 : else
44612 : {
44613 0 : std::cout << "SgFormatStatement :: " << std::flush;
44614 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
44615 0 : std::cout << " not valid " << std::endl;
44616 : }
44617 : }
44618 :
44619 0 : if ( p_numeric_label != NULL )
44620 : {
44621 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44622 : {
44623 0 : if ( p_numeric_label->isInMemoryPool() == false )
44624 : {
44625 0 : std::cout << "SgFormatStatement :: ";
44626 0 : std::cout << " p_numeric_label is not in memory pool of ";
44627 0 : std::cout << p_numeric_label->class_name() << std::endl;
44628 : }
44629 : }
44630 : else
44631 : {
44632 0 : std::cout << "SgFormatStatement :: " << std::flush;
44633 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
44634 0 : std::cout << " not valid " << std::endl;
44635 : }
44636 : }
44637 :
44638 0 : if ( p_startOfConstruct != NULL )
44639 : {
44640 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44641 : {
44642 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
44643 : {
44644 0 : std::cout << "SgFormatStatement :: ";
44645 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
44646 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
44647 : }
44648 : }
44649 : else
44650 : {
44651 0 : std::cout << "SgFormatStatement :: " << std::flush;
44652 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
44653 0 : std::cout << " not valid " << std::endl;
44654 : }
44655 : }
44656 :
44657 0 : if ( p_endOfConstruct != NULL )
44658 : {
44659 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44660 : {
44661 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
44662 : {
44663 0 : std::cout << "SgFormatStatement :: ";
44664 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
44665 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
44666 : }
44667 : }
44668 : else
44669 : {
44670 0 : std::cout << "SgFormatStatement :: " << std::flush;
44671 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
44672 0 : std::cout << " not valid " << std::endl;
44673 : }
44674 : }
44675 :
44676 0 : if ( p_parent != NULL )
44677 : {
44678 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44679 : {
44680 0 : if ( p_parent->isInMemoryPool() == false )
44681 : {
44682 0 : std::cout << "SgFormatStatement :: ";
44683 0 : std::cout << " p_parent is not in memory pool of ";
44684 0 : std::cout << p_parent->class_name() << std::endl;
44685 : }
44686 : }
44687 : else
44688 : {
44689 0 : std::cout << "SgFormatStatement :: " << std::flush;
44690 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
44691 0 : std::cout << " not valid " << std::endl;
44692 : }
44693 : }
44694 :
44695 :
44696 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
44697 :
44698 0 : }
44699 :
44700 :
44701 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
44702 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
44703 : bool
44704 0 : SgFormatStatement::isInMemoryPool ()
44705 : {
44706 0 : typedef unsigned char* TestType;
44707 :
44708 0 : bool found = false;
44709 :
44710 0 : ROSE_ASSERT(this != NULL);
44711 :
44712 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
44713 :
44714 0 : TestType tested = (TestType) ( this ) ;
44715 :
44716 0 : std::vector < unsigned char* > :: const_iterator block = SgFormatStatement::pools.begin();
44717 :
44718 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
44719 : // while (found == false && block < Memory_Block_List.end())
44720 0 : while ( (found == false) && (block != SgFormatStatement::pools.end()) )
44721 : {
44722 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFormatStatement::pool_size * sizeof(SgFormatStatement) ) ) ;
44723 0 : ++block;
44724 : }
44725 :
44726 : // Special handling for static data
44727 :
44728 :
44729 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
44730 0 : ROSE_ASSERT(found == true);
44731 :
44732 0 : return found;
44733 : }
44734 : /* #line 44735 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
44735 :
44736 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
44737 :
44738 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
44739 :
44740 : /* #line 44741 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
44741 :
44742 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
44743 :
44744 : void
44745 0 : SgTemplateDeclaration::checkDataMemberPointersIfInMemoryPool()
44746 : {
44747 : // ------------ checking pointers of SgTemplateDeclaration -------------------
44748 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
44749 :
44750 0 : SgTemplateParameterPtrList::iterator i_templateParameters = p_templateParameters.begin() ;
44751 0 : for ( ; i_templateParameters != p_templateParameters.end(); ++i_templateParameters )
44752 : {
44753 0 : if ( (*i_templateParameters) != NULL )
44754 : {
44755 0 : if ( (*i_templateParameters)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44756 : {
44757 0 : if ( (*i_templateParameters)->isInMemoryPool() == false )
44758 : {
44759 0 : std::cout << "SgTemplateDeclaration :: ";
44760 0 : std::cout << " p_templateParameters ( list of poitners to IR nodes ), entry is not in memory pool of ";
44761 0 : std::cout << (*i_templateParameters)->class_name() << std::endl;
44762 : }
44763 : }
44764 : else
44765 : {
44766 0 : std::cout << "SgTemplateDeclaration :: " << std::flush;
44767 0 : std::cout << "SgTemplateParameterPtrList p_templateParameters --> " << std::flush;
44768 0 : std::cout << " entry not valid " << std::endl;
44769 : }
44770 : }
44771 : else
44772 : {
44773 0 : std::cout << "SgTemplateParameterPtrList p_templateParameters --> NULL " << std::endl;
44774 : }
44775 : }
44776 :
44777 0 : if ( p_scope != NULL )
44778 : {
44779 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44780 : {
44781 0 : if ( p_scope->isInMemoryPool() == false )
44782 : {
44783 0 : std::cout << "SgTemplateDeclaration :: ";
44784 0 : std::cout << " p_scope is not in memory pool of ";
44785 0 : std::cout << p_scope->class_name() << std::endl;
44786 : }
44787 : }
44788 : else
44789 : {
44790 0 : std::cout << "SgTemplateDeclaration :: " << std::flush;
44791 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
44792 0 : std::cout << " not valid " << std::endl;
44793 : }
44794 : }
44795 :
44796 0 : if ( p_nonreal_decl_scope != NULL )
44797 : {
44798 0 : if ( p_nonreal_decl_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44799 : {
44800 0 : if ( p_nonreal_decl_scope->isInMemoryPool() == false )
44801 : {
44802 0 : std::cout << "SgTemplateDeclaration :: ";
44803 0 : std::cout << " p_nonreal_decl_scope is not in memory pool of ";
44804 0 : std::cout << p_nonreal_decl_scope->class_name() << std::endl;
44805 : }
44806 : }
44807 : else
44808 : {
44809 0 : std::cout << "SgTemplateDeclaration :: " << std::flush;
44810 0 : std::cout << "SgDeclarationScope* p_nonreal_decl_scope = " << p_nonreal_decl_scope << " --> " << std::flush;
44811 0 : std::cout << " not valid " << std::endl;
44812 : }
44813 : }
44814 :
44815 0 : if ( p_definingDeclaration != NULL )
44816 : {
44817 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44818 : {
44819 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
44820 : {
44821 0 : std::cout << "SgTemplateDeclaration :: ";
44822 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
44823 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
44824 : }
44825 : }
44826 : else
44827 : {
44828 0 : std::cout << "SgTemplateDeclaration :: " << std::flush;
44829 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
44830 0 : std::cout << " not valid " << std::endl;
44831 : }
44832 : }
44833 :
44834 0 : if ( p_firstNondefiningDeclaration != NULL )
44835 : {
44836 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44837 : {
44838 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
44839 : {
44840 0 : std::cout << "SgTemplateDeclaration :: ";
44841 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
44842 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
44843 : }
44844 : }
44845 : else
44846 : {
44847 0 : std::cout << "SgTemplateDeclaration :: " << std::flush;
44848 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
44849 0 : std::cout << " not valid " << std::endl;
44850 : }
44851 : }
44852 :
44853 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
44854 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
44855 : {
44856 0 : if ( (*i_qualifiedNameList) != NULL )
44857 : {
44858 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44859 : {
44860 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
44861 : {
44862 0 : std::cout << "SgTemplateDeclaration :: ";
44863 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
44864 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
44865 : }
44866 : }
44867 : else
44868 : {
44869 0 : std::cout << "SgTemplateDeclaration :: " << std::flush;
44870 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
44871 0 : std::cout << " entry not valid " << std::endl;
44872 : }
44873 : }
44874 : else
44875 : {
44876 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
44877 : }
44878 : }
44879 :
44880 0 : if ( p_declarationScope != NULL )
44881 : {
44882 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44883 : {
44884 0 : if ( p_declarationScope->isInMemoryPool() == false )
44885 : {
44886 0 : std::cout << "SgTemplateDeclaration :: ";
44887 0 : std::cout << " p_declarationScope is not in memory pool of ";
44888 0 : std::cout << p_declarationScope->class_name() << std::endl;
44889 : }
44890 : }
44891 : else
44892 : {
44893 0 : std::cout << "SgTemplateDeclaration :: " << std::flush;
44894 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
44895 0 : std::cout << " not valid " << std::endl;
44896 : }
44897 : }
44898 :
44899 0 : if ( p_numeric_label != NULL )
44900 : {
44901 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44902 : {
44903 0 : if ( p_numeric_label->isInMemoryPool() == false )
44904 : {
44905 0 : std::cout << "SgTemplateDeclaration :: ";
44906 0 : std::cout << " p_numeric_label is not in memory pool of ";
44907 0 : std::cout << p_numeric_label->class_name() << std::endl;
44908 : }
44909 : }
44910 : else
44911 : {
44912 0 : std::cout << "SgTemplateDeclaration :: " << std::flush;
44913 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
44914 0 : std::cout << " not valid " << std::endl;
44915 : }
44916 : }
44917 :
44918 0 : if ( p_startOfConstruct != NULL )
44919 : {
44920 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44921 : {
44922 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
44923 : {
44924 0 : std::cout << "SgTemplateDeclaration :: ";
44925 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
44926 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
44927 : }
44928 : }
44929 : else
44930 : {
44931 0 : std::cout << "SgTemplateDeclaration :: " << std::flush;
44932 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
44933 0 : std::cout << " not valid " << std::endl;
44934 : }
44935 : }
44936 :
44937 0 : if ( p_endOfConstruct != NULL )
44938 : {
44939 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44940 : {
44941 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
44942 : {
44943 0 : std::cout << "SgTemplateDeclaration :: ";
44944 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
44945 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
44946 : }
44947 : }
44948 : else
44949 : {
44950 0 : std::cout << "SgTemplateDeclaration :: " << std::flush;
44951 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
44952 0 : std::cout << " not valid " << std::endl;
44953 : }
44954 : }
44955 :
44956 0 : if ( p_parent != NULL )
44957 : {
44958 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
44959 : {
44960 0 : if ( p_parent->isInMemoryPool() == false )
44961 : {
44962 0 : std::cout << "SgTemplateDeclaration :: ";
44963 0 : std::cout << " p_parent is not in memory pool of ";
44964 0 : std::cout << p_parent->class_name() << std::endl;
44965 : }
44966 : }
44967 : else
44968 : {
44969 0 : std::cout << "SgTemplateDeclaration :: " << std::flush;
44970 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
44971 0 : std::cout << " not valid " << std::endl;
44972 : }
44973 : }
44974 :
44975 :
44976 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
44977 :
44978 0 : }
44979 :
44980 :
44981 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
44982 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
44983 : bool
44984 0 : SgTemplateDeclaration::isInMemoryPool ()
44985 : {
44986 0 : typedef unsigned char* TestType;
44987 :
44988 0 : bool found = false;
44989 :
44990 0 : ROSE_ASSERT(this != NULL);
44991 :
44992 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
44993 :
44994 0 : TestType tested = (TestType) ( this ) ;
44995 :
44996 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateDeclaration::pools.begin();
44997 :
44998 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
44999 : // while (found == false && block < Memory_Block_List.end())
45000 0 : while ( (found == false) && (block != SgTemplateDeclaration::pools.end()) )
45001 : {
45002 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateDeclaration::pool_size * sizeof(SgTemplateDeclaration) ) ) ;
45003 0 : ++block;
45004 : }
45005 :
45006 : // Special handling for static data
45007 :
45008 :
45009 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
45010 0 : ROSE_ASSERT(found == true);
45011 :
45012 0 : return found;
45013 : }
45014 : /* #line 45015 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
45015 :
45016 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
45017 :
45018 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
45019 :
45020 : /* #line 45021 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
45021 :
45022 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
45023 :
45024 : void
45025 0 : SgTemplateInstantiationDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
45026 : {
45027 : // ------------ checking pointers of SgTemplateInstantiationDirectiveStatement -------------------
45028 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
45029 :
45030 0 : if ( p_declaration != NULL )
45031 : {
45032 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45033 : {
45034 0 : if ( p_declaration->isInMemoryPool() == false )
45035 : {
45036 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: ";
45037 0 : std::cout << " p_declaration is not in memory pool of ";
45038 0 : std::cout << p_declaration->class_name() << std::endl;
45039 : }
45040 : }
45041 : else
45042 : {
45043 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: " << std::flush;
45044 0 : std::cout << "SgDeclarationStatement* p_declaration = " << p_declaration << " --> " << std::flush;
45045 0 : std::cout << " not valid " << std::endl;
45046 : }
45047 : }
45048 :
45049 0 : if ( p_definingDeclaration != NULL )
45050 : {
45051 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45052 : {
45053 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
45054 : {
45055 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: ";
45056 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
45057 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
45058 : }
45059 : }
45060 : else
45061 : {
45062 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: " << std::flush;
45063 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
45064 0 : std::cout << " not valid " << std::endl;
45065 : }
45066 : }
45067 :
45068 0 : if ( p_firstNondefiningDeclaration != NULL )
45069 : {
45070 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45071 : {
45072 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
45073 : {
45074 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: ";
45075 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
45076 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
45077 : }
45078 : }
45079 : else
45080 : {
45081 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: " << std::flush;
45082 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
45083 0 : std::cout << " not valid " << std::endl;
45084 : }
45085 : }
45086 :
45087 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
45088 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
45089 : {
45090 0 : if ( (*i_qualifiedNameList) != NULL )
45091 : {
45092 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45093 : {
45094 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
45095 : {
45096 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: ";
45097 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
45098 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
45099 : }
45100 : }
45101 : else
45102 : {
45103 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: " << std::flush;
45104 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
45105 0 : std::cout << " entry not valid " << std::endl;
45106 : }
45107 : }
45108 : else
45109 : {
45110 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
45111 : }
45112 : }
45113 :
45114 0 : if ( p_declarationScope != NULL )
45115 : {
45116 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45117 : {
45118 0 : if ( p_declarationScope->isInMemoryPool() == false )
45119 : {
45120 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: ";
45121 0 : std::cout << " p_declarationScope is not in memory pool of ";
45122 0 : std::cout << p_declarationScope->class_name() << std::endl;
45123 : }
45124 : }
45125 : else
45126 : {
45127 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: " << std::flush;
45128 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
45129 0 : std::cout << " not valid " << std::endl;
45130 : }
45131 : }
45132 :
45133 0 : if ( p_numeric_label != NULL )
45134 : {
45135 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45136 : {
45137 0 : if ( p_numeric_label->isInMemoryPool() == false )
45138 : {
45139 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: ";
45140 0 : std::cout << " p_numeric_label is not in memory pool of ";
45141 0 : std::cout << p_numeric_label->class_name() << std::endl;
45142 : }
45143 : }
45144 : else
45145 : {
45146 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: " << std::flush;
45147 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
45148 0 : std::cout << " not valid " << std::endl;
45149 : }
45150 : }
45151 :
45152 0 : if ( p_startOfConstruct != NULL )
45153 : {
45154 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45155 : {
45156 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
45157 : {
45158 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: ";
45159 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
45160 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
45161 : }
45162 : }
45163 : else
45164 : {
45165 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: " << std::flush;
45166 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
45167 0 : std::cout << " not valid " << std::endl;
45168 : }
45169 : }
45170 :
45171 0 : if ( p_endOfConstruct != NULL )
45172 : {
45173 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45174 : {
45175 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
45176 : {
45177 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: ";
45178 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
45179 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
45180 : }
45181 : }
45182 : else
45183 : {
45184 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: " << std::flush;
45185 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
45186 0 : std::cout << " not valid " << std::endl;
45187 : }
45188 : }
45189 :
45190 0 : if ( p_parent != NULL )
45191 : {
45192 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45193 : {
45194 0 : if ( p_parent->isInMemoryPool() == false )
45195 : {
45196 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: ";
45197 0 : std::cout << " p_parent is not in memory pool of ";
45198 0 : std::cout << p_parent->class_name() << std::endl;
45199 : }
45200 : }
45201 : else
45202 : {
45203 0 : std::cout << "SgTemplateInstantiationDirectiveStatement :: " << std::flush;
45204 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
45205 0 : std::cout << " not valid " << std::endl;
45206 : }
45207 : }
45208 :
45209 :
45210 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
45211 :
45212 0 : }
45213 :
45214 :
45215 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
45216 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
45217 : bool
45218 0 : SgTemplateInstantiationDirectiveStatement::isInMemoryPool ()
45219 : {
45220 0 : typedef unsigned char* TestType;
45221 :
45222 0 : bool found = false;
45223 :
45224 0 : ROSE_ASSERT(this != NULL);
45225 :
45226 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
45227 :
45228 0 : TestType tested = (TestType) ( this ) ;
45229 :
45230 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateInstantiationDirectiveStatement::pools.begin();
45231 :
45232 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
45233 : // while (found == false && block < Memory_Block_List.end())
45234 0 : while ( (found == false) && (block != SgTemplateInstantiationDirectiveStatement::pools.end()) )
45235 : {
45236 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateInstantiationDirectiveStatement::pool_size * sizeof(SgTemplateInstantiationDirectiveStatement) ) ) ;
45237 0 : ++block;
45238 : }
45239 :
45240 : // Special handling for static data
45241 :
45242 :
45243 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
45244 0 : ROSE_ASSERT(found == true);
45245 :
45246 0 : return found;
45247 : }
45248 : /* #line 45249 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
45249 :
45250 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
45251 :
45252 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
45253 :
45254 : /* #line 45255 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
45255 :
45256 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
45257 :
45258 : void
45259 0 : SgUseStatement::checkDataMemberPointersIfInMemoryPool()
45260 : {
45261 : // ------------ checking pointers of SgUseStatement -------------------
45262 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
45263 :
45264 0 : SgRenamePairPtrList::iterator i_rename_list = p_rename_list.begin() ;
45265 0 : for ( ; i_rename_list != p_rename_list.end(); ++i_rename_list )
45266 : {
45267 0 : if ( (*i_rename_list) != NULL )
45268 : {
45269 0 : if ( (*i_rename_list)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45270 : {
45271 0 : if ( (*i_rename_list)->isInMemoryPool() == false )
45272 : {
45273 0 : std::cout << "SgUseStatement :: ";
45274 0 : std::cout << " p_rename_list ( list of poitners to IR nodes ), entry is not in memory pool of ";
45275 0 : std::cout << (*i_rename_list)->class_name() << std::endl;
45276 : }
45277 : }
45278 : else
45279 : {
45280 0 : std::cout << "SgUseStatement :: " << std::flush;
45281 0 : std::cout << "SgRenamePairPtrList p_rename_list --> " << std::flush;
45282 0 : std::cout << " entry not valid " << std::endl;
45283 : }
45284 : }
45285 : else
45286 : {
45287 0 : std::cout << "SgRenamePairPtrList p_rename_list --> NULL " << std::endl;
45288 : }
45289 : }
45290 :
45291 0 : if ( p_module != NULL )
45292 : {
45293 0 : if ( p_module->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45294 : {
45295 0 : if ( p_module->isInMemoryPool() == false )
45296 : {
45297 0 : std::cout << "SgUseStatement :: ";
45298 0 : std::cout << " p_module is not in memory pool of ";
45299 0 : std::cout << p_module->class_name() << std::endl;
45300 : }
45301 : }
45302 : else
45303 : {
45304 0 : std::cout << "SgUseStatement :: " << std::flush;
45305 0 : std::cout << "SgModuleStatement* p_module = " << p_module << " --> " << std::flush;
45306 0 : std::cout << " not valid " << std::endl;
45307 : }
45308 : }
45309 :
45310 0 : if ( p_definingDeclaration != NULL )
45311 : {
45312 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45313 : {
45314 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
45315 : {
45316 0 : std::cout << "SgUseStatement :: ";
45317 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
45318 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
45319 : }
45320 : }
45321 : else
45322 : {
45323 0 : std::cout << "SgUseStatement :: " << std::flush;
45324 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
45325 0 : std::cout << " not valid " << std::endl;
45326 : }
45327 : }
45328 :
45329 0 : if ( p_firstNondefiningDeclaration != NULL )
45330 : {
45331 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45332 : {
45333 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
45334 : {
45335 0 : std::cout << "SgUseStatement :: ";
45336 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
45337 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
45338 : }
45339 : }
45340 : else
45341 : {
45342 0 : std::cout << "SgUseStatement :: " << std::flush;
45343 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
45344 0 : std::cout << " not valid " << std::endl;
45345 : }
45346 : }
45347 :
45348 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
45349 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
45350 : {
45351 0 : if ( (*i_qualifiedNameList) != NULL )
45352 : {
45353 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45354 : {
45355 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
45356 : {
45357 0 : std::cout << "SgUseStatement :: ";
45358 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
45359 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
45360 : }
45361 : }
45362 : else
45363 : {
45364 0 : std::cout << "SgUseStatement :: " << std::flush;
45365 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
45366 0 : std::cout << " entry not valid " << std::endl;
45367 : }
45368 : }
45369 : else
45370 : {
45371 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
45372 : }
45373 : }
45374 :
45375 0 : if ( p_declarationScope != NULL )
45376 : {
45377 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45378 : {
45379 0 : if ( p_declarationScope->isInMemoryPool() == false )
45380 : {
45381 0 : std::cout << "SgUseStatement :: ";
45382 0 : std::cout << " p_declarationScope is not in memory pool of ";
45383 0 : std::cout << p_declarationScope->class_name() << std::endl;
45384 : }
45385 : }
45386 : else
45387 : {
45388 0 : std::cout << "SgUseStatement :: " << std::flush;
45389 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
45390 0 : std::cout << " not valid " << std::endl;
45391 : }
45392 : }
45393 :
45394 0 : if ( p_numeric_label != NULL )
45395 : {
45396 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45397 : {
45398 0 : if ( p_numeric_label->isInMemoryPool() == false )
45399 : {
45400 0 : std::cout << "SgUseStatement :: ";
45401 0 : std::cout << " p_numeric_label is not in memory pool of ";
45402 0 : std::cout << p_numeric_label->class_name() << std::endl;
45403 : }
45404 : }
45405 : else
45406 : {
45407 0 : std::cout << "SgUseStatement :: " << std::flush;
45408 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
45409 0 : std::cout << " not valid " << std::endl;
45410 : }
45411 : }
45412 :
45413 0 : if ( p_startOfConstruct != NULL )
45414 : {
45415 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45416 : {
45417 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
45418 : {
45419 0 : std::cout << "SgUseStatement :: ";
45420 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
45421 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
45422 : }
45423 : }
45424 : else
45425 : {
45426 0 : std::cout << "SgUseStatement :: " << std::flush;
45427 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
45428 0 : std::cout << " not valid " << std::endl;
45429 : }
45430 : }
45431 :
45432 0 : if ( p_endOfConstruct != NULL )
45433 : {
45434 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45435 : {
45436 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
45437 : {
45438 0 : std::cout << "SgUseStatement :: ";
45439 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
45440 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
45441 : }
45442 : }
45443 : else
45444 : {
45445 0 : std::cout << "SgUseStatement :: " << std::flush;
45446 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
45447 0 : std::cout << " not valid " << std::endl;
45448 : }
45449 : }
45450 :
45451 0 : if ( p_parent != NULL )
45452 : {
45453 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45454 : {
45455 0 : if ( p_parent->isInMemoryPool() == false )
45456 : {
45457 0 : std::cout << "SgUseStatement :: ";
45458 0 : std::cout << " p_parent is not in memory pool of ";
45459 0 : std::cout << p_parent->class_name() << std::endl;
45460 : }
45461 : }
45462 : else
45463 : {
45464 0 : std::cout << "SgUseStatement :: " << std::flush;
45465 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
45466 0 : std::cout << " not valid " << std::endl;
45467 : }
45468 : }
45469 :
45470 :
45471 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
45472 :
45473 0 : }
45474 :
45475 :
45476 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
45477 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
45478 : bool
45479 0 : SgUseStatement::isInMemoryPool ()
45480 : {
45481 0 : typedef unsigned char* TestType;
45482 :
45483 0 : bool found = false;
45484 :
45485 0 : ROSE_ASSERT(this != NULL);
45486 :
45487 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
45488 :
45489 0 : TestType tested = (TestType) ( this ) ;
45490 :
45491 0 : std::vector < unsigned char* > :: const_iterator block = SgUseStatement::pools.begin();
45492 :
45493 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
45494 : // while (found == false && block < Memory_Block_List.end())
45495 0 : while ( (found == false) && (block != SgUseStatement::pools.end()) )
45496 : {
45497 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUseStatement::pool_size * sizeof(SgUseStatement) ) ) ;
45498 0 : ++block;
45499 : }
45500 :
45501 : // Special handling for static data
45502 :
45503 :
45504 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
45505 0 : ROSE_ASSERT(found == true);
45506 :
45507 0 : return found;
45508 : }
45509 : /* #line 45510 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
45510 :
45511 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
45512 :
45513 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
45514 :
45515 : /* #line 45516 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
45516 :
45517 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
45518 :
45519 : void
45520 0 : SgParameterStatement::checkDataMemberPointersIfInMemoryPool()
45521 : {
45522 : // ------------ checking pointers of SgParameterStatement -------------------
45523 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
45524 :
45525 0 : if ( p_definingDeclaration != NULL )
45526 : {
45527 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45528 : {
45529 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
45530 : {
45531 0 : std::cout << "SgParameterStatement :: ";
45532 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
45533 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
45534 : }
45535 : }
45536 : else
45537 : {
45538 0 : std::cout << "SgParameterStatement :: " << std::flush;
45539 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
45540 0 : std::cout << " not valid " << std::endl;
45541 : }
45542 : }
45543 :
45544 0 : if ( p_firstNondefiningDeclaration != NULL )
45545 : {
45546 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45547 : {
45548 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
45549 : {
45550 0 : std::cout << "SgParameterStatement :: ";
45551 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
45552 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
45553 : }
45554 : }
45555 : else
45556 : {
45557 0 : std::cout << "SgParameterStatement :: " << std::flush;
45558 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
45559 0 : std::cout << " not valid " << std::endl;
45560 : }
45561 : }
45562 :
45563 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
45564 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
45565 : {
45566 0 : if ( (*i_qualifiedNameList) != NULL )
45567 : {
45568 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45569 : {
45570 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
45571 : {
45572 0 : std::cout << "SgParameterStatement :: ";
45573 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
45574 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
45575 : }
45576 : }
45577 : else
45578 : {
45579 0 : std::cout << "SgParameterStatement :: " << std::flush;
45580 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
45581 0 : std::cout << " entry not valid " << std::endl;
45582 : }
45583 : }
45584 : else
45585 : {
45586 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
45587 : }
45588 : }
45589 :
45590 0 : if ( p_declarationScope != NULL )
45591 : {
45592 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45593 : {
45594 0 : if ( p_declarationScope->isInMemoryPool() == false )
45595 : {
45596 0 : std::cout << "SgParameterStatement :: ";
45597 0 : std::cout << " p_declarationScope is not in memory pool of ";
45598 0 : std::cout << p_declarationScope->class_name() << std::endl;
45599 : }
45600 : }
45601 : else
45602 : {
45603 0 : std::cout << "SgParameterStatement :: " << std::flush;
45604 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
45605 0 : std::cout << " not valid " << std::endl;
45606 : }
45607 : }
45608 :
45609 0 : if ( p_numeric_label != NULL )
45610 : {
45611 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45612 : {
45613 0 : if ( p_numeric_label->isInMemoryPool() == false )
45614 : {
45615 0 : std::cout << "SgParameterStatement :: ";
45616 0 : std::cout << " p_numeric_label is not in memory pool of ";
45617 0 : std::cout << p_numeric_label->class_name() << std::endl;
45618 : }
45619 : }
45620 : else
45621 : {
45622 0 : std::cout << "SgParameterStatement :: " << std::flush;
45623 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
45624 0 : std::cout << " not valid " << std::endl;
45625 : }
45626 : }
45627 :
45628 0 : if ( p_startOfConstruct != NULL )
45629 : {
45630 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45631 : {
45632 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
45633 : {
45634 0 : std::cout << "SgParameterStatement :: ";
45635 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
45636 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
45637 : }
45638 : }
45639 : else
45640 : {
45641 0 : std::cout << "SgParameterStatement :: " << std::flush;
45642 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
45643 0 : std::cout << " not valid " << std::endl;
45644 : }
45645 : }
45646 :
45647 0 : if ( p_endOfConstruct != NULL )
45648 : {
45649 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45650 : {
45651 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
45652 : {
45653 0 : std::cout << "SgParameterStatement :: ";
45654 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
45655 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
45656 : }
45657 : }
45658 : else
45659 : {
45660 0 : std::cout << "SgParameterStatement :: " << std::flush;
45661 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
45662 0 : std::cout << " not valid " << std::endl;
45663 : }
45664 : }
45665 :
45666 0 : if ( p_parent != NULL )
45667 : {
45668 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45669 : {
45670 0 : if ( p_parent->isInMemoryPool() == false )
45671 : {
45672 0 : std::cout << "SgParameterStatement :: ";
45673 0 : std::cout << " p_parent is not in memory pool of ";
45674 0 : std::cout << p_parent->class_name() << std::endl;
45675 : }
45676 : }
45677 : else
45678 : {
45679 0 : std::cout << "SgParameterStatement :: " << std::flush;
45680 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
45681 0 : std::cout << " not valid " << std::endl;
45682 : }
45683 : }
45684 :
45685 :
45686 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
45687 :
45688 0 : }
45689 :
45690 :
45691 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
45692 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
45693 : bool
45694 0 : SgParameterStatement::isInMemoryPool ()
45695 : {
45696 0 : typedef unsigned char* TestType;
45697 :
45698 0 : bool found = false;
45699 :
45700 0 : ROSE_ASSERT(this != NULL);
45701 :
45702 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
45703 :
45704 0 : TestType tested = (TestType) ( this ) ;
45705 :
45706 0 : std::vector < unsigned char* > :: const_iterator block = SgParameterStatement::pools.begin();
45707 :
45708 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
45709 : // while (found == false && block < Memory_Block_List.end())
45710 0 : while ( (found == false) && (block != SgParameterStatement::pools.end()) )
45711 : {
45712 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgParameterStatement::pool_size * sizeof(SgParameterStatement) ) ) ;
45713 0 : ++block;
45714 : }
45715 :
45716 : // Special handling for static data
45717 :
45718 :
45719 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
45720 0 : ROSE_ASSERT(found == true);
45721 :
45722 0 : return found;
45723 : }
45724 : /* #line 45725 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
45725 :
45726 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
45727 :
45728 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
45729 :
45730 : /* #line 45731 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
45731 :
45732 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
45733 :
45734 : void
45735 0 : SgNamespaceDeclarationStatement::checkDataMemberPointersIfInMemoryPool()
45736 : {
45737 : // ------------ checking pointers of SgNamespaceDeclarationStatement -------------------
45738 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
45739 :
45740 0 : if ( p_definition != NULL )
45741 : {
45742 0 : if ( p_definition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45743 : {
45744 0 : if ( p_definition->isInMemoryPool() == false )
45745 : {
45746 0 : std::cout << "SgNamespaceDeclarationStatement :: ";
45747 0 : std::cout << " p_definition is not in memory pool of ";
45748 0 : std::cout << p_definition->class_name() << std::endl;
45749 : }
45750 : }
45751 : else
45752 : {
45753 0 : std::cout << "SgNamespaceDeclarationStatement :: " << std::flush;
45754 0 : std::cout << "SgNamespaceDefinitionStatement* p_definition = " << p_definition << " --> " << std::flush;
45755 0 : std::cout << " not valid " << std::endl;
45756 : }
45757 : }
45758 :
45759 0 : if ( p_definingDeclaration != NULL )
45760 : {
45761 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45762 : {
45763 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
45764 : {
45765 0 : std::cout << "SgNamespaceDeclarationStatement :: ";
45766 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
45767 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
45768 : }
45769 : }
45770 : else
45771 : {
45772 0 : std::cout << "SgNamespaceDeclarationStatement :: " << std::flush;
45773 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
45774 0 : std::cout << " not valid " << std::endl;
45775 : }
45776 : }
45777 :
45778 0 : if ( p_firstNondefiningDeclaration != NULL )
45779 : {
45780 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45781 : {
45782 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
45783 : {
45784 0 : std::cout << "SgNamespaceDeclarationStatement :: ";
45785 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
45786 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
45787 : }
45788 : }
45789 : else
45790 : {
45791 0 : std::cout << "SgNamespaceDeclarationStatement :: " << std::flush;
45792 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
45793 0 : std::cout << " not valid " << std::endl;
45794 : }
45795 : }
45796 :
45797 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
45798 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
45799 : {
45800 0 : if ( (*i_qualifiedNameList) != NULL )
45801 : {
45802 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45803 : {
45804 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
45805 : {
45806 0 : std::cout << "SgNamespaceDeclarationStatement :: ";
45807 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
45808 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
45809 : }
45810 : }
45811 : else
45812 : {
45813 0 : std::cout << "SgNamespaceDeclarationStatement :: " << std::flush;
45814 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
45815 0 : std::cout << " entry not valid " << std::endl;
45816 : }
45817 : }
45818 : else
45819 : {
45820 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
45821 : }
45822 : }
45823 :
45824 0 : if ( p_declarationScope != NULL )
45825 : {
45826 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45827 : {
45828 0 : if ( p_declarationScope->isInMemoryPool() == false )
45829 : {
45830 0 : std::cout << "SgNamespaceDeclarationStatement :: ";
45831 0 : std::cout << " p_declarationScope is not in memory pool of ";
45832 0 : std::cout << p_declarationScope->class_name() << std::endl;
45833 : }
45834 : }
45835 : else
45836 : {
45837 0 : std::cout << "SgNamespaceDeclarationStatement :: " << std::flush;
45838 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
45839 0 : std::cout << " not valid " << std::endl;
45840 : }
45841 : }
45842 :
45843 0 : if ( p_numeric_label != NULL )
45844 : {
45845 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45846 : {
45847 0 : if ( p_numeric_label->isInMemoryPool() == false )
45848 : {
45849 0 : std::cout << "SgNamespaceDeclarationStatement :: ";
45850 0 : std::cout << " p_numeric_label is not in memory pool of ";
45851 0 : std::cout << p_numeric_label->class_name() << std::endl;
45852 : }
45853 : }
45854 : else
45855 : {
45856 0 : std::cout << "SgNamespaceDeclarationStatement :: " << std::flush;
45857 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
45858 0 : std::cout << " not valid " << std::endl;
45859 : }
45860 : }
45861 :
45862 0 : if ( p_startOfConstruct != NULL )
45863 : {
45864 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45865 : {
45866 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
45867 : {
45868 0 : std::cout << "SgNamespaceDeclarationStatement :: ";
45869 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
45870 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
45871 : }
45872 : }
45873 : else
45874 : {
45875 0 : std::cout << "SgNamespaceDeclarationStatement :: " << std::flush;
45876 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
45877 0 : std::cout << " not valid " << std::endl;
45878 : }
45879 : }
45880 :
45881 0 : if ( p_endOfConstruct != NULL )
45882 : {
45883 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45884 : {
45885 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
45886 : {
45887 0 : std::cout << "SgNamespaceDeclarationStatement :: ";
45888 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
45889 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
45890 : }
45891 : }
45892 : else
45893 : {
45894 0 : std::cout << "SgNamespaceDeclarationStatement :: " << std::flush;
45895 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
45896 0 : std::cout << " not valid " << std::endl;
45897 : }
45898 : }
45899 :
45900 0 : if ( p_parent != NULL )
45901 : {
45902 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45903 : {
45904 0 : if ( p_parent->isInMemoryPool() == false )
45905 : {
45906 0 : std::cout << "SgNamespaceDeclarationStatement :: ";
45907 0 : std::cout << " p_parent is not in memory pool of ";
45908 0 : std::cout << p_parent->class_name() << std::endl;
45909 : }
45910 : }
45911 : else
45912 : {
45913 0 : std::cout << "SgNamespaceDeclarationStatement :: " << std::flush;
45914 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
45915 0 : std::cout << " not valid " << std::endl;
45916 : }
45917 : }
45918 :
45919 :
45920 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
45921 :
45922 0 : }
45923 :
45924 :
45925 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
45926 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
45927 : bool
45928 0 : SgNamespaceDeclarationStatement::isInMemoryPool ()
45929 : {
45930 0 : typedef unsigned char* TestType;
45931 :
45932 0 : bool found = false;
45933 :
45934 0 : ROSE_ASSERT(this != NULL);
45935 :
45936 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
45937 :
45938 0 : TestType tested = (TestType) ( this ) ;
45939 :
45940 0 : std::vector < unsigned char* > :: const_iterator block = SgNamespaceDeclarationStatement::pools.begin();
45941 :
45942 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
45943 : // while (found == false && block < Memory_Block_List.end())
45944 0 : while ( (found == false) && (block != SgNamespaceDeclarationStatement::pools.end()) )
45945 : {
45946 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNamespaceDeclarationStatement::pool_size * sizeof(SgNamespaceDeclarationStatement) ) ) ;
45947 0 : ++block;
45948 : }
45949 :
45950 : // Special handling for static data
45951 :
45952 :
45953 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
45954 0 : ROSE_ASSERT(found == true);
45955 :
45956 0 : return found;
45957 : }
45958 : /* #line 45959 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
45959 :
45960 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
45961 :
45962 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
45963 :
45964 : /* #line 45965 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
45965 :
45966 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
45967 :
45968 : void
45969 0 : SgEquivalenceStatement::checkDataMemberPointersIfInMemoryPool()
45970 : {
45971 : // ------------ checking pointers of SgEquivalenceStatement -------------------
45972 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
45973 :
45974 0 : if ( p_equivalence_set_list != NULL )
45975 : {
45976 0 : if ( p_equivalence_set_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45977 : {
45978 0 : if ( p_equivalence_set_list->isInMemoryPool() == false )
45979 : {
45980 0 : std::cout << "SgEquivalenceStatement :: ";
45981 0 : std::cout << " p_equivalence_set_list is not in memory pool of ";
45982 0 : std::cout << p_equivalence_set_list->class_name() << std::endl;
45983 : }
45984 : }
45985 : else
45986 : {
45987 0 : std::cout << "SgEquivalenceStatement :: " << std::flush;
45988 0 : std::cout << "SgExprListExp* p_equivalence_set_list = " << p_equivalence_set_list << " --> " << std::flush;
45989 0 : std::cout << " not valid " << std::endl;
45990 : }
45991 : }
45992 :
45993 0 : if ( p_definingDeclaration != NULL )
45994 : {
45995 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
45996 : {
45997 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
45998 : {
45999 0 : std::cout << "SgEquivalenceStatement :: ";
46000 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
46001 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
46002 : }
46003 : }
46004 : else
46005 : {
46006 0 : std::cout << "SgEquivalenceStatement :: " << std::flush;
46007 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
46008 0 : std::cout << " not valid " << std::endl;
46009 : }
46010 : }
46011 :
46012 0 : if ( p_firstNondefiningDeclaration != NULL )
46013 : {
46014 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46015 : {
46016 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
46017 : {
46018 0 : std::cout << "SgEquivalenceStatement :: ";
46019 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
46020 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
46021 : }
46022 : }
46023 : else
46024 : {
46025 0 : std::cout << "SgEquivalenceStatement :: " << std::flush;
46026 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
46027 0 : std::cout << " not valid " << std::endl;
46028 : }
46029 : }
46030 :
46031 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
46032 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
46033 : {
46034 0 : if ( (*i_qualifiedNameList) != NULL )
46035 : {
46036 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46037 : {
46038 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
46039 : {
46040 0 : std::cout << "SgEquivalenceStatement :: ";
46041 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
46042 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
46043 : }
46044 : }
46045 : else
46046 : {
46047 0 : std::cout << "SgEquivalenceStatement :: " << std::flush;
46048 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
46049 0 : std::cout << " entry not valid " << std::endl;
46050 : }
46051 : }
46052 : else
46053 : {
46054 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
46055 : }
46056 : }
46057 :
46058 0 : if ( p_declarationScope != NULL )
46059 : {
46060 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46061 : {
46062 0 : if ( p_declarationScope->isInMemoryPool() == false )
46063 : {
46064 0 : std::cout << "SgEquivalenceStatement :: ";
46065 0 : std::cout << " p_declarationScope is not in memory pool of ";
46066 0 : std::cout << p_declarationScope->class_name() << std::endl;
46067 : }
46068 : }
46069 : else
46070 : {
46071 0 : std::cout << "SgEquivalenceStatement :: " << std::flush;
46072 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
46073 0 : std::cout << " not valid " << std::endl;
46074 : }
46075 : }
46076 :
46077 0 : if ( p_numeric_label != NULL )
46078 : {
46079 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46080 : {
46081 0 : if ( p_numeric_label->isInMemoryPool() == false )
46082 : {
46083 0 : std::cout << "SgEquivalenceStatement :: ";
46084 0 : std::cout << " p_numeric_label is not in memory pool of ";
46085 0 : std::cout << p_numeric_label->class_name() << std::endl;
46086 : }
46087 : }
46088 : else
46089 : {
46090 0 : std::cout << "SgEquivalenceStatement :: " << std::flush;
46091 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
46092 0 : std::cout << " not valid " << std::endl;
46093 : }
46094 : }
46095 :
46096 0 : if ( p_startOfConstruct != NULL )
46097 : {
46098 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46099 : {
46100 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
46101 : {
46102 0 : std::cout << "SgEquivalenceStatement :: ";
46103 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
46104 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
46105 : }
46106 : }
46107 : else
46108 : {
46109 0 : std::cout << "SgEquivalenceStatement :: " << std::flush;
46110 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
46111 0 : std::cout << " not valid " << std::endl;
46112 : }
46113 : }
46114 :
46115 0 : if ( p_endOfConstruct != NULL )
46116 : {
46117 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46118 : {
46119 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
46120 : {
46121 0 : std::cout << "SgEquivalenceStatement :: ";
46122 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
46123 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
46124 : }
46125 : }
46126 : else
46127 : {
46128 0 : std::cout << "SgEquivalenceStatement :: " << std::flush;
46129 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
46130 0 : std::cout << " not valid " << std::endl;
46131 : }
46132 : }
46133 :
46134 0 : if ( p_parent != NULL )
46135 : {
46136 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46137 : {
46138 0 : if ( p_parent->isInMemoryPool() == false )
46139 : {
46140 0 : std::cout << "SgEquivalenceStatement :: ";
46141 0 : std::cout << " p_parent is not in memory pool of ";
46142 0 : std::cout << p_parent->class_name() << std::endl;
46143 : }
46144 : }
46145 : else
46146 : {
46147 0 : std::cout << "SgEquivalenceStatement :: " << std::flush;
46148 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
46149 0 : std::cout << " not valid " << std::endl;
46150 : }
46151 : }
46152 :
46153 :
46154 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
46155 :
46156 0 : }
46157 :
46158 :
46159 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
46160 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
46161 : bool
46162 0 : SgEquivalenceStatement::isInMemoryPool ()
46163 : {
46164 0 : typedef unsigned char* TestType;
46165 :
46166 0 : bool found = false;
46167 :
46168 0 : ROSE_ASSERT(this != NULL);
46169 :
46170 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
46171 :
46172 0 : TestType tested = (TestType) ( this ) ;
46173 :
46174 0 : std::vector < unsigned char* > :: const_iterator block = SgEquivalenceStatement::pools.begin();
46175 :
46176 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
46177 : // while (found == false && block < Memory_Block_List.end())
46178 0 : while ( (found == false) && (block != SgEquivalenceStatement::pools.end()) )
46179 : {
46180 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgEquivalenceStatement::pool_size * sizeof(SgEquivalenceStatement) ) ) ;
46181 0 : ++block;
46182 : }
46183 :
46184 : // Special handling for static data
46185 :
46186 :
46187 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
46188 0 : ROSE_ASSERT(found == true);
46189 :
46190 0 : return found;
46191 : }
46192 : /* #line 46193 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
46193 :
46194 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
46195 :
46196 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
46197 :
46198 : /* #line 46199 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
46199 :
46200 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
46201 :
46202 : void
46203 0 : SgInterfaceStatement::checkDataMemberPointersIfInMemoryPool()
46204 : {
46205 : // ------------ checking pointers of SgInterfaceStatement -------------------
46206 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
46207 :
46208 0 : SgInterfaceBodyPtrList::iterator i_interface_body_list = p_interface_body_list.begin() ;
46209 0 : for ( ; i_interface_body_list != p_interface_body_list.end(); ++i_interface_body_list )
46210 : {
46211 0 : if ( (*i_interface_body_list) != NULL )
46212 : {
46213 0 : if ( (*i_interface_body_list)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46214 : {
46215 0 : if ( (*i_interface_body_list)->isInMemoryPool() == false )
46216 : {
46217 0 : std::cout << "SgInterfaceStatement :: ";
46218 0 : std::cout << " p_interface_body_list ( list of poitners to IR nodes ), entry is not in memory pool of ";
46219 0 : std::cout << (*i_interface_body_list)->class_name() << std::endl;
46220 : }
46221 : }
46222 : else
46223 : {
46224 0 : std::cout << "SgInterfaceStatement :: " << std::flush;
46225 0 : std::cout << "SgInterfaceBodyPtrList p_interface_body_list --> " << std::flush;
46226 0 : std::cout << " entry not valid " << std::endl;
46227 : }
46228 : }
46229 : else
46230 : {
46231 0 : std::cout << "SgInterfaceBodyPtrList p_interface_body_list --> NULL " << std::endl;
46232 : }
46233 : }
46234 :
46235 0 : if ( p_end_numeric_label != NULL )
46236 : {
46237 0 : if ( p_end_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46238 : {
46239 0 : if ( p_end_numeric_label->isInMemoryPool() == false )
46240 : {
46241 0 : std::cout << "SgInterfaceStatement :: ";
46242 0 : std::cout << " p_end_numeric_label is not in memory pool of ";
46243 0 : std::cout << p_end_numeric_label->class_name() << std::endl;
46244 : }
46245 : }
46246 : else
46247 : {
46248 0 : std::cout << "SgInterfaceStatement :: " << std::flush;
46249 0 : std::cout << "SgLabelRefExp* p_end_numeric_label = " << p_end_numeric_label << " --> " << std::flush;
46250 0 : std::cout << " not valid " << std::endl;
46251 : }
46252 : }
46253 :
46254 0 : if ( p_definingDeclaration != NULL )
46255 : {
46256 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46257 : {
46258 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
46259 : {
46260 0 : std::cout << "SgInterfaceStatement :: ";
46261 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
46262 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
46263 : }
46264 : }
46265 : else
46266 : {
46267 0 : std::cout << "SgInterfaceStatement :: " << std::flush;
46268 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
46269 0 : std::cout << " not valid " << std::endl;
46270 : }
46271 : }
46272 :
46273 0 : if ( p_firstNondefiningDeclaration != NULL )
46274 : {
46275 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46276 : {
46277 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
46278 : {
46279 0 : std::cout << "SgInterfaceStatement :: ";
46280 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
46281 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
46282 : }
46283 : }
46284 : else
46285 : {
46286 0 : std::cout << "SgInterfaceStatement :: " << std::flush;
46287 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
46288 0 : std::cout << " not valid " << std::endl;
46289 : }
46290 : }
46291 :
46292 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
46293 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
46294 : {
46295 0 : if ( (*i_qualifiedNameList) != NULL )
46296 : {
46297 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46298 : {
46299 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
46300 : {
46301 0 : std::cout << "SgInterfaceStatement :: ";
46302 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
46303 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
46304 : }
46305 : }
46306 : else
46307 : {
46308 0 : std::cout << "SgInterfaceStatement :: " << std::flush;
46309 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
46310 0 : std::cout << " entry not valid " << std::endl;
46311 : }
46312 : }
46313 : else
46314 : {
46315 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
46316 : }
46317 : }
46318 :
46319 0 : if ( p_declarationScope != NULL )
46320 : {
46321 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46322 : {
46323 0 : if ( p_declarationScope->isInMemoryPool() == false )
46324 : {
46325 0 : std::cout << "SgInterfaceStatement :: ";
46326 0 : std::cout << " p_declarationScope is not in memory pool of ";
46327 0 : std::cout << p_declarationScope->class_name() << std::endl;
46328 : }
46329 : }
46330 : else
46331 : {
46332 0 : std::cout << "SgInterfaceStatement :: " << std::flush;
46333 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
46334 0 : std::cout << " not valid " << std::endl;
46335 : }
46336 : }
46337 :
46338 0 : if ( p_numeric_label != NULL )
46339 : {
46340 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46341 : {
46342 0 : if ( p_numeric_label->isInMemoryPool() == false )
46343 : {
46344 0 : std::cout << "SgInterfaceStatement :: ";
46345 0 : std::cout << " p_numeric_label is not in memory pool of ";
46346 0 : std::cout << p_numeric_label->class_name() << std::endl;
46347 : }
46348 : }
46349 : else
46350 : {
46351 0 : std::cout << "SgInterfaceStatement :: " << std::flush;
46352 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
46353 0 : std::cout << " not valid " << std::endl;
46354 : }
46355 : }
46356 :
46357 0 : if ( p_startOfConstruct != NULL )
46358 : {
46359 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46360 : {
46361 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
46362 : {
46363 0 : std::cout << "SgInterfaceStatement :: ";
46364 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
46365 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
46366 : }
46367 : }
46368 : else
46369 : {
46370 0 : std::cout << "SgInterfaceStatement :: " << std::flush;
46371 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
46372 0 : std::cout << " not valid " << std::endl;
46373 : }
46374 : }
46375 :
46376 0 : if ( p_endOfConstruct != NULL )
46377 : {
46378 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46379 : {
46380 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
46381 : {
46382 0 : std::cout << "SgInterfaceStatement :: ";
46383 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
46384 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
46385 : }
46386 : }
46387 : else
46388 : {
46389 0 : std::cout << "SgInterfaceStatement :: " << std::flush;
46390 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
46391 0 : std::cout << " not valid " << std::endl;
46392 : }
46393 : }
46394 :
46395 0 : if ( p_parent != NULL )
46396 : {
46397 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46398 : {
46399 0 : if ( p_parent->isInMemoryPool() == false )
46400 : {
46401 0 : std::cout << "SgInterfaceStatement :: ";
46402 0 : std::cout << " p_parent is not in memory pool of ";
46403 0 : std::cout << p_parent->class_name() << std::endl;
46404 : }
46405 : }
46406 : else
46407 : {
46408 0 : std::cout << "SgInterfaceStatement :: " << std::flush;
46409 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
46410 0 : std::cout << " not valid " << std::endl;
46411 : }
46412 : }
46413 :
46414 :
46415 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
46416 :
46417 0 : }
46418 :
46419 :
46420 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
46421 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
46422 : bool
46423 0 : SgInterfaceStatement::isInMemoryPool ()
46424 : {
46425 0 : typedef unsigned char* TestType;
46426 :
46427 0 : bool found = false;
46428 :
46429 0 : ROSE_ASSERT(this != NULL);
46430 :
46431 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
46432 :
46433 0 : TestType tested = (TestType) ( this ) ;
46434 :
46435 0 : std::vector < unsigned char* > :: const_iterator block = SgInterfaceStatement::pools.begin();
46436 :
46437 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
46438 : // while (found == false && block < Memory_Block_List.end())
46439 0 : while ( (found == false) && (block != SgInterfaceStatement::pools.end()) )
46440 : {
46441 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgInterfaceStatement::pool_size * sizeof(SgInterfaceStatement) ) ) ;
46442 0 : ++block;
46443 : }
46444 :
46445 : // Special handling for static data
46446 :
46447 :
46448 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
46449 0 : ROSE_ASSERT(found == true);
46450 :
46451 0 : return found;
46452 : }
46453 : /* #line 46454 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
46454 :
46455 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
46456 :
46457 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
46458 :
46459 : /* #line 46460 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
46460 :
46461 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
46462 :
46463 : void
46464 0 : SgNamespaceAliasDeclarationStatement::checkDataMemberPointersIfInMemoryPool()
46465 : {
46466 : // ------------ checking pointers of SgNamespaceAliasDeclarationStatement -------------------
46467 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
46468 :
46469 0 : if ( p_namespaceDeclaration != NULL )
46470 : {
46471 0 : if ( p_namespaceDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46472 : {
46473 0 : if ( p_namespaceDeclaration->isInMemoryPool() == false )
46474 : {
46475 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: ";
46476 0 : std::cout << " p_namespaceDeclaration is not in memory pool of ";
46477 0 : std::cout << p_namespaceDeclaration->class_name() << std::endl;
46478 : }
46479 : }
46480 : else
46481 : {
46482 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: " << std::flush;
46483 0 : std::cout << "SgNamespaceDeclarationStatement* p_namespaceDeclaration = " << p_namespaceDeclaration << " --> " << std::flush;
46484 0 : std::cout << " not valid " << std::endl;
46485 : }
46486 : }
46487 :
46488 0 : if ( p_namespaceAliasDeclaration != NULL )
46489 : {
46490 0 : if ( p_namespaceAliasDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46491 : {
46492 0 : if ( p_namespaceAliasDeclaration->isInMemoryPool() == false )
46493 : {
46494 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: ";
46495 0 : std::cout << " p_namespaceAliasDeclaration is not in memory pool of ";
46496 0 : std::cout << p_namespaceAliasDeclaration->class_name() << std::endl;
46497 : }
46498 : }
46499 : else
46500 : {
46501 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: " << std::flush;
46502 0 : std::cout << "SgNamespaceAliasDeclarationStatement* p_namespaceAliasDeclaration = " << p_namespaceAliasDeclaration << " --> " << std::flush;
46503 0 : std::cout << " not valid " << std::endl;
46504 : }
46505 : }
46506 :
46507 0 : if ( p_definingDeclaration != NULL )
46508 : {
46509 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46510 : {
46511 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
46512 : {
46513 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: ";
46514 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
46515 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
46516 : }
46517 : }
46518 : else
46519 : {
46520 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: " << std::flush;
46521 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
46522 0 : std::cout << " not valid " << std::endl;
46523 : }
46524 : }
46525 :
46526 0 : if ( p_firstNondefiningDeclaration != NULL )
46527 : {
46528 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46529 : {
46530 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
46531 : {
46532 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: ";
46533 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
46534 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
46535 : }
46536 : }
46537 : else
46538 : {
46539 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: " << std::flush;
46540 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
46541 0 : std::cout << " not valid " << std::endl;
46542 : }
46543 : }
46544 :
46545 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
46546 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
46547 : {
46548 0 : if ( (*i_qualifiedNameList) != NULL )
46549 : {
46550 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46551 : {
46552 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
46553 : {
46554 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: ";
46555 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
46556 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
46557 : }
46558 : }
46559 : else
46560 : {
46561 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: " << std::flush;
46562 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
46563 0 : std::cout << " entry not valid " << std::endl;
46564 : }
46565 : }
46566 : else
46567 : {
46568 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
46569 : }
46570 : }
46571 :
46572 0 : if ( p_declarationScope != NULL )
46573 : {
46574 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46575 : {
46576 0 : if ( p_declarationScope->isInMemoryPool() == false )
46577 : {
46578 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: ";
46579 0 : std::cout << " p_declarationScope is not in memory pool of ";
46580 0 : std::cout << p_declarationScope->class_name() << std::endl;
46581 : }
46582 : }
46583 : else
46584 : {
46585 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: " << std::flush;
46586 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
46587 0 : std::cout << " not valid " << std::endl;
46588 : }
46589 : }
46590 :
46591 0 : if ( p_numeric_label != NULL )
46592 : {
46593 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46594 : {
46595 0 : if ( p_numeric_label->isInMemoryPool() == false )
46596 : {
46597 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: ";
46598 0 : std::cout << " p_numeric_label is not in memory pool of ";
46599 0 : std::cout << p_numeric_label->class_name() << std::endl;
46600 : }
46601 : }
46602 : else
46603 : {
46604 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: " << std::flush;
46605 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
46606 0 : std::cout << " not valid " << std::endl;
46607 : }
46608 : }
46609 :
46610 0 : if ( p_startOfConstruct != NULL )
46611 : {
46612 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46613 : {
46614 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
46615 : {
46616 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: ";
46617 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
46618 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
46619 : }
46620 : }
46621 : else
46622 : {
46623 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: " << std::flush;
46624 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
46625 0 : std::cout << " not valid " << std::endl;
46626 : }
46627 : }
46628 :
46629 0 : if ( p_endOfConstruct != NULL )
46630 : {
46631 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46632 : {
46633 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
46634 : {
46635 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: ";
46636 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
46637 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
46638 : }
46639 : }
46640 : else
46641 : {
46642 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: " << std::flush;
46643 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
46644 0 : std::cout << " not valid " << std::endl;
46645 : }
46646 : }
46647 :
46648 0 : if ( p_parent != NULL )
46649 : {
46650 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46651 : {
46652 0 : if ( p_parent->isInMemoryPool() == false )
46653 : {
46654 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: ";
46655 0 : std::cout << " p_parent is not in memory pool of ";
46656 0 : std::cout << p_parent->class_name() << std::endl;
46657 : }
46658 : }
46659 : else
46660 : {
46661 0 : std::cout << "SgNamespaceAliasDeclarationStatement :: " << std::flush;
46662 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
46663 0 : std::cout << " not valid " << std::endl;
46664 : }
46665 : }
46666 :
46667 :
46668 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
46669 :
46670 0 : }
46671 :
46672 :
46673 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
46674 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
46675 : bool
46676 0 : SgNamespaceAliasDeclarationStatement::isInMemoryPool ()
46677 : {
46678 0 : typedef unsigned char* TestType;
46679 :
46680 0 : bool found = false;
46681 :
46682 0 : ROSE_ASSERT(this != NULL);
46683 :
46684 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
46685 :
46686 0 : TestType tested = (TestType) ( this ) ;
46687 :
46688 0 : std::vector < unsigned char* > :: const_iterator block = SgNamespaceAliasDeclarationStatement::pools.begin();
46689 :
46690 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
46691 : // while (found == false && block < Memory_Block_List.end())
46692 0 : while ( (found == false) && (block != SgNamespaceAliasDeclarationStatement::pools.end()) )
46693 : {
46694 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNamespaceAliasDeclarationStatement::pool_size * sizeof(SgNamespaceAliasDeclarationStatement) ) ) ;
46695 0 : ++block;
46696 : }
46697 :
46698 : // Special handling for static data
46699 :
46700 :
46701 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
46702 0 : ROSE_ASSERT(found == true);
46703 :
46704 0 : return found;
46705 : }
46706 : /* #line 46707 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
46707 :
46708 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
46709 :
46710 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
46711 :
46712 : /* #line 46713 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
46713 :
46714 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
46715 :
46716 : void
46717 0 : SgCommonBlock::checkDataMemberPointersIfInMemoryPool()
46718 : {
46719 : // ------------ checking pointers of SgCommonBlock -------------------
46720 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
46721 :
46722 0 : SgCommonBlockObjectPtrList::iterator i_block_list = p_block_list.begin() ;
46723 0 : for ( ; i_block_list != p_block_list.end(); ++i_block_list )
46724 : {
46725 0 : if ( (*i_block_list) != NULL )
46726 : {
46727 0 : if ( (*i_block_list)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46728 : {
46729 0 : if ( (*i_block_list)->isInMemoryPool() == false )
46730 : {
46731 0 : std::cout << "SgCommonBlock :: ";
46732 0 : std::cout << " p_block_list ( list of poitners to IR nodes ), entry is not in memory pool of ";
46733 0 : std::cout << (*i_block_list)->class_name() << std::endl;
46734 : }
46735 : }
46736 : else
46737 : {
46738 0 : std::cout << "SgCommonBlock :: " << std::flush;
46739 0 : std::cout << "SgCommonBlockObjectPtrList p_block_list --> " << std::flush;
46740 0 : std::cout << " entry not valid " << std::endl;
46741 : }
46742 : }
46743 : else
46744 : {
46745 0 : std::cout << "SgCommonBlockObjectPtrList p_block_list --> NULL " << std::endl;
46746 : }
46747 : }
46748 :
46749 0 : if ( p_definingDeclaration != NULL )
46750 : {
46751 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46752 : {
46753 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
46754 : {
46755 0 : std::cout << "SgCommonBlock :: ";
46756 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
46757 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
46758 : }
46759 : }
46760 : else
46761 : {
46762 0 : std::cout << "SgCommonBlock :: " << std::flush;
46763 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
46764 0 : std::cout << " not valid " << std::endl;
46765 : }
46766 : }
46767 :
46768 0 : if ( p_firstNondefiningDeclaration != NULL )
46769 : {
46770 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46771 : {
46772 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
46773 : {
46774 0 : std::cout << "SgCommonBlock :: ";
46775 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
46776 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
46777 : }
46778 : }
46779 : else
46780 : {
46781 0 : std::cout << "SgCommonBlock :: " << std::flush;
46782 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
46783 0 : std::cout << " not valid " << std::endl;
46784 : }
46785 : }
46786 :
46787 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
46788 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
46789 : {
46790 0 : if ( (*i_qualifiedNameList) != NULL )
46791 : {
46792 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46793 : {
46794 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
46795 : {
46796 0 : std::cout << "SgCommonBlock :: ";
46797 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
46798 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
46799 : }
46800 : }
46801 : else
46802 : {
46803 0 : std::cout << "SgCommonBlock :: " << std::flush;
46804 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
46805 0 : std::cout << " entry not valid " << std::endl;
46806 : }
46807 : }
46808 : else
46809 : {
46810 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
46811 : }
46812 : }
46813 :
46814 0 : if ( p_declarationScope != NULL )
46815 : {
46816 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46817 : {
46818 0 : if ( p_declarationScope->isInMemoryPool() == false )
46819 : {
46820 0 : std::cout << "SgCommonBlock :: ";
46821 0 : std::cout << " p_declarationScope is not in memory pool of ";
46822 0 : std::cout << p_declarationScope->class_name() << std::endl;
46823 : }
46824 : }
46825 : else
46826 : {
46827 0 : std::cout << "SgCommonBlock :: " << std::flush;
46828 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
46829 0 : std::cout << " not valid " << std::endl;
46830 : }
46831 : }
46832 :
46833 0 : if ( p_numeric_label != NULL )
46834 : {
46835 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46836 : {
46837 0 : if ( p_numeric_label->isInMemoryPool() == false )
46838 : {
46839 0 : std::cout << "SgCommonBlock :: ";
46840 0 : std::cout << " p_numeric_label is not in memory pool of ";
46841 0 : std::cout << p_numeric_label->class_name() << std::endl;
46842 : }
46843 : }
46844 : else
46845 : {
46846 0 : std::cout << "SgCommonBlock :: " << std::flush;
46847 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
46848 0 : std::cout << " not valid " << std::endl;
46849 : }
46850 : }
46851 :
46852 0 : if ( p_startOfConstruct != NULL )
46853 : {
46854 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46855 : {
46856 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
46857 : {
46858 0 : std::cout << "SgCommonBlock :: ";
46859 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
46860 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
46861 : }
46862 : }
46863 : else
46864 : {
46865 0 : std::cout << "SgCommonBlock :: " << std::flush;
46866 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
46867 0 : std::cout << " not valid " << std::endl;
46868 : }
46869 : }
46870 :
46871 0 : if ( p_endOfConstruct != NULL )
46872 : {
46873 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46874 : {
46875 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
46876 : {
46877 0 : std::cout << "SgCommonBlock :: ";
46878 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
46879 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
46880 : }
46881 : }
46882 : else
46883 : {
46884 0 : std::cout << "SgCommonBlock :: " << std::flush;
46885 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
46886 0 : std::cout << " not valid " << std::endl;
46887 : }
46888 : }
46889 :
46890 0 : if ( p_parent != NULL )
46891 : {
46892 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46893 : {
46894 0 : if ( p_parent->isInMemoryPool() == false )
46895 : {
46896 0 : std::cout << "SgCommonBlock :: ";
46897 0 : std::cout << " p_parent is not in memory pool of ";
46898 0 : std::cout << p_parent->class_name() << std::endl;
46899 : }
46900 : }
46901 : else
46902 : {
46903 0 : std::cout << "SgCommonBlock :: " << std::flush;
46904 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
46905 0 : std::cout << " not valid " << std::endl;
46906 : }
46907 : }
46908 :
46909 :
46910 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
46911 :
46912 0 : }
46913 :
46914 :
46915 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
46916 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
46917 : bool
46918 0 : SgCommonBlock::isInMemoryPool ()
46919 : {
46920 0 : typedef unsigned char* TestType;
46921 :
46922 0 : bool found = false;
46923 :
46924 0 : ROSE_ASSERT(this != NULL);
46925 :
46926 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
46927 :
46928 0 : TestType tested = (TestType) ( this ) ;
46929 :
46930 0 : std::vector < unsigned char* > :: const_iterator block = SgCommonBlock::pools.begin();
46931 :
46932 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
46933 : // while (found == false && block < Memory_Block_List.end())
46934 0 : while ( (found == false) && (block != SgCommonBlock::pools.end()) )
46935 : {
46936 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCommonBlock::pool_size * sizeof(SgCommonBlock) ) ) ;
46937 0 : ++block;
46938 : }
46939 :
46940 : // Special handling for static data
46941 :
46942 :
46943 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
46944 0 : ROSE_ASSERT(found == true);
46945 :
46946 0 : return found;
46947 : }
46948 : /* #line 46949 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
46949 :
46950 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
46951 :
46952 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
46953 :
46954 : /* #line 46955 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
46955 :
46956 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
46957 :
46958 : void
46959 0 : SgTypedefDeclaration::checkDataMemberPointersIfInMemoryPool()
46960 : {
46961 : // ------------ checking pointers of SgTypedefDeclaration -------------------
46962 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
46963 :
46964 0 : if ( p_base_type != NULL )
46965 : {
46966 0 : if ( p_base_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46967 : {
46968 0 : if ( p_base_type->isInMemoryPool() == false )
46969 : {
46970 0 : std::cout << "SgTypedefDeclaration :: ";
46971 0 : std::cout << " p_base_type is not in memory pool of ";
46972 0 : std::cout << p_base_type->class_name() << std::endl;
46973 : }
46974 : }
46975 : else
46976 : {
46977 0 : std::cout << "SgTypedefDeclaration :: " << std::flush;
46978 0 : std::cout << "SgType* p_base_type = " << p_base_type << " --> " << std::flush;
46979 0 : std::cout << " not valid " << std::endl;
46980 : }
46981 : }
46982 :
46983 0 : if ( p_type != NULL )
46984 : {
46985 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
46986 : {
46987 0 : if ( p_type->isInMemoryPool() == false )
46988 : {
46989 0 : std::cout << "SgTypedefDeclaration :: ";
46990 0 : std::cout << " p_type is not in memory pool of ";
46991 0 : std::cout << p_type->class_name() << std::endl;
46992 : }
46993 : }
46994 : else
46995 : {
46996 0 : std::cout << "SgTypedefDeclaration :: " << std::flush;
46997 0 : std::cout << "SgTypedefType* p_type = " << p_type << " --> " << std::flush;
46998 0 : std::cout << " not valid " << std::endl;
46999 : }
47000 : }
47001 :
47002 0 : if ( p_declaration != NULL )
47003 : {
47004 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47005 : {
47006 0 : if ( p_declaration->isInMemoryPool() == false )
47007 : {
47008 0 : std::cout << "SgTypedefDeclaration :: ";
47009 0 : std::cout << " p_declaration is not in memory pool of ";
47010 0 : std::cout << p_declaration->class_name() << std::endl;
47011 : }
47012 : }
47013 : else
47014 : {
47015 0 : std::cout << "SgTypedefDeclaration :: " << std::flush;
47016 0 : std::cout << "SgDeclarationStatement* p_declaration = " << p_declaration << " --> " << std::flush;
47017 0 : std::cout << " not valid " << std::endl;
47018 : }
47019 : }
47020 :
47021 0 : if ( p_parent_scope != NULL )
47022 : {
47023 0 : if ( p_parent_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47024 : {
47025 0 : if ( p_parent_scope->isInMemoryPool() == false )
47026 : {
47027 0 : std::cout << "SgTypedefDeclaration :: ";
47028 0 : std::cout << " p_parent_scope is not in memory pool of ";
47029 0 : std::cout << p_parent_scope->class_name() << std::endl;
47030 : }
47031 : }
47032 : else
47033 : {
47034 0 : std::cout << "SgTypedefDeclaration :: " << std::flush;
47035 0 : std::cout << "SgSymbol* p_parent_scope = " << p_parent_scope << " --> " << std::flush;
47036 0 : std::cout << " not valid " << std::endl;
47037 : }
47038 : }
47039 :
47040 0 : if ( p_scope != NULL )
47041 : {
47042 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47043 : {
47044 0 : if ( p_scope->isInMemoryPool() == false )
47045 : {
47046 0 : std::cout << "SgTypedefDeclaration :: ";
47047 0 : std::cout << " p_scope is not in memory pool of ";
47048 0 : std::cout << p_scope->class_name() << std::endl;
47049 : }
47050 : }
47051 : else
47052 : {
47053 0 : std::cout << "SgTypedefDeclaration :: " << std::flush;
47054 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
47055 0 : std::cout << " not valid " << std::endl;
47056 : }
47057 : }
47058 :
47059 0 : if ( p_definingDeclaration != NULL )
47060 : {
47061 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47062 : {
47063 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
47064 : {
47065 0 : std::cout << "SgTypedefDeclaration :: ";
47066 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
47067 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
47068 : }
47069 : }
47070 : else
47071 : {
47072 0 : std::cout << "SgTypedefDeclaration :: " << std::flush;
47073 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
47074 0 : std::cout << " not valid " << std::endl;
47075 : }
47076 : }
47077 :
47078 0 : if ( p_firstNondefiningDeclaration != NULL )
47079 : {
47080 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47081 : {
47082 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
47083 : {
47084 0 : std::cout << "SgTypedefDeclaration :: ";
47085 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
47086 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
47087 : }
47088 : }
47089 : else
47090 : {
47091 0 : std::cout << "SgTypedefDeclaration :: " << std::flush;
47092 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
47093 0 : std::cout << " not valid " << std::endl;
47094 : }
47095 : }
47096 :
47097 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
47098 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
47099 : {
47100 0 : if ( (*i_qualifiedNameList) != NULL )
47101 : {
47102 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47103 : {
47104 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
47105 : {
47106 0 : std::cout << "SgTypedefDeclaration :: ";
47107 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
47108 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
47109 : }
47110 : }
47111 : else
47112 : {
47113 0 : std::cout << "SgTypedefDeclaration :: " << std::flush;
47114 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
47115 0 : std::cout << " entry not valid " << std::endl;
47116 : }
47117 : }
47118 : else
47119 : {
47120 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
47121 : }
47122 : }
47123 :
47124 0 : if ( p_declarationScope != NULL )
47125 : {
47126 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47127 : {
47128 0 : if ( p_declarationScope->isInMemoryPool() == false )
47129 : {
47130 0 : std::cout << "SgTypedefDeclaration :: ";
47131 0 : std::cout << " p_declarationScope is not in memory pool of ";
47132 0 : std::cout << p_declarationScope->class_name() << std::endl;
47133 : }
47134 : }
47135 : else
47136 : {
47137 0 : std::cout << "SgTypedefDeclaration :: " << std::flush;
47138 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
47139 0 : std::cout << " not valid " << std::endl;
47140 : }
47141 : }
47142 :
47143 0 : if ( p_numeric_label != NULL )
47144 : {
47145 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47146 : {
47147 0 : if ( p_numeric_label->isInMemoryPool() == false )
47148 : {
47149 0 : std::cout << "SgTypedefDeclaration :: ";
47150 0 : std::cout << " p_numeric_label is not in memory pool of ";
47151 0 : std::cout << p_numeric_label->class_name() << std::endl;
47152 : }
47153 : }
47154 : else
47155 : {
47156 0 : std::cout << "SgTypedefDeclaration :: " << std::flush;
47157 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
47158 0 : std::cout << " not valid " << std::endl;
47159 : }
47160 : }
47161 :
47162 0 : if ( p_startOfConstruct != NULL )
47163 : {
47164 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47165 : {
47166 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
47167 : {
47168 0 : std::cout << "SgTypedefDeclaration :: ";
47169 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
47170 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
47171 : }
47172 : }
47173 : else
47174 : {
47175 0 : std::cout << "SgTypedefDeclaration :: " << std::flush;
47176 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
47177 0 : std::cout << " not valid " << std::endl;
47178 : }
47179 : }
47180 :
47181 0 : if ( p_endOfConstruct != NULL )
47182 : {
47183 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47184 : {
47185 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
47186 : {
47187 0 : std::cout << "SgTypedefDeclaration :: ";
47188 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
47189 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
47190 : }
47191 : }
47192 : else
47193 : {
47194 0 : std::cout << "SgTypedefDeclaration :: " << std::flush;
47195 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
47196 0 : std::cout << " not valid " << std::endl;
47197 : }
47198 : }
47199 :
47200 0 : if ( p_parent != NULL )
47201 : {
47202 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47203 : {
47204 0 : if ( p_parent->isInMemoryPool() == false )
47205 : {
47206 0 : std::cout << "SgTypedefDeclaration :: ";
47207 0 : std::cout << " p_parent is not in memory pool of ";
47208 0 : std::cout << p_parent->class_name() << std::endl;
47209 : }
47210 : }
47211 : else
47212 : {
47213 0 : std::cout << "SgTypedefDeclaration :: " << std::flush;
47214 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
47215 0 : std::cout << " not valid " << std::endl;
47216 : }
47217 : }
47218 :
47219 :
47220 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
47221 :
47222 0 : }
47223 :
47224 :
47225 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
47226 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
47227 : bool
47228 0 : SgTypedefDeclaration::isInMemoryPool ()
47229 : {
47230 0 : typedef unsigned char* TestType;
47231 :
47232 0 : bool found = false;
47233 :
47234 0 : ROSE_ASSERT(this != NULL);
47235 :
47236 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
47237 :
47238 0 : TestType tested = (TestType) ( this ) ;
47239 :
47240 0 : std::vector < unsigned char* > :: const_iterator block = SgTypedefDeclaration::pools.begin();
47241 :
47242 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
47243 : // while (found == false && block < Memory_Block_List.end())
47244 0 : while ( (found == false) && (block != SgTypedefDeclaration::pools.end()) )
47245 : {
47246 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypedefDeclaration::pool_size * sizeof(SgTypedefDeclaration) ) ) ;
47247 0 : ++block;
47248 : }
47249 :
47250 : // Special handling for static data
47251 :
47252 :
47253 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
47254 0 : ROSE_ASSERT(found == true);
47255 :
47256 0 : return found;
47257 : }
47258 : /* #line 47259 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
47259 :
47260 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
47261 :
47262 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
47263 :
47264 : /* #line 47265 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
47265 :
47266 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
47267 :
47268 : void
47269 0 : SgTemplateTypedefDeclaration::checkDataMemberPointersIfInMemoryPool()
47270 : {
47271 : // ------------ checking pointers of SgTemplateTypedefDeclaration -------------------
47272 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
47273 :
47274 0 : SgTemplateParameterPtrList::iterator i_templateParameters = p_templateParameters.begin() ;
47275 0 : for ( ; i_templateParameters != p_templateParameters.end(); ++i_templateParameters )
47276 : {
47277 0 : if ( (*i_templateParameters) != NULL )
47278 : {
47279 0 : if ( (*i_templateParameters)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47280 : {
47281 0 : if ( (*i_templateParameters)->isInMemoryPool() == false )
47282 : {
47283 0 : std::cout << "SgTemplateTypedefDeclaration :: ";
47284 0 : std::cout << " p_templateParameters ( list of poitners to IR nodes ), entry is not in memory pool of ";
47285 0 : std::cout << (*i_templateParameters)->class_name() << std::endl;
47286 : }
47287 : }
47288 : else
47289 : {
47290 0 : std::cout << "SgTemplateTypedefDeclaration :: " << std::flush;
47291 0 : std::cout << "SgTemplateParameterPtrList p_templateParameters --> " << std::flush;
47292 0 : std::cout << " entry not valid " << std::endl;
47293 : }
47294 : }
47295 : else
47296 : {
47297 0 : std::cout << "SgTemplateParameterPtrList p_templateParameters --> NULL " << std::endl;
47298 : }
47299 : }
47300 :
47301 0 : SgTemplateArgumentPtrList::iterator i_templateSpecializationArguments = p_templateSpecializationArguments.begin() ;
47302 0 : for ( ; i_templateSpecializationArguments != p_templateSpecializationArguments.end(); ++i_templateSpecializationArguments )
47303 : {
47304 0 : if ( (*i_templateSpecializationArguments) != NULL )
47305 : {
47306 0 : if ( (*i_templateSpecializationArguments)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47307 : {
47308 0 : if ( (*i_templateSpecializationArguments)->isInMemoryPool() == false )
47309 : {
47310 0 : std::cout << "SgTemplateTypedefDeclaration :: ";
47311 0 : std::cout << " p_templateSpecializationArguments ( list of poitners to IR nodes ), entry is not in memory pool of ";
47312 0 : std::cout << (*i_templateSpecializationArguments)->class_name() << std::endl;
47313 : }
47314 : }
47315 : else
47316 : {
47317 0 : std::cout << "SgTemplateTypedefDeclaration :: " << std::flush;
47318 0 : std::cout << "SgTemplateArgumentPtrList p_templateSpecializationArguments --> " << std::flush;
47319 0 : std::cout << " entry not valid " << std::endl;
47320 : }
47321 : }
47322 : else
47323 : {
47324 0 : std::cout << "SgTemplateArgumentPtrList p_templateSpecializationArguments --> NULL " << std::endl;
47325 : }
47326 : }
47327 :
47328 0 : if ( p_nonreal_decl_scope != NULL )
47329 : {
47330 0 : if ( p_nonreal_decl_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47331 : {
47332 0 : if ( p_nonreal_decl_scope->isInMemoryPool() == false )
47333 : {
47334 0 : std::cout << "SgTemplateTypedefDeclaration :: ";
47335 0 : std::cout << " p_nonreal_decl_scope is not in memory pool of ";
47336 0 : std::cout << p_nonreal_decl_scope->class_name() << std::endl;
47337 : }
47338 : }
47339 : else
47340 : {
47341 0 : std::cout << "SgTemplateTypedefDeclaration :: " << std::flush;
47342 0 : std::cout << "SgDeclarationScope* p_nonreal_decl_scope = " << p_nonreal_decl_scope << " --> " << std::flush;
47343 0 : std::cout << " not valid " << std::endl;
47344 : }
47345 : }
47346 :
47347 0 : if ( p_base_type != NULL )
47348 : {
47349 0 : if ( p_base_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47350 : {
47351 0 : if ( p_base_type->isInMemoryPool() == false )
47352 : {
47353 0 : std::cout << "SgTemplateTypedefDeclaration :: ";
47354 0 : std::cout << " p_base_type is not in memory pool of ";
47355 0 : std::cout << p_base_type->class_name() << std::endl;
47356 : }
47357 : }
47358 : else
47359 : {
47360 0 : std::cout << "SgTemplateTypedefDeclaration :: " << std::flush;
47361 0 : std::cout << "SgType* p_base_type = " << p_base_type << " --> " << std::flush;
47362 0 : std::cout << " not valid " << std::endl;
47363 : }
47364 : }
47365 :
47366 0 : if ( p_type != NULL )
47367 : {
47368 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47369 : {
47370 0 : if ( p_type->isInMemoryPool() == false )
47371 : {
47372 0 : std::cout << "SgTemplateTypedefDeclaration :: ";
47373 0 : std::cout << " p_type is not in memory pool of ";
47374 0 : std::cout << p_type->class_name() << std::endl;
47375 : }
47376 : }
47377 : else
47378 : {
47379 0 : std::cout << "SgTemplateTypedefDeclaration :: " << std::flush;
47380 0 : std::cout << "SgTypedefType* p_type = " << p_type << " --> " << std::flush;
47381 0 : std::cout << " not valid " << std::endl;
47382 : }
47383 : }
47384 :
47385 0 : if ( p_declaration != NULL )
47386 : {
47387 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47388 : {
47389 0 : if ( p_declaration->isInMemoryPool() == false )
47390 : {
47391 0 : std::cout << "SgTemplateTypedefDeclaration :: ";
47392 0 : std::cout << " p_declaration is not in memory pool of ";
47393 0 : std::cout << p_declaration->class_name() << std::endl;
47394 : }
47395 : }
47396 : else
47397 : {
47398 0 : std::cout << "SgTemplateTypedefDeclaration :: " << std::flush;
47399 0 : std::cout << "SgDeclarationStatement* p_declaration = " << p_declaration << " --> " << std::flush;
47400 0 : std::cout << " not valid " << std::endl;
47401 : }
47402 : }
47403 :
47404 0 : if ( p_parent_scope != NULL )
47405 : {
47406 0 : if ( p_parent_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47407 : {
47408 0 : if ( p_parent_scope->isInMemoryPool() == false )
47409 : {
47410 0 : std::cout << "SgTemplateTypedefDeclaration :: ";
47411 0 : std::cout << " p_parent_scope is not in memory pool of ";
47412 0 : std::cout << p_parent_scope->class_name() << std::endl;
47413 : }
47414 : }
47415 : else
47416 : {
47417 0 : std::cout << "SgTemplateTypedefDeclaration :: " << std::flush;
47418 0 : std::cout << "SgSymbol* p_parent_scope = " << p_parent_scope << " --> " << std::flush;
47419 0 : std::cout << " not valid " << std::endl;
47420 : }
47421 : }
47422 :
47423 0 : if ( p_scope != NULL )
47424 : {
47425 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47426 : {
47427 0 : if ( p_scope->isInMemoryPool() == false )
47428 : {
47429 0 : std::cout << "SgTemplateTypedefDeclaration :: ";
47430 0 : std::cout << " p_scope is not in memory pool of ";
47431 0 : std::cout << p_scope->class_name() << std::endl;
47432 : }
47433 : }
47434 : else
47435 : {
47436 0 : std::cout << "SgTemplateTypedefDeclaration :: " << std::flush;
47437 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
47438 0 : std::cout << " not valid " << std::endl;
47439 : }
47440 : }
47441 :
47442 0 : if ( p_definingDeclaration != NULL )
47443 : {
47444 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47445 : {
47446 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
47447 : {
47448 0 : std::cout << "SgTemplateTypedefDeclaration :: ";
47449 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
47450 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
47451 : }
47452 : }
47453 : else
47454 : {
47455 0 : std::cout << "SgTemplateTypedefDeclaration :: " << std::flush;
47456 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
47457 0 : std::cout << " not valid " << std::endl;
47458 : }
47459 : }
47460 :
47461 0 : if ( p_firstNondefiningDeclaration != NULL )
47462 : {
47463 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47464 : {
47465 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
47466 : {
47467 0 : std::cout << "SgTemplateTypedefDeclaration :: ";
47468 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
47469 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
47470 : }
47471 : }
47472 : else
47473 : {
47474 0 : std::cout << "SgTemplateTypedefDeclaration :: " << std::flush;
47475 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
47476 0 : std::cout << " not valid " << std::endl;
47477 : }
47478 : }
47479 :
47480 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
47481 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
47482 : {
47483 0 : if ( (*i_qualifiedNameList) != NULL )
47484 : {
47485 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47486 : {
47487 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
47488 : {
47489 0 : std::cout << "SgTemplateTypedefDeclaration :: ";
47490 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
47491 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
47492 : }
47493 : }
47494 : else
47495 : {
47496 0 : std::cout << "SgTemplateTypedefDeclaration :: " << std::flush;
47497 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
47498 0 : std::cout << " entry not valid " << std::endl;
47499 : }
47500 : }
47501 : else
47502 : {
47503 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
47504 : }
47505 : }
47506 :
47507 0 : if ( p_declarationScope != NULL )
47508 : {
47509 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47510 : {
47511 0 : if ( p_declarationScope->isInMemoryPool() == false )
47512 : {
47513 0 : std::cout << "SgTemplateTypedefDeclaration :: ";
47514 0 : std::cout << " p_declarationScope is not in memory pool of ";
47515 0 : std::cout << p_declarationScope->class_name() << std::endl;
47516 : }
47517 : }
47518 : else
47519 : {
47520 0 : std::cout << "SgTemplateTypedefDeclaration :: " << std::flush;
47521 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
47522 0 : std::cout << " not valid " << std::endl;
47523 : }
47524 : }
47525 :
47526 0 : if ( p_numeric_label != NULL )
47527 : {
47528 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47529 : {
47530 0 : if ( p_numeric_label->isInMemoryPool() == false )
47531 : {
47532 0 : std::cout << "SgTemplateTypedefDeclaration :: ";
47533 0 : std::cout << " p_numeric_label is not in memory pool of ";
47534 0 : std::cout << p_numeric_label->class_name() << std::endl;
47535 : }
47536 : }
47537 : else
47538 : {
47539 0 : std::cout << "SgTemplateTypedefDeclaration :: " << std::flush;
47540 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
47541 0 : std::cout << " not valid " << std::endl;
47542 : }
47543 : }
47544 :
47545 0 : if ( p_startOfConstruct != NULL )
47546 : {
47547 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47548 : {
47549 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
47550 : {
47551 0 : std::cout << "SgTemplateTypedefDeclaration :: ";
47552 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
47553 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
47554 : }
47555 : }
47556 : else
47557 : {
47558 0 : std::cout << "SgTemplateTypedefDeclaration :: " << std::flush;
47559 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
47560 0 : std::cout << " not valid " << std::endl;
47561 : }
47562 : }
47563 :
47564 0 : if ( p_endOfConstruct != NULL )
47565 : {
47566 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47567 : {
47568 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
47569 : {
47570 0 : std::cout << "SgTemplateTypedefDeclaration :: ";
47571 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
47572 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
47573 : }
47574 : }
47575 : else
47576 : {
47577 0 : std::cout << "SgTemplateTypedefDeclaration :: " << std::flush;
47578 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
47579 0 : std::cout << " not valid " << std::endl;
47580 : }
47581 : }
47582 :
47583 0 : if ( p_parent != NULL )
47584 : {
47585 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47586 : {
47587 0 : if ( p_parent->isInMemoryPool() == false )
47588 : {
47589 0 : std::cout << "SgTemplateTypedefDeclaration :: ";
47590 0 : std::cout << " p_parent is not in memory pool of ";
47591 0 : std::cout << p_parent->class_name() << std::endl;
47592 : }
47593 : }
47594 : else
47595 : {
47596 0 : std::cout << "SgTemplateTypedefDeclaration :: " << std::flush;
47597 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
47598 0 : std::cout << " not valid " << std::endl;
47599 : }
47600 : }
47601 :
47602 :
47603 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
47604 :
47605 0 : }
47606 :
47607 :
47608 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
47609 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
47610 : bool
47611 0 : SgTemplateTypedefDeclaration::isInMemoryPool ()
47612 : {
47613 0 : typedef unsigned char* TestType;
47614 :
47615 0 : bool found = false;
47616 :
47617 0 : ROSE_ASSERT(this != NULL);
47618 :
47619 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
47620 :
47621 0 : TestType tested = (TestType) ( this ) ;
47622 :
47623 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateTypedefDeclaration::pools.begin();
47624 :
47625 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
47626 : // while (found == false && block < Memory_Block_List.end())
47627 0 : while ( (found == false) && (block != SgTemplateTypedefDeclaration::pools.end()) )
47628 : {
47629 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateTypedefDeclaration::pool_size * sizeof(SgTemplateTypedefDeclaration) ) ) ;
47630 0 : ++block;
47631 : }
47632 :
47633 : // Special handling for static data
47634 :
47635 :
47636 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
47637 0 : ROSE_ASSERT(found == true);
47638 :
47639 0 : return found;
47640 : }
47641 : /* #line 47642 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
47642 :
47643 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
47644 :
47645 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
47646 :
47647 : /* #line 47648 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
47648 :
47649 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
47650 :
47651 : void
47652 0 : SgTemplateInstantiationTypedefDeclaration::checkDataMemberPointersIfInMemoryPool()
47653 : {
47654 : // ------------ checking pointers of SgTemplateInstantiationTypedefDeclaration -------------------
47655 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
47656 :
47657 0 : if ( p_templateDeclaration != NULL )
47658 : {
47659 0 : if ( p_templateDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47660 : {
47661 0 : if ( p_templateDeclaration->isInMemoryPool() == false )
47662 : {
47663 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: ";
47664 0 : std::cout << " p_templateDeclaration is not in memory pool of ";
47665 0 : std::cout << p_templateDeclaration->class_name() << std::endl;
47666 : }
47667 : }
47668 : else
47669 : {
47670 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: " << std::flush;
47671 0 : std::cout << "SgTemplateTypedefDeclaration* p_templateDeclaration = " << p_templateDeclaration << " --> " << std::flush;
47672 0 : std::cout << " not valid " << std::endl;
47673 : }
47674 : }
47675 :
47676 0 : SgTemplateArgumentPtrList::iterator i_templateArguments = p_templateArguments.begin() ;
47677 0 : for ( ; i_templateArguments != p_templateArguments.end(); ++i_templateArguments )
47678 : {
47679 0 : if ( (*i_templateArguments) != NULL )
47680 : {
47681 0 : if ( (*i_templateArguments)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47682 : {
47683 0 : if ( (*i_templateArguments)->isInMemoryPool() == false )
47684 : {
47685 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: ";
47686 0 : std::cout << " p_templateArguments ( list of poitners to IR nodes ), entry is not in memory pool of ";
47687 0 : std::cout << (*i_templateArguments)->class_name() << std::endl;
47688 : }
47689 : }
47690 : else
47691 : {
47692 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: " << std::flush;
47693 0 : std::cout << "SgTemplateArgumentPtrList p_templateArguments --> " << std::flush;
47694 0 : std::cout << " entry not valid " << std::endl;
47695 : }
47696 : }
47697 : else
47698 : {
47699 0 : std::cout << "SgTemplateArgumentPtrList p_templateArguments --> NULL " << std::endl;
47700 : }
47701 : }
47702 :
47703 0 : if ( p_base_type != NULL )
47704 : {
47705 0 : if ( p_base_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47706 : {
47707 0 : if ( p_base_type->isInMemoryPool() == false )
47708 : {
47709 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: ";
47710 0 : std::cout << " p_base_type is not in memory pool of ";
47711 0 : std::cout << p_base_type->class_name() << std::endl;
47712 : }
47713 : }
47714 : else
47715 : {
47716 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: " << std::flush;
47717 0 : std::cout << "SgType* p_base_type = " << p_base_type << " --> " << std::flush;
47718 0 : std::cout << " not valid " << std::endl;
47719 : }
47720 : }
47721 :
47722 0 : if ( p_type != NULL )
47723 : {
47724 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47725 : {
47726 0 : if ( p_type->isInMemoryPool() == false )
47727 : {
47728 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: ";
47729 0 : std::cout << " p_type is not in memory pool of ";
47730 0 : std::cout << p_type->class_name() << std::endl;
47731 : }
47732 : }
47733 : else
47734 : {
47735 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: " << std::flush;
47736 0 : std::cout << "SgTypedefType* p_type = " << p_type << " --> " << std::flush;
47737 0 : std::cout << " not valid " << std::endl;
47738 : }
47739 : }
47740 :
47741 0 : if ( p_declaration != NULL )
47742 : {
47743 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47744 : {
47745 0 : if ( p_declaration->isInMemoryPool() == false )
47746 : {
47747 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: ";
47748 0 : std::cout << " p_declaration is not in memory pool of ";
47749 0 : std::cout << p_declaration->class_name() << std::endl;
47750 : }
47751 : }
47752 : else
47753 : {
47754 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: " << std::flush;
47755 0 : std::cout << "SgDeclarationStatement* p_declaration = " << p_declaration << " --> " << std::flush;
47756 0 : std::cout << " not valid " << std::endl;
47757 : }
47758 : }
47759 :
47760 0 : if ( p_parent_scope != NULL )
47761 : {
47762 0 : if ( p_parent_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47763 : {
47764 0 : if ( p_parent_scope->isInMemoryPool() == false )
47765 : {
47766 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: ";
47767 0 : std::cout << " p_parent_scope is not in memory pool of ";
47768 0 : std::cout << p_parent_scope->class_name() << std::endl;
47769 : }
47770 : }
47771 : else
47772 : {
47773 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: " << std::flush;
47774 0 : std::cout << "SgSymbol* p_parent_scope = " << p_parent_scope << " --> " << std::flush;
47775 0 : std::cout << " not valid " << std::endl;
47776 : }
47777 : }
47778 :
47779 0 : if ( p_scope != NULL )
47780 : {
47781 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47782 : {
47783 0 : if ( p_scope->isInMemoryPool() == false )
47784 : {
47785 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: ";
47786 0 : std::cout << " p_scope is not in memory pool of ";
47787 0 : std::cout << p_scope->class_name() << std::endl;
47788 : }
47789 : }
47790 : else
47791 : {
47792 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: " << std::flush;
47793 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
47794 0 : std::cout << " not valid " << std::endl;
47795 : }
47796 : }
47797 :
47798 0 : if ( p_definingDeclaration != NULL )
47799 : {
47800 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47801 : {
47802 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
47803 : {
47804 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: ";
47805 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
47806 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
47807 : }
47808 : }
47809 : else
47810 : {
47811 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: " << std::flush;
47812 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
47813 0 : std::cout << " not valid " << std::endl;
47814 : }
47815 : }
47816 :
47817 0 : if ( p_firstNondefiningDeclaration != NULL )
47818 : {
47819 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47820 : {
47821 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
47822 : {
47823 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: ";
47824 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
47825 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
47826 : }
47827 : }
47828 : else
47829 : {
47830 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: " << std::flush;
47831 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
47832 0 : std::cout << " not valid " << std::endl;
47833 : }
47834 : }
47835 :
47836 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
47837 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
47838 : {
47839 0 : if ( (*i_qualifiedNameList) != NULL )
47840 : {
47841 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47842 : {
47843 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
47844 : {
47845 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: ";
47846 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
47847 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
47848 : }
47849 : }
47850 : else
47851 : {
47852 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: " << std::flush;
47853 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
47854 0 : std::cout << " entry not valid " << std::endl;
47855 : }
47856 : }
47857 : else
47858 : {
47859 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
47860 : }
47861 : }
47862 :
47863 0 : if ( p_declarationScope != NULL )
47864 : {
47865 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47866 : {
47867 0 : if ( p_declarationScope->isInMemoryPool() == false )
47868 : {
47869 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: ";
47870 0 : std::cout << " p_declarationScope is not in memory pool of ";
47871 0 : std::cout << p_declarationScope->class_name() << std::endl;
47872 : }
47873 : }
47874 : else
47875 : {
47876 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: " << std::flush;
47877 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
47878 0 : std::cout << " not valid " << std::endl;
47879 : }
47880 : }
47881 :
47882 0 : if ( p_numeric_label != NULL )
47883 : {
47884 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47885 : {
47886 0 : if ( p_numeric_label->isInMemoryPool() == false )
47887 : {
47888 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: ";
47889 0 : std::cout << " p_numeric_label is not in memory pool of ";
47890 0 : std::cout << p_numeric_label->class_name() << std::endl;
47891 : }
47892 : }
47893 : else
47894 : {
47895 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: " << std::flush;
47896 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
47897 0 : std::cout << " not valid " << std::endl;
47898 : }
47899 : }
47900 :
47901 0 : if ( p_startOfConstruct != NULL )
47902 : {
47903 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47904 : {
47905 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
47906 : {
47907 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: ";
47908 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
47909 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
47910 : }
47911 : }
47912 : else
47913 : {
47914 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: " << std::flush;
47915 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
47916 0 : std::cout << " not valid " << std::endl;
47917 : }
47918 : }
47919 :
47920 0 : if ( p_endOfConstruct != NULL )
47921 : {
47922 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47923 : {
47924 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
47925 : {
47926 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: ";
47927 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
47928 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
47929 : }
47930 : }
47931 : else
47932 : {
47933 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: " << std::flush;
47934 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
47935 0 : std::cout << " not valid " << std::endl;
47936 : }
47937 : }
47938 :
47939 0 : if ( p_parent != NULL )
47940 : {
47941 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
47942 : {
47943 0 : if ( p_parent->isInMemoryPool() == false )
47944 : {
47945 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: ";
47946 0 : std::cout << " p_parent is not in memory pool of ";
47947 0 : std::cout << p_parent->class_name() << std::endl;
47948 : }
47949 : }
47950 : else
47951 : {
47952 0 : std::cout << "SgTemplateInstantiationTypedefDeclaration :: " << std::flush;
47953 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
47954 0 : std::cout << " not valid " << std::endl;
47955 : }
47956 : }
47957 :
47958 :
47959 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
47960 :
47961 0 : }
47962 :
47963 :
47964 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
47965 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
47966 : bool
47967 0 : SgTemplateInstantiationTypedefDeclaration::isInMemoryPool ()
47968 : {
47969 0 : typedef unsigned char* TestType;
47970 :
47971 0 : bool found = false;
47972 :
47973 0 : ROSE_ASSERT(this != NULL);
47974 :
47975 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
47976 :
47977 0 : TestType tested = (TestType) ( this ) ;
47978 :
47979 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateInstantiationTypedefDeclaration::pools.begin();
47980 :
47981 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
47982 : // while (found == false && block < Memory_Block_List.end())
47983 0 : while ( (found == false) && (block != SgTemplateInstantiationTypedefDeclaration::pools.end()) )
47984 : {
47985 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateInstantiationTypedefDeclaration::pool_size * sizeof(SgTemplateInstantiationTypedefDeclaration) ) ) ;
47986 0 : ++block;
47987 : }
47988 :
47989 : // Special handling for static data
47990 :
47991 :
47992 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
47993 0 : ROSE_ASSERT(found == true);
47994 :
47995 0 : return found;
47996 : }
47997 : /* #line 47998 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
47998 :
47999 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
48000 :
48001 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
48002 :
48003 : /* #line 48004 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
48004 :
48005 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
48006 :
48007 : void
48008 0 : SgStatementFunctionStatement::checkDataMemberPointersIfInMemoryPool()
48009 : {
48010 : // ------------ checking pointers of SgStatementFunctionStatement -------------------
48011 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
48012 :
48013 0 : if ( p_function != NULL )
48014 : {
48015 0 : if ( p_function->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48016 : {
48017 0 : if ( p_function->isInMemoryPool() == false )
48018 : {
48019 0 : std::cout << "SgStatementFunctionStatement :: ";
48020 0 : std::cout << " p_function is not in memory pool of ";
48021 0 : std::cout << p_function->class_name() << std::endl;
48022 : }
48023 : }
48024 : else
48025 : {
48026 0 : std::cout << "SgStatementFunctionStatement :: " << std::flush;
48027 0 : std::cout << "SgFunctionDeclaration* p_function = " << p_function << " --> " << std::flush;
48028 0 : std::cout << " not valid " << std::endl;
48029 : }
48030 : }
48031 :
48032 0 : if ( p_expression != NULL )
48033 : {
48034 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48035 : {
48036 0 : if ( p_expression->isInMemoryPool() == false )
48037 : {
48038 0 : std::cout << "SgStatementFunctionStatement :: ";
48039 0 : std::cout << " p_expression is not in memory pool of ";
48040 0 : std::cout << p_expression->class_name() << std::endl;
48041 : }
48042 : }
48043 : else
48044 : {
48045 0 : std::cout << "SgStatementFunctionStatement :: " << std::flush;
48046 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
48047 0 : std::cout << " not valid " << std::endl;
48048 : }
48049 : }
48050 :
48051 0 : if ( p_definingDeclaration != NULL )
48052 : {
48053 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48054 : {
48055 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
48056 : {
48057 0 : std::cout << "SgStatementFunctionStatement :: ";
48058 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
48059 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
48060 : }
48061 : }
48062 : else
48063 : {
48064 0 : std::cout << "SgStatementFunctionStatement :: " << std::flush;
48065 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
48066 0 : std::cout << " not valid " << std::endl;
48067 : }
48068 : }
48069 :
48070 0 : if ( p_firstNondefiningDeclaration != NULL )
48071 : {
48072 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48073 : {
48074 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
48075 : {
48076 0 : std::cout << "SgStatementFunctionStatement :: ";
48077 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
48078 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
48079 : }
48080 : }
48081 : else
48082 : {
48083 0 : std::cout << "SgStatementFunctionStatement :: " << std::flush;
48084 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
48085 0 : std::cout << " not valid " << std::endl;
48086 : }
48087 : }
48088 :
48089 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
48090 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
48091 : {
48092 0 : if ( (*i_qualifiedNameList) != NULL )
48093 : {
48094 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48095 : {
48096 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
48097 : {
48098 0 : std::cout << "SgStatementFunctionStatement :: ";
48099 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
48100 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
48101 : }
48102 : }
48103 : else
48104 : {
48105 0 : std::cout << "SgStatementFunctionStatement :: " << std::flush;
48106 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
48107 0 : std::cout << " entry not valid " << std::endl;
48108 : }
48109 : }
48110 : else
48111 : {
48112 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
48113 : }
48114 : }
48115 :
48116 0 : if ( p_declarationScope != NULL )
48117 : {
48118 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48119 : {
48120 0 : if ( p_declarationScope->isInMemoryPool() == false )
48121 : {
48122 0 : std::cout << "SgStatementFunctionStatement :: ";
48123 0 : std::cout << " p_declarationScope is not in memory pool of ";
48124 0 : std::cout << p_declarationScope->class_name() << std::endl;
48125 : }
48126 : }
48127 : else
48128 : {
48129 0 : std::cout << "SgStatementFunctionStatement :: " << std::flush;
48130 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
48131 0 : std::cout << " not valid " << std::endl;
48132 : }
48133 : }
48134 :
48135 0 : if ( p_numeric_label != NULL )
48136 : {
48137 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48138 : {
48139 0 : if ( p_numeric_label->isInMemoryPool() == false )
48140 : {
48141 0 : std::cout << "SgStatementFunctionStatement :: ";
48142 0 : std::cout << " p_numeric_label is not in memory pool of ";
48143 0 : std::cout << p_numeric_label->class_name() << std::endl;
48144 : }
48145 : }
48146 : else
48147 : {
48148 0 : std::cout << "SgStatementFunctionStatement :: " << std::flush;
48149 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
48150 0 : std::cout << " not valid " << std::endl;
48151 : }
48152 : }
48153 :
48154 0 : if ( p_startOfConstruct != NULL )
48155 : {
48156 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48157 : {
48158 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
48159 : {
48160 0 : std::cout << "SgStatementFunctionStatement :: ";
48161 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
48162 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
48163 : }
48164 : }
48165 : else
48166 : {
48167 0 : std::cout << "SgStatementFunctionStatement :: " << std::flush;
48168 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
48169 0 : std::cout << " not valid " << std::endl;
48170 : }
48171 : }
48172 :
48173 0 : if ( p_endOfConstruct != NULL )
48174 : {
48175 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48176 : {
48177 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
48178 : {
48179 0 : std::cout << "SgStatementFunctionStatement :: ";
48180 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
48181 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
48182 : }
48183 : }
48184 : else
48185 : {
48186 0 : std::cout << "SgStatementFunctionStatement :: " << std::flush;
48187 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
48188 0 : std::cout << " not valid " << std::endl;
48189 : }
48190 : }
48191 :
48192 0 : if ( p_parent != NULL )
48193 : {
48194 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48195 : {
48196 0 : if ( p_parent->isInMemoryPool() == false )
48197 : {
48198 0 : std::cout << "SgStatementFunctionStatement :: ";
48199 0 : std::cout << " p_parent is not in memory pool of ";
48200 0 : std::cout << p_parent->class_name() << std::endl;
48201 : }
48202 : }
48203 : else
48204 : {
48205 0 : std::cout << "SgStatementFunctionStatement :: " << std::flush;
48206 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
48207 0 : std::cout << " not valid " << std::endl;
48208 : }
48209 : }
48210 :
48211 :
48212 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
48213 :
48214 0 : }
48215 :
48216 :
48217 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
48218 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
48219 : bool
48220 0 : SgStatementFunctionStatement::isInMemoryPool ()
48221 : {
48222 0 : typedef unsigned char* TestType;
48223 :
48224 0 : bool found = false;
48225 :
48226 0 : ROSE_ASSERT(this != NULL);
48227 :
48228 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
48229 :
48230 0 : TestType tested = (TestType) ( this ) ;
48231 :
48232 0 : std::vector < unsigned char* > :: const_iterator block = SgStatementFunctionStatement::pools.begin();
48233 :
48234 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
48235 : // while (found == false && block < Memory_Block_List.end())
48236 0 : while ( (found == false) && (block != SgStatementFunctionStatement::pools.end()) )
48237 : {
48238 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgStatementFunctionStatement::pool_size * sizeof(SgStatementFunctionStatement) ) ) ;
48239 0 : ++block;
48240 : }
48241 :
48242 : // Special handling for static data
48243 :
48244 :
48245 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
48246 0 : ROSE_ASSERT(found == true);
48247 :
48248 0 : return found;
48249 : }
48250 : /* #line 48251 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
48251 :
48252 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
48253 :
48254 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
48255 :
48256 : /* #line 48257 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
48257 :
48258 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
48259 :
48260 : void
48261 0 : SgCtorInitializerList::checkDataMemberPointersIfInMemoryPool()
48262 : {
48263 : // ------------ checking pointers of SgCtorInitializerList -------------------
48264 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
48265 :
48266 0 : SgInitializedNamePtrList::iterator i_ctors = p_ctors.begin() ;
48267 0 : for ( ; i_ctors != p_ctors.end(); ++i_ctors )
48268 : {
48269 0 : if ( (*i_ctors) != NULL )
48270 : {
48271 0 : if ( (*i_ctors)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48272 : {
48273 0 : if ( (*i_ctors)->isInMemoryPool() == false )
48274 : {
48275 0 : std::cout << "SgCtorInitializerList :: ";
48276 0 : std::cout << " p_ctors ( list of poitners to IR nodes ), entry is not in memory pool of ";
48277 0 : std::cout << (*i_ctors)->class_name() << std::endl;
48278 : }
48279 : }
48280 : else
48281 : {
48282 0 : std::cout << "SgCtorInitializerList :: " << std::flush;
48283 0 : std::cout << "SgInitializedNamePtrList p_ctors --> " << std::flush;
48284 0 : std::cout << " entry not valid " << std::endl;
48285 : }
48286 : }
48287 : else
48288 : {
48289 0 : std::cout << "SgInitializedNamePtrList p_ctors --> NULL " << std::endl;
48290 : }
48291 : }
48292 :
48293 0 : if ( p_definingDeclaration != NULL )
48294 : {
48295 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48296 : {
48297 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
48298 : {
48299 0 : std::cout << "SgCtorInitializerList :: ";
48300 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
48301 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
48302 : }
48303 : }
48304 : else
48305 : {
48306 0 : std::cout << "SgCtorInitializerList :: " << std::flush;
48307 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
48308 0 : std::cout << " not valid " << std::endl;
48309 : }
48310 : }
48311 :
48312 0 : if ( p_firstNondefiningDeclaration != NULL )
48313 : {
48314 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48315 : {
48316 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
48317 : {
48318 0 : std::cout << "SgCtorInitializerList :: ";
48319 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
48320 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
48321 : }
48322 : }
48323 : else
48324 : {
48325 0 : std::cout << "SgCtorInitializerList :: " << std::flush;
48326 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
48327 0 : std::cout << " not valid " << std::endl;
48328 : }
48329 : }
48330 :
48331 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
48332 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
48333 : {
48334 0 : if ( (*i_qualifiedNameList) != NULL )
48335 : {
48336 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48337 : {
48338 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
48339 : {
48340 0 : std::cout << "SgCtorInitializerList :: ";
48341 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
48342 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
48343 : }
48344 : }
48345 : else
48346 : {
48347 0 : std::cout << "SgCtorInitializerList :: " << std::flush;
48348 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
48349 0 : std::cout << " entry not valid " << std::endl;
48350 : }
48351 : }
48352 : else
48353 : {
48354 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
48355 : }
48356 : }
48357 :
48358 0 : if ( p_declarationScope != NULL )
48359 : {
48360 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48361 : {
48362 0 : if ( p_declarationScope->isInMemoryPool() == false )
48363 : {
48364 0 : std::cout << "SgCtorInitializerList :: ";
48365 0 : std::cout << " p_declarationScope is not in memory pool of ";
48366 0 : std::cout << p_declarationScope->class_name() << std::endl;
48367 : }
48368 : }
48369 : else
48370 : {
48371 0 : std::cout << "SgCtorInitializerList :: " << std::flush;
48372 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
48373 0 : std::cout << " not valid " << std::endl;
48374 : }
48375 : }
48376 :
48377 0 : if ( p_numeric_label != NULL )
48378 : {
48379 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48380 : {
48381 0 : if ( p_numeric_label->isInMemoryPool() == false )
48382 : {
48383 0 : std::cout << "SgCtorInitializerList :: ";
48384 0 : std::cout << " p_numeric_label is not in memory pool of ";
48385 0 : std::cout << p_numeric_label->class_name() << std::endl;
48386 : }
48387 : }
48388 : else
48389 : {
48390 0 : std::cout << "SgCtorInitializerList :: " << std::flush;
48391 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
48392 0 : std::cout << " not valid " << std::endl;
48393 : }
48394 : }
48395 :
48396 0 : if ( p_startOfConstruct != NULL )
48397 : {
48398 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48399 : {
48400 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
48401 : {
48402 0 : std::cout << "SgCtorInitializerList :: ";
48403 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
48404 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
48405 : }
48406 : }
48407 : else
48408 : {
48409 0 : std::cout << "SgCtorInitializerList :: " << std::flush;
48410 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
48411 0 : std::cout << " not valid " << std::endl;
48412 : }
48413 : }
48414 :
48415 0 : if ( p_endOfConstruct != NULL )
48416 : {
48417 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48418 : {
48419 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
48420 : {
48421 0 : std::cout << "SgCtorInitializerList :: ";
48422 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
48423 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
48424 : }
48425 : }
48426 : else
48427 : {
48428 0 : std::cout << "SgCtorInitializerList :: " << std::flush;
48429 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
48430 0 : std::cout << " not valid " << std::endl;
48431 : }
48432 : }
48433 :
48434 0 : if ( p_parent != NULL )
48435 : {
48436 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48437 : {
48438 0 : if ( p_parent->isInMemoryPool() == false )
48439 : {
48440 0 : std::cout << "SgCtorInitializerList :: ";
48441 0 : std::cout << " p_parent is not in memory pool of ";
48442 0 : std::cout << p_parent->class_name() << std::endl;
48443 : }
48444 : }
48445 : else
48446 : {
48447 0 : std::cout << "SgCtorInitializerList :: " << std::flush;
48448 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
48449 0 : std::cout << " not valid " << std::endl;
48450 : }
48451 : }
48452 :
48453 :
48454 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
48455 :
48456 0 : }
48457 :
48458 :
48459 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
48460 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
48461 : bool
48462 0 : SgCtorInitializerList::isInMemoryPool ()
48463 : {
48464 0 : typedef unsigned char* TestType;
48465 :
48466 0 : bool found = false;
48467 :
48468 0 : ROSE_ASSERT(this != NULL);
48469 :
48470 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
48471 :
48472 0 : TestType tested = (TestType) ( this ) ;
48473 :
48474 0 : std::vector < unsigned char* > :: const_iterator block = SgCtorInitializerList::pools.begin();
48475 :
48476 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
48477 : // while (found == false && block < Memory_Block_List.end())
48478 0 : while ( (found == false) && (block != SgCtorInitializerList::pools.end()) )
48479 : {
48480 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCtorInitializerList::pool_size * sizeof(SgCtorInitializerList) ) ) ;
48481 0 : ++block;
48482 : }
48483 :
48484 : // Special handling for static data
48485 :
48486 :
48487 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
48488 0 : ROSE_ASSERT(found == true);
48489 :
48490 0 : return found;
48491 : }
48492 : /* #line 48493 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
48493 :
48494 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
48495 :
48496 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
48497 :
48498 : /* #line 48499 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
48499 :
48500 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
48501 :
48502 : void
48503 0 : SgPragmaDeclaration::checkDataMemberPointersIfInMemoryPool()
48504 : {
48505 : // ------------ checking pointers of SgPragmaDeclaration -------------------
48506 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
48507 :
48508 0 : if ( p_pragma != NULL )
48509 : {
48510 0 : if ( p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48511 : {
48512 0 : if ( p_pragma->isInMemoryPool() == false )
48513 : {
48514 0 : std::cout << "SgPragmaDeclaration :: ";
48515 0 : std::cout << " p_pragma is not in memory pool of ";
48516 0 : std::cout << p_pragma->class_name() << std::endl;
48517 : }
48518 : }
48519 : else
48520 : {
48521 0 : std::cout << "SgPragmaDeclaration :: " << std::flush;
48522 0 : std::cout << "SgPragma* p_pragma = " << p_pragma << " --> " << std::flush;
48523 0 : std::cout << " not valid " << std::endl;
48524 : }
48525 : }
48526 :
48527 0 : if ( p_definingDeclaration != NULL )
48528 : {
48529 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48530 : {
48531 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
48532 : {
48533 0 : std::cout << "SgPragmaDeclaration :: ";
48534 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
48535 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
48536 : }
48537 : }
48538 : else
48539 : {
48540 0 : std::cout << "SgPragmaDeclaration :: " << std::flush;
48541 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
48542 0 : std::cout << " not valid " << std::endl;
48543 : }
48544 : }
48545 :
48546 0 : if ( p_firstNondefiningDeclaration != NULL )
48547 : {
48548 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48549 : {
48550 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
48551 : {
48552 0 : std::cout << "SgPragmaDeclaration :: ";
48553 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
48554 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
48555 : }
48556 : }
48557 : else
48558 : {
48559 0 : std::cout << "SgPragmaDeclaration :: " << std::flush;
48560 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
48561 0 : std::cout << " not valid " << std::endl;
48562 : }
48563 : }
48564 :
48565 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
48566 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
48567 : {
48568 0 : if ( (*i_qualifiedNameList) != NULL )
48569 : {
48570 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48571 : {
48572 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
48573 : {
48574 0 : std::cout << "SgPragmaDeclaration :: ";
48575 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
48576 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
48577 : }
48578 : }
48579 : else
48580 : {
48581 0 : std::cout << "SgPragmaDeclaration :: " << std::flush;
48582 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
48583 0 : std::cout << " entry not valid " << std::endl;
48584 : }
48585 : }
48586 : else
48587 : {
48588 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
48589 : }
48590 : }
48591 :
48592 0 : if ( p_declarationScope != NULL )
48593 : {
48594 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48595 : {
48596 0 : if ( p_declarationScope->isInMemoryPool() == false )
48597 : {
48598 0 : std::cout << "SgPragmaDeclaration :: ";
48599 0 : std::cout << " p_declarationScope is not in memory pool of ";
48600 0 : std::cout << p_declarationScope->class_name() << std::endl;
48601 : }
48602 : }
48603 : else
48604 : {
48605 0 : std::cout << "SgPragmaDeclaration :: " << std::flush;
48606 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
48607 0 : std::cout << " not valid " << std::endl;
48608 : }
48609 : }
48610 :
48611 0 : if ( p_numeric_label != NULL )
48612 : {
48613 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48614 : {
48615 0 : if ( p_numeric_label->isInMemoryPool() == false )
48616 : {
48617 0 : std::cout << "SgPragmaDeclaration :: ";
48618 0 : std::cout << " p_numeric_label is not in memory pool of ";
48619 0 : std::cout << p_numeric_label->class_name() << std::endl;
48620 : }
48621 : }
48622 : else
48623 : {
48624 0 : std::cout << "SgPragmaDeclaration :: " << std::flush;
48625 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
48626 0 : std::cout << " not valid " << std::endl;
48627 : }
48628 : }
48629 :
48630 0 : if ( p_startOfConstruct != NULL )
48631 : {
48632 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48633 : {
48634 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
48635 : {
48636 0 : std::cout << "SgPragmaDeclaration :: ";
48637 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
48638 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
48639 : }
48640 : }
48641 : else
48642 : {
48643 0 : std::cout << "SgPragmaDeclaration :: " << std::flush;
48644 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
48645 0 : std::cout << " not valid " << std::endl;
48646 : }
48647 : }
48648 :
48649 0 : if ( p_endOfConstruct != NULL )
48650 : {
48651 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48652 : {
48653 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
48654 : {
48655 0 : std::cout << "SgPragmaDeclaration :: ";
48656 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
48657 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
48658 : }
48659 : }
48660 : else
48661 : {
48662 0 : std::cout << "SgPragmaDeclaration :: " << std::flush;
48663 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
48664 0 : std::cout << " not valid " << std::endl;
48665 : }
48666 : }
48667 :
48668 0 : if ( p_parent != NULL )
48669 : {
48670 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48671 : {
48672 0 : if ( p_parent->isInMemoryPool() == false )
48673 : {
48674 0 : std::cout << "SgPragmaDeclaration :: ";
48675 0 : std::cout << " p_parent is not in memory pool of ";
48676 0 : std::cout << p_parent->class_name() << std::endl;
48677 : }
48678 : }
48679 : else
48680 : {
48681 0 : std::cout << "SgPragmaDeclaration :: " << std::flush;
48682 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
48683 0 : std::cout << " not valid " << std::endl;
48684 : }
48685 : }
48686 :
48687 :
48688 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
48689 :
48690 0 : }
48691 :
48692 :
48693 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
48694 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
48695 : bool
48696 0 : SgPragmaDeclaration::isInMemoryPool ()
48697 : {
48698 0 : typedef unsigned char* TestType;
48699 :
48700 0 : bool found = false;
48701 :
48702 0 : ROSE_ASSERT(this != NULL);
48703 :
48704 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
48705 :
48706 0 : TestType tested = (TestType) ( this ) ;
48707 :
48708 0 : std::vector < unsigned char* > :: const_iterator block = SgPragmaDeclaration::pools.begin();
48709 :
48710 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
48711 : // while (found == false && block < Memory_Block_List.end())
48712 0 : while ( (found == false) && (block != SgPragmaDeclaration::pools.end()) )
48713 : {
48714 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgPragmaDeclaration::pool_size * sizeof(SgPragmaDeclaration) ) ) ;
48715 0 : ++block;
48716 : }
48717 :
48718 : // Special handling for static data
48719 :
48720 :
48721 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
48722 0 : ROSE_ASSERT(found == true);
48723 :
48724 0 : return found;
48725 : }
48726 : /* #line 48727 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
48727 :
48728 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
48729 :
48730 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
48731 :
48732 : /* #line 48733 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
48733 :
48734 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
48735 :
48736 : void
48737 0 : SgUsingDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
48738 : {
48739 : // ------------ checking pointers of SgUsingDirectiveStatement -------------------
48740 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
48741 :
48742 0 : if ( p_namespaceDeclaration != NULL )
48743 : {
48744 0 : if ( p_namespaceDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48745 : {
48746 0 : if ( p_namespaceDeclaration->isInMemoryPool() == false )
48747 : {
48748 0 : std::cout << "SgUsingDirectiveStatement :: ";
48749 0 : std::cout << " p_namespaceDeclaration is not in memory pool of ";
48750 0 : std::cout << p_namespaceDeclaration->class_name() << std::endl;
48751 : }
48752 : }
48753 : else
48754 : {
48755 0 : std::cout << "SgUsingDirectiveStatement :: " << std::flush;
48756 0 : std::cout << "SgNamespaceDeclarationStatement* p_namespaceDeclaration = " << p_namespaceDeclaration << " --> " << std::flush;
48757 0 : std::cout << " not valid " << std::endl;
48758 : }
48759 : }
48760 :
48761 0 : if ( p_definingDeclaration != NULL )
48762 : {
48763 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48764 : {
48765 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
48766 : {
48767 0 : std::cout << "SgUsingDirectiveStatement :: ";
48768 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
48769 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
48770 : }
48771 : }
48772 : else
48773 : {
48774 0 : std::cout << "SgUsingDirectiveStatement :: " << std::flush;
48775 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
48776 0 : std::cout << " not valid " << std::endl;
48777 : }
48778 : }
48779 :
48780 0 : if ( p_firstNondefiningDeclaration != NULL )
48781 : {
48782 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48783 : {
48784 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
48785 : {
48786 0 : std::cout << "SgUsingDirectiveStatement :: ";
48787 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
48788 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
48789 : }
48790 : }
48791 : else
48792 : {
48793 0 : std::cout << "SgUsingDirectiveStatement :: " << std::flush;
48794 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
48795 0 : std::cout << " not valid " << std::endl;
48796 : }
48797 : }
48798 :
48799 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
48800 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
48801 : {
48802 0 : if ( (*i_qualifiedNameList) != NULL )
48803 : {
48804 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48805 : {
48806 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
48807 : {
48808 0 : std::cout << "SgUsingDirectiveStatement :: ";
48809 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
48810 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
48811 : }
48812 : }
48813 : else
48814 : {
48815 0 : std::cout << "SgUsingDirectiveStatement :: " << std::flush;
48816 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
48817 0 : std::cout << " entry not valid " << std::endl;
48818 : }
48819 : }
48820 : else
48821 : {
48822 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
48823 : }
48824 : }
48825 :
48826 0 : if ( p_declarationScope != NULL )
48827 : {
48828 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48829 : {
48830 0 : if ( p_declarationScope->isInMemoryPool() == false )
48831 : {
48832 0 : std::cout << "SgUsingDirectiveStatement :: ";
48833 0 : std::cout << " p_declarationScope is not in memory pool of ";
48834 0 : std::cout << p_declarationScope->class_name() << std::endl;
48835 : }
48836 : }
48837 : else
48838 : {
48839 0 : std::cout << "SgUsingDirectiveStatement :: " << std::flush;
48840 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
48841 0 : std::cout << " not valid " << std::endl;
48842 : }
48843 : }
48844 :
48845 0 : if ( p_numeric_label != NULL )
48846 : {
48847 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48848 : {
48849 0 : if ( p_numeric_label->isInMemoryPool() == false )
48850 : {
48851 0 : std::cout << "SgUsingDirectiveStatement :: ";
48852 0 : std::cout << " p_numeric_label is not in memory pool of ";
48853 0 : std::cout << p_numeric_label->class_name() << std::endl;
48854 : }
48855 : }
48856 : else
48857 : {
48858 0 : std::cout << "SgUsingDirectiveStatement :: " << std::flush;
48859 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
48860 0 : std::cout << " not valid " << std::endl;
48861 : }
48862 : }
48863 :
48864 0 : if ( p_startOfConstruct != NULL )
48865 : {
48866 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48867 : {
48868 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
48869 : {
48870 0 : std::cout << "SgUsingDirectiveStatement :: ";
48871 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
48872 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
48873 : }
48874 : }
48875 : else
48876 : {
48877 0 : std::cout << "SgUsingDirectiveStatement :: " << std::flush;
48878 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
48879 0 : std::cout << " not valid " << std::endl;
48880 : }
48881 : }
48882 :
48883 0 : if ( p_endOfConstruct != NULL )
48884 : {
48885 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48886 : {
48887 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
48888 : {
48889 0 : std::cout << "SgUsingDirectiveStatement :: ";
48890 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
48891 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
48892 : }
48893 : }
48894 : else
48895 : {
48896 0 : std::cout << "SgUsingDirectiveStatement :: " << std::flush;
48897 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
48898 0 : std::cout << " not valid " << std::endl;
48899 : }
48900 : }
48901 :
48902 0 : if ( p_parent != NULL )
48903 : {
48904 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48905 : {
48906 0 : if ( p_parent->isInMemoryPool() == false )
48907 : {
48908 0 : std::cout << "SgUsingDirectiveStatement :: ";
48909 0 : std::cout << " p_parent is not in memory pool of ";
48910 0 : std::cout << p_parent->class_name() << std::endl;
48911 : }
48912 : }
48913 : else
48914 : {
48915 0 : std::cout << "SgUsingDirectiveStatement :: " << std::flush;
48916 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
48917 0 : std::cout << " not valid " << std::endl;
48918 : }
48919 : }
48920 :
48921 :
48922 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
48923 :
48924 0 : }
48925 :
48926 :
48927 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
48928 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
48929 : bool
48930 0 : SgUsingDirectiveStatement::isInMemoryPool ()
48931 : {
48932 0 : typedef unsigned char* TestType;
48933 :
48934 0 : bool found = false;
48935 :
48936 0 : ROSE_ASSERT(this != NULL);
48937 :
48938 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
48939 :
48940 0 : TestType tested = (TestType) ( this ) ;
48941 :
48942 0 : std::vector < unsigned char* > :: const_iterator block = SgUsingDirectiveStatement::pools.begin();
48943 :
48944 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
48945 : // while (found == false && block < Memory_Block_List.end())
48946 0 : while ( (found == false) && (block != SgUsingDirectiveStatement::pools.end()) )
48947 : {
48948 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUsingDirectiveStatement::pool_size * sizeof(SgUsingDirectiveStatement) ) ) ;
48949 0 : ++block;
48950 : }
48951 :
48952 : // Special handling for static data
48953 :
48954 :
48955 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
48956 0 : ROSE_ASSERT(found == true);
48957 :
48958 0 : return found;
48959 : }
48960 : /* #line 48961 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
48961 :
48962 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
48963 :
48964 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
48965 :
48966 : /* #line 48967 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
48967 :
48968 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
48969 :
48970 : void
48971 0 : SgClassDeclaration::checkDataMemberPointersIfInMemoryPool()
48972 : {
48973 : // ------------ checking pointers of SgClassDeclaration -------------------
48974 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
48975 :
48976 0 : if ( p_type != NULL )
48977 : {
48978 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48979 : {
48980 0 : if ( p_type->isInMemoryPool() == false )
48981 : {
48982 0 : std::cout << "SgClassDeclaration :: ";
48983 0 : std::cout << " p_type is not in memory pool of ";
48984 0 : std::cout << p_type->class_name() << std::endl;
48985 : }
48986 : }
48987 : else
48988 : {
48989 0 : std::cout << "SgClassDeclaration :: " << std::flush;
48990 0 : std::cout << "SgClassType* p_type = " << p_type << " --> " << std::flush;
48991 0 : std::cout << " not valid " << std::endl;
48992 : }
48993 : }
48994 :
48995 0 : if ( p_definition != NULL )
48996 : {
48997 0 : if ( p_definition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
48998 : {
48999 0 : if ( p_definition->isInMemoryPool() == false )
49000 : {
49001 0 : std::cout << "SgClassDeclaration :: ";
49002 0 : std::cout << " p_definition is not in memory pool of ";
49003 0 : std::cout << p_definition->class_name() << std::endl;
49004 : }
49005 : }
49006 : else
49007 : {
49008 0 : std::cout << "SgClassDeclaration :: " << std::flush;
49009 0 : std::cout << "SgClassDefinition* p_definition = " << p_definition << " --> " << std::flush;
49010 0 : std::cout << " not valid " << std::endl;
49011 : }
49012 : }
49013 :
49014 0 : if ( p_scope != NULL )
49015 : {
49016 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49017 : {
49018 0 : if ( p_scope->isInMemoryPool() == false )
49019 : {
49020 0 : std::cout << "SgClassDeclaration :: ";
49021 0 : std::cout << " p_scope is not in memory pool of ";
49022 0 : std::cout << p_scope->class_name() << std::endl;
49023 : }
49024 : }
49025 : else
49026 : {
49027 0 : std::cout << "SgClassDeclaration :: " << std::flush;
49028 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
49029 0 : std::cout << " not valid " << std::endl;
49030 : }
49031 : }
49032 :
49033 0 : if ( p_decoratorList != NULL )
49034 : {
49035 0 : if ( p_decoratorList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49036 : {
49037 0 : if ( p_decoratorList->isInMemoryPool() == false )
49038 : {
49039 0 : std::cout << "SgClassDeclaration :: ";
49040 0 : std::cout << " p_decoratorList is not in memory pool of ";
49041 0 : std::cout << p_decoratorList->class_name() << std::endl;
49042 : }
49043 : }
49044 : else
49045 : {
49046 0 : std::cout << "SgClassDeclaration :: " << std::flush;
49047 0 : std::cout << "SgExprListExp* p_decoratorList = " << p_decoratorList << " --> " << std::flush;
49048 0 : std::cout << " not valid " << std::endl;
49049 : }
49050 : }
49051 :
49052 0 : if ( p_adaParentType != NULL )
49053 : {
49054 0 : if ( p_adaParentType->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49055 : {
49056 0 : if ( p_adaParentType->isInMemoryPool() == false )
49057 : {
49058 0 : std::cout << "SgClassDeclaration :: ";
49059 0 : std::cout << " p_adaParentType is not in memory pool of ";
49060 0 : std::cout << p_adaParentType->class_name() << std::endl;
49061 : }
49062 : }
49063 : else
49064 : {
49065 0 : std::cout << "SgClassDeclaration :: " << std::flush;
49066 0 : std::cout << "SgBaseClass* p_adaParentType = " << p_adaParentType << " --> " << std::flush;
49067 0 : std::cout << " not valid " << std::endl;
49068 : }
49069 : }
49070 :
49071 0 : if ( p_definingDeclaration != NULL )
49072 : {
49073 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49074 : {
49075 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
49076 : {
49077 0 : std::cout << "SgClassDeclaration :: ";
49078 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
49079 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
49080 : }
49081 : }
49082 : else
49083 : {
49084 0 : std::cout << "SgClassDeclaration :: " << std::flush;
49085 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
49086 0 : std::cout << " not valid " << std::endl;
49087 : }
49088 : }
49089 :
49090 0 : if ( p_firstNondefiningDeclaration != NULL )
49091 : {
49092 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49093 : {
49094 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
49095 : {
49096 0 : std::cout << "SgClassDeclaration :: ";
49097 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
49098 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
49099 : }
49100 : }
49101 : else
49102 : {
49103 0 : std::cout << "SgClassDeclaration :: " << std::flush;
49104 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
49105 0 : std::cout << " not valid " << std::endl;
49106 : }
49107 : }
49108 :
49109 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
49110 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
49111 : {
49112 0 : if ( (*i_qualifiedNameList) != NULL )
49113 : {
49114 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49115 : {
49116 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
49117 : {
49118 0 : std::cout << "SgClassDeclaration :: ";
49119 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
49120 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
49121 : }
49122 : }
49123 : else
49124 : {
49125 0 : std::cout << "SgClassDeclaration :: " << std::flush;
49126 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
49127 0 : std::cout << " entry not valid " << std::endl;
49128 : }
49129 : }
49130 : else
49131 : {
49132 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
49133 : }
49134 : }
49135 :
49136 0 : if ( p_declarationScope != NULL )
49137 : {
49138 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49139 : {
49140 0 : if ( p_declarationScope->isInMemoryPool() == false )
49141 : {
49142 0 : std::cout << "SgClassDeclaration :: ";
49143 0 : std::cout << " p_declarationScope is not in memory pool of ";
49144 0 : std::cout << p_declarationScope->class_name() << std::endl;
49145 : }
49146 : }
49147 : else
49148 : {
49149 0 : std::cout << "SgClassDeclaration :: " << std::flush;
49150 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
49151 0 : std::cout << " not valid " << std::endl;
49152 : }
49153 : }
49154 :
49155 0 : if ( p_numeric_label != NULL )
49156 : {
49157 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49158 : {
49159 0 : if ( p_numeric_label->isInMemoryPool() == false )
49160 : {
49161 0 : std::cout << "SgClassDeclaration :: ";
49162 0 : std::cout << " p_numeric_label is not in memory pool of ";
49163 0 : std::cout << p_numeric_label->class_name() << std::endl;
49164 : }
49165 : }
49166 : else
49167 : {
49168 0 : std::cout << "SgClassDeclaration :: " << std::flush;
49169 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
49170 0 : std::cout << " not valid " << std::endl;
49171 : }
49172 : }
49173 :
49174 0 : if ( p_startOfConstruct != NULL )
49175 : {
49176 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49177 : {
49178 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
49179 : {
49180 0 : std::cout << "SgClassDeclaration :: ";
49181 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
49182 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
49183 : }
49184 : }
49185 : else
49186 : {
49187 0 : std::cout << "SgClassDeclaration :: " << std::flush;
49188 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
49189 0 : std::cout << " not valid " << std::endl;
49190 : }
49191 : }
49192 :
49193 0 : if ( p_endOfConstruct != NULL )
49194 : {
49195 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49196 : {
49197 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
49198 : {
49199 0 : std::cout << "SgClassDeclaration :: ";
49200 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
49201 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
49202 : }
49203 : }
49204 : else
49205 : {
49206 0 : std::cout << "SgClassDeclaration :: " << std::flush;
49207 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
49208 0 : std::cout << " not valid " << std::endl;
49209 : }
49210 : }
49211 :
49212 0 : if ( p_parent != NULL )
49213 : {
49214 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49215 : {
49216 0 : if ( p_parent->isInMemoryPool() == false )
49217 : {
49218 0 : std::cout << "SgClassDeclaration :: ";
49219 0 : std::cout << " p_parent is not in memory pool of ";
49220 0 : std::cout << p_parent->class_name() << std::endl;
49221 : }
49222 : }
49223 : else
49224 : {
49225 0 : std::cout << "SgClassDeclaration :: " << std::flush;
49226 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
49227 0 : std::cout << " not valid " << std::endl;
49228 : }
49229 : }
49230 :
49231 :
49232 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
49233 :
49234 0 : }
49235 :
49236 :
49237 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
49238 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
49239 : bool
49240 0 : SgClassDeclaration::isInMemoryPool ()
49241 : {
49242 0 : typedef unsigned char* TestType;
49243 :
49244 0 : bool found = false;
49245 :
49246 0 : ROSE_ASSERT(this != NULL);
49247 :
49248 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
49249 :
49250 0 : TestType tested = (TestType) ( this ) ;
49251 :
49252 0 : std::vector < unsigned char* > :: const_iterator block = SgClassDeclaration::pools.begin();
49253 :
49254 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
49255 : // while (found == false && block < Memory_Block_List.end())
49256 0 : while ( (found == false) && (block != SgClassDeclaration::pools.end()) )
49257 : {
49258 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgClassDeclaration::pool_size * sizeof(SgClassDeclaration) ) ) ;
49259 0 : ++block;
49260 : }
49261 :
49262 : // Special handling for static data
49263 :
49264 :
49265 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
49266 0 : ROSE_ASSERT(found == true);
49267 :
49268 0 : return found;
49269 : }
49270 : /* #line 49271 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
49271 :
49272 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
49273 :
49274 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
49275 :
49276 : /* #line 49277 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
49277 :
49278 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
49279 :
49280 : void
49281 0 : SgTemplateClassDeclaration::checkDataMemberPointersIfInMemoryPool()
49282 : {
49283 : // ------------ checking pointers of SgTemplateClassDeclaration -------------------
49284 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
49285 :
49286 0 : SgTemplateParameterPtrList::iterator i_templateParameters = p_templateParameters.begin() ;
49287 0 : for ( ; i_templateParameters != p_templateParameters.end(); ++i_templateParameters )
49288 : {
49289 0 : if ( (*i_templateParameters) != NULL )
49290 : {
49291 0 : if ( (*i_templateParameters)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49292 : {
49293 0 : if ( (*i_templateParameters)->isInMemoryPool() == false )
49294 : {
49295 0 : std::cout << "SgTemplateClassDeclaration :: ";
49296 0 : std::cout << " p_templateParameters ( list of poitners to IR nodes ), entry is not in memory pool of ";
49297 0 : std::cout << (*i_templateParameters)->class_name() << std::endl;
49298 : }
49299 : }
49300 : else
49301 : {
49302 0 : std::cout << "SgTemplateClassDeclaration :: " << std::flush;
49303 0 : std::cout << "SgTemplateParameterPtrList p_templateParameters --> " << std::flush;
49304 0 : std::cout << " entry not valid " << std::endl;
49305 : }
49306 : }
49307 : else
49308 : {
49309 0 : std::cout << "SgTemplateParameterPtrList p_templateParameters --> NULL " << std::endl;
49310 : }
49311 : }
49312 :
49313 0 : SgTemplateArgumentPtrList::iterator i_templateSpecializationArguments = p_templateSpecializationArguments.begin() ;
49314 0 : for ( ; i_templateSpecializationArguments != p_templateSpecializationArguments.end(); ++i_templateSpecializationArguments )
49315 : {
49316 0 : if ( (*i_templateSpecializationArguments) != NULL )
49317 : {
49318 0 : if ( (*i_templateSpecializationArguments)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49319 : {
49320 0 : if ( (*i_templateSpecializationArguments)->isInMemoryPool() == false )
49321 : {
49322 0 : std::cout << "SgTemplateClassDeclaration :: ";
49323 0 : std::cout << " p_templateSpecializationArguments ( list of poitners to IR nodes ), entry is not in memory pool of ";
49324 0 : std::cout << (*i_templateSpecializationArguments)->class_name() << std::endl;
49325 : }
49326 : }
49327 : else
49328 : {
49329 0 : std::cout << "SgTemplateClassDeclaration :: " << std::flush;
49330 0 : std::cout << "SgTemplateArgumentPtrList p_templateSpecializationArguments --> " << std::flush;
49331 0 : std::cout << " entry not valid " << std::endl;
49332 : }
49333 : }
49334 : else
49335 : {
49336 0 : std::cout << "SgTemplateArgumentPtrList p_templateSpecializationArguments --> NULL " << std::endl;
49337 : }
49338 : }
49339 :
49340 0 : if ( p_nonreal_decl_scope != NULL )
49341 : {
49342 0 : if ( p_nonreal_decl_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49343 : {
49344 0 : if ( p_nonreal_decl_scope->isInMemoryPool() == false )
49345 : {
49346 0 : std::cout << "SgTemplateClassDeclaration :: ";
49347 0 : std::cout << " p_nonreal_decl_scope is not in memory pool of ";
49348 0 : std::cout << p_nonreal_decl_scope->class_name() << std::endl;
49349 : }
49350 : }
49351 : else
49352 : {
49353 0 : std::cout << "SgTemplateClassDeclaration :: " << std::flush;
49354 0 : std::cout << "SgDeclarationScope* p_nonreal_decl_scope = " << p_nonreal_decl_scope << " --> " << std::flush;
49355 0 : std::cout << " not valid " << std::endl;
49356 : }
49357 : }
49358 :
49359 0 : if ( p_type != NULL )
49360 : {
49361 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49362 : {
49363 0 : if ( p_type->isInMemoryPool() == false )
49364 : {
49365 0 : std::cout << "SgTemplateClassDeclaration :: ";
49366 0 : std::cout << " p_type is not in memory pool of ";
49367 0 : std::cout << p_type->class_name() << std::endl;
49368 : }
49369 : }
49370 : else
49371 : {
49372 0 : std::cout << "SgTemplateClassDeclaration :: " << std::flush;
49373 0 : std::cout << "SgClassType* p_type = " << p_type << " --> " << std::flush;
49374 0 : std::cout << " not valid " << std::endl;
49375 : }
49376 : }
49377 :
49378 0 : if ( p_definition != NULL )
49379 : {
49380 0 : if ( p_definition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49381 : {
49382 0 : if ( p_definition->isInMemoryPool() == false )
49383 : {
49384 0 : std::cout << "SgTemplateClassDeclaration :: ";
49385 0 : std::cout << " p_definition is not in memory pool of ";
49386 0 : std::cout << p_definition->class_name() << std::endl;
49387 : }
49388 : }
49389 : else
49390 : {
49391 0 : std::cout << "SgTemplateClassDeclaration :: " << std::flush;
49392 0 : std::cout << "SgClassDefinition* p_definition = " << p_definition << " --> " << std::flush;
49393 0 : std::cout << " not valid " << std::endl;
49394 : }
49395 : }
49396 :
49397 0 : if ( p_scope != NULL )
49398 : {
49399 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49400 : {
49401 0 : if ( p_scope->isInMemoryPool() == false )
49402 : {
49403 0 : std::cout << "SgTemplateClassDeclaration :: ";
49404 0 : std::cout << " p_scope is not in memory pool of ";
49405 0 : std::cout << p_scope->class_name() << std::endl;
49406 : }
49407 : }
49408 : else
49409 : {
49410 0 : std::cout << "SgTemplateClassDeclaration :: " << std::flush;
49411 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
49412 0 : std::cout << " not valid " << std::endl;
49413 : }
49414 : }
49415 :
49416 0 : if ( p_decoratorList != NULL )
49417 : {
49418 0 : if ( p_decoratorList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49419 : {
49420 0 : if ( p_decoratorList->isInMemoryPool() == false )
49421 : {
49422 0 : std::cout << "SgTemplateClassDeclaration :: ";
49423 0 : std::cout << " p_decoratorList is not in memory pool of ";
49424 0 : std::cout << p_decoratorList->class_name() << std::endl;
49425 : }
49426 : }
49427 : else
49428 : {
49429 0 : std::cout << "SgTemplateClassDeclaration :: " << std::flush;
49430 0 : std::cout << "SgExprListExp* p_decoratorList = " << p_decoratorList << " --> " << std::flush;
49431 0 : std::cout << " not valid " << std::endl;
49432 : }
49433 : }
49434 :
49435 0 : if ( p_adaParentType != NULL )
49436 : {
49437 0 : if ( p_adaParentType->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49438 : {
49439 0 : if ( p_adaParentType->isInMemoryPool() == false )
49440 : {
49441 0 : std::cout << "SgTemplateClassDeclaration :: ";
49442 0 : std::cout << " p_adaParentType is not in memory pool of ";
49443 0 : std::cout << p_adaParentType->class_name() << std::endl;
49444 : }
49445 : }
49446 : else
49447 : {
49448 0 : std::cout << "SgTemplateClassDeclaration :: " << std::flush;
49449 0 : std::cout << "SgBaseClass* p_adaParentType = " << p_adaParentType << " --> " << std::flush;
49450 0 : std::cout << " not valid " << std::endl;
49451 : }
49452 : }
49453 :
49454 0 : if ( p_definingDeclaration != NULL )
49455 : {
49456 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49457 : {
49458 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
49459 : {
49460 0 : std::cout << "SgTemplateClassDeclaration :: ";
49461 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
49462 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
49463 : }
49464 : }
49465 : else
49466 : {
49467 0 : std::cout << "SgTemplateClassDeclaration :: " << std::flush;
49468 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
49469 0 : std::cout << " not valid " << std::endl;
49470 : }
49471 : }
49472 :
49473 0 : if ( p_firstNondefiningDeclaration != NULL )
49474 : {
49475 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49476 : {
49477 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
49478 : {
49479 0 : std::cout << "SgTemplateClassDeclaration :: ";
49480 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
49481 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
49482 : }
49483 : }
49484 : else
49485 : {
49486 0 : std::cout << "SgTemplateClassDeclaration :: " << std::flush;
49487 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
49488 0 : std::cout << " not valid " << std::endl;
49489 : }
49490 : }
49491 :
49492 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
49493 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
49494 : {
49495 0 : if ( (*i_qualifiedNameList) != NULL )
49496 : {
49497 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49498 : {
49499 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
49500 : {
49501 0 : std::cout << "SgTemplateClassDeclaration :: ";
49502 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
49503 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
49504 : }
49505 : }
49506 : else
49507 : {
49508 0 : std::cout << "SgTemplateClassDeclaration :: " << std::flush;
49509 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
49510 0 : std::cout << " entry not valid " << std::endl;
49511 : }
49512 : }
49513 : else
49514 : {
49515 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
49516 : }
49517 : }
49518 :
49519 0 : if ( p_declarationScope != NULL )
49520 : {
49521 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49522 : {
49523 0 : if ( p_declarationScope->isInMemoryPool() == false )
49524 : {
49525 0 : std::cout << "SgTemplateClassDeclaration :: ";
49526 0 : std::cout << " p_declarationScope is not in memory pool of ";
49527 0 : std::cout << p_declarationScope->class_name() << std::endl;
49528 : }
49529 : }
49530 : else
49531 : {
49532 0 : std::cout << "SgTemplateClassDeclaration :: " << std::flush;
49533 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
49534 0 : std::cout << " not valid " << std::endl;
49535 : }
49536 : }
49537 :
49538 0 : if ( p_numeric_label != NULL )
49539 : {
49540 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49541 : {
49542 0 : if ( p_numeric_label->isInMemoryPool() == false )
49543 : {
49544 0 : std::cout << "SgTemplateClassDeclaration :: ";
49545 0 : std::cout << " p_numeric_label is not in memory pool of ";
49546 0 : std::cout << p_numeric_label->class_name() << std::endl;
49547 : }
49548 : }
49549 : else
49550 : {
49551 0 : std::cout << "SgTemplateClassDeclaration :: " << std::flush;
49552 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
49553 0 : std::cout << " not valid " << std::endl;
49554 : }
49555 : }
49556 :
49557 0 : if ( p_startOfConstruct != NULL )
49558 : {
49559 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49560 : {
49561 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
49562 : {
49563 0 : std::cout << "SgTemplateClassDeclaration :: ";
49564 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
49565 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
49566 : }
49567 : }
49568 : else
49569 : {
49570 0 : std::cout << "SgTemplateClassDeclaration :: " << std::flush;
49571 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
49572 0 : std::cout << " not valid " << std::endl;
49573 : }
49574 : }
49575 :
49576 0 : if ( p_endOfConstruct != NULL )
49577 : {
49578 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49579 : {
49580 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
49581 : {
49582 0 : std::cout << "SgTemplateClassDeclaration :: ";
49583 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
49584 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
49585 : }
49586 : }
49587 : else
49588 : {
49589 0 : std::cout << "SgTemplateClassDeclaration :: " << std::flush;
49590 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
49591 0 : std::cout << " not valid " << std::endl;
49592 : }
49593 : }
49594 :
49595 0 : if ( p_parent != NULL )
49596 : {
49597 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49598 : {
49599 0 : if ( p_parent->isInMemoryPool() == false )
49600 : {
49601 0 : std::cout << "SgTemplateClassDeclaration :: ";
49602 0 : std::cout << " p_parent is not in memory pool of ";
49603 0 : std::cout << p_parent->class_name() << std::endl;
49604 : }
49605 : }
49606 : else
49607 : {
49608 0 : std::cout << "SgTemplateClassDeclaration :: " << std::flush;
49609 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
49610 0 : std::cout << " not valid " << std::endl;
49611 : }
49612 : }
49613 :
49614 :
49615 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
49616 :
49617 0 : }
49618 :
49619 :
49620 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
49621 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
49622 : bool
49623 0 : SgTemplateClassDeclaration::isInMemoryPool ()
49624 : {
49625 0 : typedef unsigned char* TestType;
49626 :
49627 0 : bool found = false;
49628 :
49629 0 : ROSE_ASSERT(this != NULL);
49630 :
49631 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
49632 :
49633 0 : TestType tested = (TestType) ( this ) ;
49634 :
49635 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateClassDeclaration::pools.begin();
49636 :
49637 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
49638 : // while (found == false && block < Memory_Block_List.end())
49639 0 : while ( (found == false) && (block != SgTemplateClassDeclaration::pools.end()) )
49640 : {
49641 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateClassDeclaration::pool_size * sizeof(SgTemplateClassDeclaration) ) ) ;
49642 0 : ++block;
49643 : }
49644 :
49645 : // Special handling for static data
49646 :
49647 :
49648 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
49649 0 : ROSE_ASSERT(found == true);
49650 :
49651 0 : return found;
49652 : }
49653 : /* #line 49654 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
49654 :
49655 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
49656 :
49657 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
49658 :
49659 : /* #line 49660 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
49660 :
49661 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
49662 :
49663 : void
49664 0 : SgTemplateInstantiationDecl::checkDataMemberPointersIfInMemoryPool()
49665 : {
49666 : // ------------ checking pointers of SgTemplateInstantiationDecl -------------------
49667 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
49668 :
49669 0 : if ( p_templateDeclaration != NULL )
49670 : {
49671 0 : if ( p_templateDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49672 : {
49673 0 : if ( p_templateDeclaration->isInMemoryPool() == false )
49674 : {
49675 0 : std::cout << "SgTemplateInstantiationDecl :: ";
49676 0 : std::cout << " p_templateDeclaration is not in memory pool of ";
49677 0 : std::cout << p_templateDeclaration->class_name() << std::endl;
49678 : }
49679 : }
49680 : else
49681 : {
49682 0 : std::cout << "SgTemplateInstantiationDecl :: " << std::flush;
49683 0 : std::cout << "SgTemplateClassDeclaration* p_templateDeclaration = " << p_templateDeclaration << " --> " << std::flush;
49684 0 : std::cout << " not valid " << std::endl;
49685 : }
49686 : }
49687 :
49688 0 : SgTemplateArgumentPtrList::iterator i_templateArguments = p_templateArguments.begin() ;
49689 0 : for ( ; i_templateArguments != p_templateArguments.end(); ++i_templateArguments )
49690 : {
49691 0 : if ( (*i_templateArguments) != NULL )
49692 : {
49693 0 : if ( (*i_templateArguments)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49694 : {
49695 0 : if ( (*i_templateArguments)->isInMemoryPool() == false )
49696 : {
49697 0 : std::cout << "SgTemplateInstantiationDecl :: ";
49698 0 : std::cout << " p_templateArguments ( list of poitners to IR nodes ), entry is not in memory pool of ";
49699 0 : std::cout << (*i_templateArguments)->class_name() << std::endl;
49700 : }
49701 : }
49702 : else
49703 : {
49704 0 : std::cout << "SgTemplateInstantiationDecl :: " << std::flush;
49705 0 : std::cout << "SgTemplateArgumentPtrList p_templateArguments --> " << std::flush;
49706 0 : std::cout << " entry not valid " << std::endl;
49707 : }
49708 : }
49709 : else
49710 : {
49711 0 : std::cout << "SgTemplateArgumentPtrList p_templateArguments --> NULL " << std::endl;
49712 : }
49713 : }
49714 :
49715 0 : if ( p_type != NULL )
49716 : {
49717 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49718 : {
49719 0 : if ( p_type->isInMemoryPool() == false )
49720 : {
49721 0 : std::cout << "SgTemplateInstantiationDecl :: ";
49722 0 : std::cout << " p_type is not in memory pool of ";
49723 0 : std::cout << p_type->class_name() << std::endl;
49724 : }
49725 : }
49726 : else
49727 : {
49728 0 : std::cout << "SgTemplateInstantiationDecl :: " << std::flush;
49729 0 : std::cout << "SgClassType* p_type = " << p_type << " --> " << std::flush;
49730 0 : std::cout << " not valid " << std::endl;
49731 : }
49732 : }
49733 :
49734 0 : if ( p_definition != NULL )
49735 : {
49736 0 : if ( p_definition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49737 : {
49738 0 : if ( p_definition->isInMemoryPool() == false )
49739 : {
49740 0 : std::cout << "SgTemplateInstantiationDecl :: ";
49741 0 : std::cout << " p_definition is not in memory pool of ";
49742 0 : std::cout << p_definition->class_name() << std::endl;
49743 : }
49744 : }
49745 : else
49746 : {
49747 0 : std::cout << "SgTemplateInstantiationDecl :: " << std::flush;
49748 0 : std::cout << "SgClassDefinition* p_definition = " << p_definition << " --> " << std::flush;
49749 0 : std::cout << " not valid " << std::endl;
49750 : }
49751 : }
49752 :
49753 0 : if ( p_scope != NULL )
49754 : {
49755 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49756 : {
49757 0 : if ( p_scope->isInMemoryPool() == false )
49758 : {
49759 0 : std::cout << "SgTemplateInstantiationDecl :: ";
49760 0 : std::cout << " p_scope is not in memory pool of ";
49761 0 : std::cout << p_scope->class_name() << std::endl;
49762 : }
49763 : }
49764 : else
49765 : {
49766 0 : std::cout << "SgTemplateInstantiationDecl :: " << std::flush;
49767 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
49768 0 : std::cout << " not valid " << std::endl;
49769 : }
49770 : }
49771 :
49772 0 : if ( p_decoratorList != NULL )
49773 : {
49774 0 : if ( p_decoratorList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49775 : {
49776 0 : if ( p_decoratorList->isInMemoryPool() == false )
49777 : {
49778 0 : std::cout << "SgTemplateInstantiationDecl :: ";
49779 0 : std::cout << " p_decoratorList is not in memory pool of ";
49780 0 : std::cout << p_decoratorList->class_name() << std::endl;
49781 : }
49782 : }
49783 : else
49784 : {
49785 0 : std::cout << "SgTemplateInstantiationDecl :: " << std::flush;
49786 0 : std::cout << "SgExprListExp* p_decoratorList = " << p_decoratorList << " --> " << std::flush;
49787 0 : std::cout << " not valid " << std::endl;
49788 : }
49789 : }
49790 :
49791 0 : if ( p_adaParentType != NULL )
49792 : {
49793 0 : if ( p_adaParentType->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49794 : {
49795 0 : if ( p_adaParentType->isInMemoryPool() == false )
49796 : {
49797 0 : std::cout << "SgTemplateInstantiationDecl :: ";
49798 0 : std::cout << " p_adaParentType is not in memory pool of ";
49799 0 : std::cout << p_adaParentType->class_name() << std::endl;
49800 : }
49801 : }
49802 : else
49803 : {
49804 0 : std::cout << "SgTemplateInstantiationDecl :: " << std::flush;
49805 0 : std::cout << "SgBaseClass* p_adaParentType = " << p_adaParentType << " --> " << std::flush;
49806 0 : std::cout << " not valid " << std::endl;
49807 : }
49808 : }
49809 :
49810 0 : if ( p_definingDeclaration != NULL )
49811 : {
49812 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49813 : {
49814 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
49815 : {
49816 0 : std::cout << "SgTemplateInstantiationDecl :: ";
49817 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
49818 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
49819 : }
49820 : }
49821 : else
49822 : {
49823 0 : std::cout << "SgTemplateInstantiationDecl :: " << std::flush;
49824 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
49825 0 : std::cout << " not valid " << std::endl;
49826 : }
49827 : }
49828 :
49829 0 : if ( p_firstNondefiningDeclaration != NULL )
49830 : {
49831 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49832 : {
49833 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
49834 : {
49835 0 : std::cout << "SgTemplateInstantiationDecl :: ";
49836 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
49837 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
49838 : }
49839 : }
49840 : else
49841 : {
49842 0 : std::cout << "SgTemplateInstantiationDecl :: " << std::flush;
49843 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
49844 0 : std::cout << " not valid " << std::endl;
49845 : }
49846 : }
49847 :
49848 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
49849 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
49850 : {
49851 0 : if ( (*i_qualifiedNameList) != NULL )
49852 : {
49853 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49854 : {
49855 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
49856 : {
49857 0 : std::cout << "SgTemplateInstantiationDecl :: ";
49858 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
49859 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
49860 : }
49861 : }
49862 : else
49863 : {
49864 0 : std::cout << "SgTemplateInstantiationDecl :: " << std::flush;
49865 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
49866 0 : std::cout << " entry not valid " << std::endl;
49867 : }
49868 : }
49869 : else
49870 : {
49871 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
49872 : }
49873 : }
49874 :
49875 0 : if ( p_declarationScope != NULL )
49876 : {
49877 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49878 : {
49879 0 : if ( p_declarationScope->isInMemoryPool() == false )
49880 : {
49881 0 : std::cout << "SgTemplateInstantiationDecl :: ";
49882 0 : std::cout << " p_declarationScope is not in memory pool of ";
49883 0 : std::cout << p_declarationScope->class_name() << std::endl;
49884 : }
49885 : }
49886 : else
49887 : {
49888 0 : std::cout << "SgTemplateInstantiationDecl :: " << std::flush;
49889 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
49890 0 : std::cout << " not valid " << std::endl;
49891 : }
49892 : }
49893 :
49894 0 : if ( p_numeric_label != NULL )
49895 : {
49896 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49897 : {
49898 0 : if ( p_numeric_label->isInMemoryPool() == false )
49899 : {
49900 0 : std::cout << "SgTemplateInstantiationDecl :: ";
49901 0 : std::cout << " p_numeric_label is not in memory pool of ";
49902 0 : std::cout << p_numeric_label->class_name() << std::endl;
49903 : }
49904 : }
49905 : else
49906 : {
49907 0 : std::cout << "SgTemplateInstantiationDecl :: " << std::flush;
49908 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
49909 0 : std::cout << " not valid " << std::endl;
49910 : }
49911 : }
49912 :
49913 0 : if ( p_startOfConstruct != NULL )
49914 : {
49915 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49916 : {
49917 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
49918 : {
49919 0 : std::cout << "SgTemplateInstantiationDecl :: ";
49920 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
49921 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
49922 : }
49923 : }
49924 : else
49925 : {
49926 0 : std::cout << "SgTemplateInstantiationDecl :: " << std::flush;
49927 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
49928 0 : std::cout << " not valid " << std::endl;
49929 : }
49930 : }
49931 :
49932 0 : if ( p_endOfConstruct != NULL )
49933 : {
49934 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49935 : {
49936 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
49937 : {
49938 0 : std::cout << "SgTemplateInstantiationDecl :: ";
49939 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
49940 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
49941 : }
49942 : }
49943 : else
49944 : {
49945 0 : std::cout << "SgTemplateInstantiationDecl :: " << std::flush;
49946 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
49947 0 : std::cout << " not valid " << std::endl;
49948 : }
49949 : }
49950 :
49951 0 : if ( p_parent != NULL )
49952 : {
49953 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
49954 : {
49955 0 : if ( p_parent->isInMemoryPool() == false )
49956 : {
49957 0 : std::cout << "SgTemplateInstantiationDecl :: ";
49958 0 : std::cout << " p_parent is not in memory pool of ";
49959 0 : std::cout << p_parent->class_name() << std::endl;
49960 : }
49961 : }
49962 : else
49963 : {
49964 0 : std::cout << "SgTemplateInstantiationDecl :: " << std::flush;
49965 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
49966 0 : std::cout << " not valid " << std::endl;
49967 : }
49968 : }
49969 :
49970 :
49971 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
49972 :
49973 0 : }
49974 :
49975 :
49976 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
49977 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
49978 : bool
49979 0 : SgTemplateInstantiationDecl::isInMemoryPool ()
49980 : {
49981 0 : typedef unsigned char* TestType;
49982 :
49983 0 : bool found = false;
49984 :
49985 0 : ROSE_ASSERT(this != NULL);
49986 :
49987 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
49988 :
49989 0 : TestType tested = (TestType) ( this ) ;
49990 :
49991 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateInstantiationDecl::pools.begin();
49992 :
49993 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
49994 : // while (found == false && block < Memory_Block_List.end())
49995 0 : while ( (found == false) && (block != SgTemplateInstantiationDecl::pools.end()) )
49996 : {
49997 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateInstantiationDecl::pool_size * sizeof(SgTemplateInstantiationDecl) ) ) ;
49998 0 : ++block;
49999 : }
50000 :
50001 : // Special handling for static data
50002 :
50003 :
50004 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
50005 0 : ROSE_ASSERT(found == true);
50006 :
50007 0 : return found;
50008 : }
50009 : /* #line 50010 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
50010 :
50011 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
50012 :
50013 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
50014 :
50015 : /* #line 50016 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
50016 :
50017 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
50018 :
50019 : void
50020 0 : SgDerivedTypeStatement::checkDataMemberPointersIfInMemoryPool()
50021 : {
50022 : // ------------ checking pointers of SgDerivedTypeStatement -------------------
50023 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
50024 :
50025 0 : if ( p_end_numeric_label != NULL )
50026 : {
50027 0 : if ( p_end_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50028 : {
50029 0 : if ( p_end_numeric_label->isInMemoryPool() == false )
50030 : {
50031 0 : std::cout << "SgDerivedTypeStatement :: ";
50032 0 : std::cout << " p_end_numeric_label is not in memory pool of ";
50033 0 : std::cout << p_end_numeric_label->class_name() << std::endl;
50034 : }
50035 : }
50036 : else
50037 : {
50038 0 : std::cout << "SgDerivedTypeStatement :: " << std::flush;
50039 0 : std::cout << "SgLabelRefExp* p_end_numeric_label = " << p_end_numeric_label << " --> " << std::flush;
50040 0 : std::cout << " not valid " << std::endl;
50041 : }
50042 : }
50043 :
50044 0 : if ( p_type != NULL )
50045 : {
50046 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50047 : {
50048 0 : if ( p_type->isInMemoryPool() == false )
50049 : {
50050 0 : std::cout << "SgDerivedTypeStatement :: ";
50051 0 : std::cout << " p_type is not in memory pool of ";
50052 0 : std::cout << p_type->class_name() << std::endl;
50053 : }
50054 : }
50055 : else
50056 : {
50057 0 : std::cout << "SgDerivedTypeStatement :: " << std::flush;
50058 0 : std::cout << "SgClassType* p_type = " << p_type << " --> " << std::flush;
50059 0 : std::cout << " not valid " << std::endl;
50060 : }
50061 : }
50062 :
50063 0 : if ( p_definition != NULL )
50064 : {
50065 0 : if ( p_definition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50066 : {
50067 0 : if ( p_definition->isInMemoryPool() == false )
50068 : {
50069 0 : std::cout << "SgDerivedTypeStatement :: ";
50070 0 : std::cout << " p_definition is not in memory pool of ";
50071 0 : std::cout << p_definition->class_name() << std::endl;
50072 : }
50073 : }
50074 : else
50075 : {
50076 0 : std::cout << "SgDerivedTypeStatement :: " << std::flush;
50077 0 : std::cout << "SgClassDefinition* p_definition = " << p_definition << " --> " << std::flush;
50078 0 : std::cout << " not valid " << std::endl;
50079 : }
50080 : }
50081 :
50082 0 : if ( p_scope != NULL )
50083 : {
50084 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50085 : {
50086 0 : if ( p_scope->isInMemoryPool() == false )
50087 : {
50088 0 : std::cout << "SgDerivedTypeStatement :: ";
50089 0 : std::cout << " p_scope is not in memory pool of ";
50090 0 : std::cout << p_scope->class_name() << std::endl;
50091 : }
50092 : }
50093 : else
50094 : {
50095 0 : std::cout << "SgDerivedTypeStatement :: " << std::flush;
50096 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
50097 0 : std::cout << " not valid " << std::endl;
50098 : }
50099 : }
50100 :
50101 0 : if ( p_decoratorList != NULL )
50102 : {
50103 0 : if ( p_decoratorList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50104 : {
50105 0 : if ( p_decoratorList->isInMemoryPool() == false )
50106 : {
50107 0 : std::cout << "SgDerivedTypeStatement :: ";
50108 0 : std::cout << " p_decoratorList is not in memory pool of ";
50109 0 : std::cout << p_decoratorList->class_name() << std::endl;
50110 : }
50111 : }
50112 : else
50113 : {
50114 0 : std::cout << "SgDerivedTypeStatement :: " << std::flush;
50115 0 : std::cout << "SgExprListExp* p_decoratorList = " << p_decoratorList << " --> " << std::flush;
50116 0 : std::cout << " not valid " << std::endl;
50117 : }
50118 : }
50119 :
50120 0 : if ( p_adaParentType != NULL )
50121 : {
50122 0 : if ( p_adaParentType->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50123 : {
50124 0 : if ( p_adaParentType->isInMemoryPool() == false )
50125 : {
50126 0 : std::cout << "SgDerivedTypeStatement :: ";
50127 0 : std::cout << " p_adaParentType is not in memory pool of ";
50128 0 : std::cout << p_adaParentType->class_name() << std::endl;
50129 : }
50130 : }
50131 : else
50132 : {
50133 0 : std::cout << "SgDerivedTypeStatement :: " << std::flush;
50134 0 : std::cout << "SgBaseClass* p_adaParentType = " << p_adaParentType << " --> " << std::flush;
50135 0 : std::cout << " not valid " << std::endl;
50136 : }
50137 : }
50138 :
50139 0 : if ( p_definingDeclaration != NULL )
50140 : {
50141 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50142 : {
50143 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
50144 : {
50145 0 : std::cout << "SgDerivedTypeStatement :: ";
50146 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
50147 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
50148 : }
50149 : }
50150 : else
50151 : {
50152 0 : std::cout << "SgDerivedTypeStatement :: " << std::flush;
50153 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
50154 0 : std::cout << " not valid " << std::endl;
50155 : }
50156 : }
50157 :
50158 0 : if ( p_firstNondefiningDeclaration != NULL )
50159 : {
50160 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50161 : {
50162 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
50163 : {
50164 0 : std::cout << "SgDerivedTypeStatement :: ";
50165 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
50166 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
50167 : }
50168 : }
50169 : else
50170 : {
50171 0 : std::cout << "SgDerivedTypeStatement :: " << std::flush;
50172 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
50173 0 : std::cout << " not valid " << std::endl;
50174 : }
50175 : }
50176 :
50177 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
50178 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
50179 : {
50180 0 : if ( (*i_qualifiedNameList) != NULL )
50181 : {
50182 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50183 : {
50184 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
50185 : {
50186 0 : std::cout << "SgDerivedTypeStatement :: ";
50187 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
50188 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
50189 : }
50190 : }
50191 : else
50192 : {
50193 0 : std::cout << "SgDerivedTypeStatement :: " << std::flush;
50194 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
50195 0 : std::cout << " entry not valid " << std::endl;
50196 : }
50197 : }
50198 : else
50199 : {
50200 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
50201 : }
50202 : }
50203 :
50204 0 : if ( p_declarationScope != NULL )
50205 : {
50206 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50207 : {
50208 0 : if ( p_declarationScope->isInMemoryPool() == false )
50209 : {
50210 0 : std::cout << "SgDerivedTypeStatement :: ";
50211 0 : std::cout << " p_declarationScope is not in memory pool of ";
50212 0 : std::cout << p_declarationScope->class_name() << std::endl;
50213 : }
50214 : }
50215 : else
50216 : {
50217 0 : std::cout << "SgDerivedTypeStatement :: " << std::flush;
50218 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
50219 0 : std::cout << " not valid " << std::endl;
50220 : }
50221 : }
50222 :
50223 0 : if ( p_numeric_label != NULL )
50224 : {
50225 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50226 : {
50227 0 : if ( p_numeric_label->isInMemoryPool() == false )
50228 : {
50229 0 : std::cout << "SgDerivedTypeStatement :: ";
50230 0 : std::cout << " p_numeric_label is not in memory pool of ";
50231 0 : std::cout << p_numeric_label->class_name() << std::endl;
50232 : }
50233 : }
50234 : else
50235 : {
50236 0 : std::cout << "SgDerivedTypeStatement :: " << std::flush;
50237 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
50238 0 : std::cout << " not valid " << std::endl;
50239 : }
50240 : }
50241 :
50242 0 : if ( p_startOfConstruct != NULL )
50243 : {
50244 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50245 : {
50246 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
50247 : {
50248 0 : std::cout << "SgDerivedTypeStatement :: ";
50249 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
50250 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
50251 : }
50252 : }
50253 : else
50254 : {
50255 0 : std::cout << "SgDerivedTypeStatement :: " << std::flush;
50256 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
50257 0 : std::cout << " not valid " << std::endl;
50258 : }
50259 : }
50260 :
50261 0 : if ( p_endOfConstruct != NULL )
50262 : {
50263 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50264 : {
50265 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
50266 : {
50267 0 : std::cout << "SgDerivedTypeStatement :: ";
50268 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
50269 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
50270 : }
50271 : }
50272 : else
50273 : {
50274 0 : std::cout << "SgDerivedTypeStatement :: " << std::flush;
50275 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
50276 0 : std::cout << " not valid " << std::endl;
50277 : }
50278 : }
50279 :
50280 0 : if ( p_parent != NULL )
50281 : {
50282 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50283 : {
50284 0 : if ( p_parent->isInMemoryPool() == false )
50285 : {
50286 0 : std::cout << "SgDerivedTypeStatement :: ";
50287 0 : std::cout << " p_parent is not in memory pool of ";
50288 0 : std::cout << p_parent->class_name() << std::endl;
50289 : }
50290 : }
50291 : else
50292 : {
50293 0 : std::cout << "SgDerivedTypeStatement :: " << std::flush;
50294 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
50295 0 : std::cout << " not valid " << std::endl;
50296 : }
50297 : }
50298 :
50299 :
50300 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
50301 :
50302 0 : }
50303 :
50304 :
50305 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
50306 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
50307 : bool
50308 0 : SgDerivedTypeStatement::isInMemoryPool ()
50309 : {
50310 0 : typedef unsigned char* TestType;
50311 :
50312 0 : bool found = false;
50313 :
50314 0 : ROSE_ASSERT(this != NULL);
50315 :
50316 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
50317 :
50318 0 : TestType tested = (TestType) ( this ) ;
50319 :
50320 0 : std::vector < unsigned char* > :: const_iterator block = SgDerivedTypeStatement::pools.begin();
50321 :
50322 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
50323 : // while (found == false && block < Memory_Block_List.end())
50324 0 : while ( (found == false) && (block != SgDerivedTypeStatement::pools.end()) )
50325 : {
50326 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDerivedTypeStatement::pool_size * sizeof(SgDerivedTypeStatement) ) ) ;
50327 0 : ++block;
50328 : }
50329 :
50330 : // Special handling for static data
50331 :
50332 :
50333 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
50334 0 : ROSE_ASSERT(found == true);
50335 :
50336 0 : return found;
50337 : }
50338 : /* #line 50339 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
50339 :
50340 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
50341 :
50342 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
50343 :
50344 : /* #line 50345 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
50345 :
50346 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
50347 :
50348 : void
50349 0 : SgModuleStatement::checkDataMemberPointersIfInMemoryPool()
50350 : {
50351 : // ------------ checking pointers of SgModuleStatement -------------------
50352 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
50353 :
50354 0 : if ( p_end_numeric_label != NULL )
50355 : {
50356 0 : if ( p_end_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50357 : {
50358 0 : if ( p_end_numeric_label->isInMemoryPool() == false )
50359 : {
50360 0 : std::cout << "SgModuleStatement :: ";
50361 0 : std::cout << " p_end_numeric_label is not in memory pool of ";
50362 0 : std::cout << p_end_numeric_label->class_name() << std::endl;
50363 : }
50364 : }
50365 : else
50366 : {
50367 0 : std::cout << "SgModuleStatement :: " << std::flush;
50368 0 : std::cout << "SgLabelRefExp* p_end_numeric_label = " << p_end_numeric_label << " --> " << std::flush;
50369 0 : std::cout << " not valid " << std::endl;
50370 : }
50371 : }
50372 :
50373 0 : if ( p_type != NULL )
50374 : {
50375 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50376 : {
50377 0 : if ( p_type->isInMemoryPool() == false )
50378 : {
50379 0 : std::cout << "SgModuleStatement :: ";
50380 0 : std::cout << " p_type is not in memory pool of ";
50381 0 : std::cout << p_type->class_name() << std::endl;
50382 : }
50383 : }
50384 : else
50385 : {
50386 0 : std::cout << "SgModuleStatement :: " << std::flush;
50387 0 : std::cout << "SgClassType* p_type = " << p_type << " --> " << std::flush;
50388 0 : std::cout << " not valid " << std::endl;
50389 : }
50390 : }
50391 :
50392 0 : if ( p_definition != NULL )
50393 : {
50394 0 : if ( p_definition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50395 : {
50396 0 : if ( p_definition->isInMemoryPool() == false )
50397 : {
50398 0 : std::cout << "SgModuleStatement :: ";
50399 0 : std::cout << " p_definition is not in memory pool of ";
50400 0 : std::cout << p_definition->class_name() << std::endl;
50401 : }
50402 : }
50403 : else
50404 : {
50405 0 : std::cout << "SgModuleStatement :: " << std::flush;
50406 0 : std::cout << "SgClassDefinition* p_definition = " << p_definition << " --> " << std::flush;
50407 0 : std::cout << " not valid " << std::endl;
50408 : }
50409 : }
50410 :
50411 0 : if ( p_scope != NULL )
50412 : {
50413 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50414 : {
50415 0 : if ( p_scope->isInMemoryPool() == false )
50416 : {
50417 0 : std::cout << "SgModuleStatement :: ";
50418 0 : std::cout << " p_scope is not in memory pool of ";
50419 0 : std::cout << p_scope->class_name() << std::endl;
50420 : }
50421 : }
50422 : else
50423 : {
50424 0 : std::cout << "SgModuleStatement :: " << std::flush;
50425 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
50426 0 : std::cout << " not valid " << std::endl;
50427 : }
50428 : }
50429 :
50430 0 : if ( p_decoratorList != NULL )
50431 : {
50432 0 : if ( p_decoratorList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50433 : {
50434 0 : if ( p_decoratorList->isInMemoryPool() == false )
50435 : {
50436 0 : std::cout << "SgModuleStatement :: ";
50437 0 : std::cout << " p_decoratorList is not in memory pool of ";
50438 0 : std::cout << p_decoratorList->class_name() << std::endl;
50439 : }
50440 : }
50441 : else
50442 : {
50443 0 : std::cout << "SgModuleStatement :: " << std::flush;
50444 0 : std::cout << "SgExprListExp* p_decoratorList = " << p_decoratorList << " --> " << std::flush;
50445 0 : std::cout << " not valid " << std::endl;
50446 : }
50447 : }
50448 :
50449 0 : if ( p_adaParentType != NULL )
50450 : {
50451 0 : if ( p_adaParentType->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50452 : {
50453 0 : if ( p_adaParentType->isInMemoryPool() == false )
50454 : {
50455 0 : std::cout << "SgModuleStatement :: ";
50456 0 : std::cout << " p_adaParentType is not in memory pool of ";
50457 0 : std::cout << p_adaParentType->class_name() << std::endl;
50458 : }
50459 : }
50460 : else
50461 : {
50462 0 : std::cout << "SgModuleStatement :: " << std::flush;
50463 0 : std::cout << "SgBaseClass* p_adaParentType = " << p_adaParentType << " --> " << std::flush;
50464 0 : std::cout << " not valid " << std::endl;
50465 : }
50466 : }
50467 :
50468 0 : if ( p_definingDeclaration != NULL )
50469 : {
50470 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50471 : {
50472 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
50473 : {
50474 0 : std::cout << "SgModuleStatement :: ";
50475 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
50476 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
50477 : }
50478 : }
50479 : else
50480 : {
50481 0 : std::cout << "SgModuleStatement :: " << std::flush;
50482 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
50483 0 : std::cout << " not valid " << std::endl;
50484 : }
50485 : }
50486 :
50487 0 : if ( p_firstNondefiningDeclaration != NULL )
50488 : {
50489 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50490 : {
50491 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
50492 : {
50493 0 : std::cout << "SgModuleStatement :: ";
50494 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
50495 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
50496 : }
50497 : }
50498 : else
50499 : {
50500 0 : std::cout << "SgModuleStatement :: " << std::flush;
50501 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
50502 0 : std::cout << " not valid " << std::endl;
50503 : }
50504 : }
50505 :
50506 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
50507 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
50508 : {
50509 0 : if ( (*i_qualifiedNameList) != NULL )
50510 : {
50511 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50512 : {
50513 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
50514 : {
50515 0 : std::cout << "SgModuleStatement :: ";
50516 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
50517 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
50518 : }
50519 : }
50520 : else
50521 : {
50522 0 : std::cout << "SgModuleStatement :: " << std::flush;
50523 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
50524 0 : std::cout << " entry not valid " << std::endl;
50525 : }
50526 : }
50527 : else
50528 : {
50529 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
50530 : }
50531 : }
50532 :
50533 0 : if ( p_declarationScope != NULL )
50534 : {
50535 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50536 : {
50537 0 : if ( p_declarationScope->isInMemoryPool() == false )
50538 : {
50539 0 : std::cout << "SgModuleStatement :: ";
50540 0 : std::cout << " p_declarationScope is not in memory pool of ";
50541 0 : std::cout << p_declarationScope->class_name() << std::endl;
50542 : }
50543 : }
50544 : else
50545 : {
50546 0 : std::cout << "SgModuleStatement :: " << std::flush;
50547 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
50548 0 : std::cout << " not valid " << std::endl;
50549 : }
50550 : }
50551 :
50552 0 : if ( p_numeric_label != NULL )
50553 : {
50554 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50555 : {
50556 0 : if ( p_numeric_label->isInMemoryPool() == false )
50557 : {
50558 0 : std::cout << "SgModuleStatement :: ";
50559 0 : std::cout << " p_numeric_label is not in memory pool of ";
50560 0 : std::cout << p_numeric_label->class_name() << std::endl;
50561 : }
50562 : }
50563 : else
50564 : {
50565 0 : std::cout << "SgModuleStatement :: " << std::flush;
50566 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
50567 0 : std::cout << " not valid " << std::endl;
50568 : }
50569 : }
50570 :
50571 0 : if ( p_startOfConstruct != NULL )
50572 : {
50573 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50574 : {
50575 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
50576 : {
50577 0 : std::cout << "SgModuleStatement :: ";
50578 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
50579 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
50580 : }
50581 : }
50582 : else
50583 : {
50584 0 : std::cout << "SgModuleStatement :: " << std::flush;
50585 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
50586 0 : std::cout << " not valid " << std::endl;
50587 : }
50588 : }
50589 :
50590 0 : if ( p_endOfConstruct != NULL )
50591 : {
50592 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50593 : {
50594 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
50595 : {
50596 0 : std::cout << "SgModuleStatement :: ";
50597 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
50598 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
50599 : }
50600 : }
50601 : else
50602 : {
50603 0 : std::cout << "SgModuleStatement :: " << std::flush;
50604 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
50605 0 : std::cout << " not valid " << std::endl;
50606 : }
50607 : }
50608 :
50609 0 : if ( p_parent != NULL )
50610 : {
50611 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50612 : {
50613 0 : if ( p_parent->isInMemoryPool() == false )
50614 : {
50615 0 : std::cout << "SgModuleStatement :: ";
50616 0 : std::cout << " p_parent is not in memory pool of ";
50617 0 : std::cout << p_parent->class_name() << std::endl;
50618 : }
50619 : }
50620 : else
50621 : {
50622 0 : std::cout << "SgModuleStatement :: " << std::flush;
50623 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
50624 0 : std::cout << " not valid " << std::endl;
50625 : }
50626 : }
50627 :
50628 :
50629 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
50630 :
50631 0 : }
50632 :
50633 :
50634 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
50635 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
50636 : bool
50637 0 : SgModuleStatement::isInMemoryPool ()
50638 : {
50639 0 : typedef unsigned char* TestType;
50640 :
50641 0 : bool found = false;
50642 :
50643 0 : ROSE_ASSERT(this != NULL);
50644 :
50645 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
50646 :
50647 0 : TestType tested = (TestType) ( this ) ;
50648 :
50649 0 : std::vector < unsigned char* > :: const_iterator block = SgModuleStatement::pools.begin();
50650 :
50651 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
50652 : // while (found == false && block < Memory_Block_List.end())
50653 0 : while ( (found == false) && (block != SgModuleStatement::pools.end()) )
50654 : {
50655 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgModuleStatement::pool_size * sizeof(SgModuleStatement) ) ) ;
50656 0 : ++block;
50657 : }
50658 :
50659 : // Special handling for static data
50660 :
50661 :
50662 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
50663 0 : ROSE_ASSERT(found == true);
50664 :
50665 0 : return found;
50666 : }
50667 : /* #line 50668 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
50668 :
50669 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
50670 :
50671 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
50672 :
50673 : /* #line 50674 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
50674 :
50675 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
50676 :
50677 : void
50678 0 : SgImplicitStatement::checkDataMemberPointersIfInMemoryPool()
50679 : {
50680 : // ------------ checking pointers of SgImplicitStatement -------------------
50681 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
50682 :
50683 0 : SgInitializedNamePtrList::iterator i_variables = p_variables.begin() ;
50684 0 : for ( ; i_variables != p_variables.end(); ++i_variables )
50685 : {
50686 0 : if ( (*i_variables) != NULL )
50687 : {
50688 0 : if ( (*i_variables)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50689 : {
50690 0 : if ( (*i_variables)->isInMemoryPool() == false )
50691 : {
50692 0 : std::cout << "SgImplicitStatement :: ";
50693 0 : std::cout << " p_variables ( list of poitners to IR nodes ), entry is not in memory pool of ";
50694 0 : std::cout << (*i_variables)->class_name() << std::endl;
50695 : }
50696 : }
50697 : else
50698 : {
50699 0 : std::cout << "SgImplicitStatement :: " << std::flush;
50700 0 : std::cout << "SgInitializedNamePtrList p_variables --> " << std::flush;
50701 0 : std::cout << " entry not valid " << std::endl;
50702 : }
50703 : }
50704 : else
50705 : {
50706 0 : std::cout << "SgInitializedNamePtrList p_variables --> NULL " << std::endl;
50707 : }
50708 : }
50709 :
50710 0 : if ( p_definingDeclaration != NULL )
50711 : {
50712 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50713 : {
50714 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
50715 : {
50716 0 : std::cout << "SgImplicitStatement :: ";
50717 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
50718 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
50719 : }
50720 : }
50721 : else
50722 : {
50723 0 : std::cout << "SgImplicitStatement :: " << std::flush;
50724 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
50725 0 : std::cout << " not valid " << std::endl;
50726 : }
50727 : }
50728 :
50729 0 : if ( p_firstNondefiningDeclaration != NULL )
50730 : {
50731 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50732 : {
50733 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
50734 : {
50735 0 : std::cout << "SgImplicitStatement :: ";
50736 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
50737 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
50738 : }
50739 : }
50740 : else
50741 : {
50742 0 : std::cout << "SgImplicitStatement :: " << std::flush;
50743 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
50744 0 : std::cout << " not valid " << std::endl;
50745 : }
50746 : }
50747 :
50748 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
50749 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
50750 : {
50751 0 : if ( (*i_qualifiedNameList) != NULL )
50752 : {
50753 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50754 : {
50755 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
50756 : {
50757 0 : std::cout << "SgImplicitStatement :: ";
50758 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
50759 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
50760 : }
50761 : }
50762 : else
50763 : {
50764 0 : std::cout << "SgImplicitStatement :: " << std::flush;
50765 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
50766 0 : std::cout << " entry not valid " << std::endl;
50767 : }
50768 : }
50769 : else
50770 : {
50771 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
50772 : }
50773 : }
50774 :
50775 0 : if ( p_declarationScope != NULL )
50776 : {
50777 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50778 : {
50779 0 : if ( p_declarationScope->isInMemoryPool() == false )
50780 : {
50781 0 : std::cout << "SgImplicitStatement :: ";
50782 0 : std::cout << " p_declarationScope is not in memory pool of ";
50783 0 : std::cout << p_declarationScope->class_name() << std::endl;
50784 : }
50785 : }
50786 : else
50787 : {
50788 0 : std::cout << "SgImplicitStatement :: " << std::flush;
50789 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
50790 0 : std::cout << " not valid " << std::endl;
50791 : }
50792 : }
50793 :
50794 0 : if ( p_numeric_label != NULL )
50795 : {
50796 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50797 : {
50798 0 : if ( p_numeric_label->isInMemoryPool() == false )
50799 : {
50800 0 : std::cout << "SgImplicitStatement :: ";
50801 0 : std::cout << " p_numeric_label is not in memory pool of ";
50802 0 : std::cout << p_numeric_label->class_name() << std::endl;
50803 : }
50804 : }
50805 : else
50806 : {
50807 0 : std::cout << "SgImplicitStatement :: " << std::flush;
50808 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
50809 0 : std::cout << " not valid " << std::endl;
50810 : }
50811 : }
50812 :
50813 0 : if ( p_startOfConstruct != NULL )
50814 : {
50815 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50816 : {
50817 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
50818 : {
50819 0 : std::cout << "SgImplicitStatement :: ";
50820 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
50821 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
50822 : }
50823 : }
50824 : else
50825 : {
50826 0 : std::cout << "SgImplicitStatement :: " << std::flush;
50827 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
50828 0 : std::cout << " not valid " << std::endl;
50829 : }
50830 : }
50831 :
50832 0 : if ( p_endOfConstruct != NULL )
50833 : {
50834 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50835 : {
50836 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
50837 : {
50838 0 : std::cout << "SgImplicitStatement :: ";
50839 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
50840 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
50841 : }
50842 : }
50843 : else
50844 : {
50845 0 : std::cout << "SgImplicitStatement :: " << std::flush;
50846 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
50847 0 : std::cout << " not valid " << std::endl;
50848 : }
50849 : }
50850 :
50851 0 : if ( p_parent != NULL )
50852 : {
50853 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50854 : {
50855 0 : if ( p_parent->isInMemoryPool() == false )
50856 : {
50857 0 : std::cout << "SgImplicitStatement :: ";
50858 0 : std::cout << " p_parent is not in memory pool of ";
50859 0 : std::cout << p_parent->class_name() << std::endl;
50860 : }
50861 : }
50862 : else
50863 : {
50864 0 : std::cout << "SgImplicitStatement :: " << std::flush;
50865 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
50866 0 : std::cout << " not valid " << std::endl;
50867 : }
50868 : }
50869 :
50870 :
50871 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
50872 :
50873 0 : }
50874 :
50875 :
50876 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
50877 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
50878 : bool
50879 0 : SgImplicitStatement::isInMemoryPool ()
50880 : {
50881 0 : typedef unsigned char* TestType;
50882 :
50883 0 : bool found = false;
50884 :
50885 0 : ROSE_ASSERT(this != NULL);
50886 :
50887 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
50888 :
50889 0 : TestType tested = (TestType) ( this ) ;
50890 :
50891 0 : std::vector < unsigned char* > :: const_iterator block = SgImplicitStatement::pools.begin();
50892 :
50893 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
50894 : // while (found == false && block < Memory_Block_List.end())
50895 0 : while ( (found == false) && (block != SgImplicitStatement::pools.end()) )
50896 : {
50897 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgImplicitStatement::pool_size * sizeof(SgImplicitStatement) ) ) ;
50898 0 : ++block;
50899 : }
50900 :
50901 : // Special handling for static data
50902 :
50903 :
50904 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
50905 0 : ROSE_ASSERT(found == true);
50906 :
50907 0 : return found;
50908 : }
50909 : /* #line 50910 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
50910 :
50911 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
50912 :
50913 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
50914 :
50915 : /* #line 50916 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
50916 :
50917 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
50918 :
50919 : void
50920 0 : SgUsingDeclarationStatement::checkDataMemberPointersIfInMemoryPool()
50921 : {
50922 : // ------------ checking pointers of SgUsingDeclarationStatement -------------------
50923 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
50924 :
50925 0 : if ( p_declaration != NULL )
50926 : {
50927 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50928 : {
50929 0 : if ( p_declaration->isInMemoryPool() == false )
50930 : {
50931 0 : std::cout << "SgUsingDeclarationStatement :: ";
50932 0 : std::cout << " p_declaration is not in memory pool of ";
50933 0 : std::cout << p_declaration->class_name() << std::endl;
50934 : }
50935 : }
50936 : else
50937 : {
50938 0 : std::cout << "SgUsingDeclarationStatement :: " << std::flush;
50939 0 : std::cout << "SgDeclarationStatement* p_declaration = " << p_declaration << " --> " << std::flush;
50940 0 : std::cout << " not valid " << std::endl;
50941 : }
50942 : }
50943 :
50944 0 : if ( p_initializedName != NULL )
50945 : {
50946 0 : if ( p_initializedName->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50947 : {
50948 0 : if ( p_initializedName->isInMemoryPool() == false )
50949 : {
50950 0 : std::cout << "SgUsingDeclarationStatement :: ";
50951 0 : std::cout << " p_initializedName is not in memory pool of ";
50952 0 : std::cout << p_initializedName->class_name() << std::endl;
50953 : }
50954 : }
50955 : else
50956 : {
50957 0 : std::cout << "SgUsingDeclarationStatement :: " << std::flush;
50958 0 : std::cout << "SgInitializedName* p_initializedName = " << p_initializedName << " --> " << std::flush;
50959 0 : std::cout << " not valid " << std::endl;
50960 : }
50961 : }
50962 :
50963 0 : if ( p_definingDeclaration != NULL )
50964 : {
50965 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50966 : {
50967 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
50968 : {
50969 0 : std::cout << "SgUsingDeclarationStatement :: ";
50970 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
50971 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
50972 : }
50973 : }
50974 : else
50975 : {
50976 0 : std::cout << "SgUsingDeclarationStatement :: " << std::flush;
50977 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
50978 0 : std::cout << " not valid " << std::endl;
50979 : }
50980 : }
50981 :
50982 0 : if ( p_firstNondefiningDeclaration != NULL )
50983 : {
50984 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
50985 : {
50986 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
50987 : {
50988 0 : std::cout << "SgUsingDeclarationStatement :: ";
50989 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
50990 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
50991 : }
50992 : }
50993 : else
50994 : {
50995 0 : std::cout << "SgUsingDeclarationStatement :: " << std::flush;
50996 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
50997 0 : std::cout << " not valid " << std::endl;
50998 : }
50999 : }
51000 :
51001 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
51002 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
51003 : {
51004 0 : if ( (*i_qualifiedNameList) != NULL )
51005 : {
51006 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51007 : {
51008 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
51009 : {
51010 0 : std::cout << "SgUsingDeclarationStatement :: ";
51011 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
51012 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
51013 : }
51014 : }
51015 : else
51016 : {
51017 0 : std::cout << "SgUsingDeclarationStatement :: " << std::flush;
51018 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
51019 0 : std::cout << " entry not valid " << std::endl;
51020 : }
51021 : }
51022 : else
51023 : {
51024 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
51025 : }
51026 : }
51027 :
51028 0 : if ( p_declarationScope != NULL )
51029 : {
51030 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51031 : {
51032 0 : if ( p_declarationScope->isInMemoryPool() == false )
51033 : {
51034 0 : std::cout << "SgUsingDeclarationStatement :: ";
51035 0 : std::cout << " p_declarationScope is not in memory pool of ";
51036 0 : std::cout << p_declarationScope->class_name() << std::endl;
51037 : }
51038 : }
51039 : else
51040 : {
51041 0 : std::cout << "SgUsingDeclarationStatement :: " << std::flush;
51042 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
51043 0 : std::cout << " not valid " << std::endl;
51044 : }
51045 : }
51046 :
51047 0 : if ( p_numeric_label != NULL )
51048 : {
51049 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51050 : {
51051 0 : if ( p_numeric_label->isInMemoryPool() == false )
51052 : {
51053 0 : std::cout << "SgUsingDeclarationStatement :: ";
51054 0 : std::cout << " p_numeric_label is not in memory pool of ";
51055 0 : std::cout << p_numeric_label->class_name() << std::endl;
51056 : }
51057 : }
51058 : else
51059 : {
51060 0 : std::cout << "SgUsingDeclarationStatement :: " << std::flush;
51061 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
51062 0 : std::cout << " not valid " << std::endl;
51063 : }
51064 : }
51065 :
51066 0 : if ( p_startOfConstruct != NULL )
51067 : {
51068 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51069 : {
51070 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
51071 : {
51072 0 : std::cout << "SgUsingDeclarationStatement :: ";
51073 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
51074 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
51075 : }
51076 : }
51077 : else
51078 : {
51079 0 : std::cout << "SgUsingDeclarationStatement :: " << std::flush;
51080 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
51081 0 : std::cout << " not valid " << std::endl;
51082 : }
51083 : }
51084 :
51085 0 : if ( p_endOfConstruct != NULL )
51086 : {
51087 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51088 : {
51089 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
51090 : {
51091 0 : std::cout << "SgUsingDeclarationStatement :: ";
51092 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
51093 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
51094 : }
51095 : }
51096 : else
51097 : {
51098 0 : std::cout << "SgUsingDeclarationStatement :: " << std::flush;
51099 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
51100 0 : std::cout << " not valid " << std::endl;
51101 : }
51102 : }
51103 :
51104 0 : if ( p_parent != NULL )
51105 : {
51106 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51107 : {
51108 0 : if ( p_parent->isInMemoryPool() == false )
51109 : {
51110 0 : std::cout << "SgUsingDeclarationStatement :: ";
51111 0 : std::cout << " p_parent is not in memory pool of ";
51112 0 : std::cout << p_parent->class_name() << std::endl;
51113 : }
51114 : }
51115 : else
51116 : {
51117 0 : std::cout << "SgUsingDeclarationStatement :: " << std::flush;
51118 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
51119 0 : std::cout << " not valid " << std::endl;
51120 : }
51121 : }
51122 :
51123 :
51124 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
51125 :
51126 0 : }
51127 :
51128 :
51129 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
51130 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
51131 : bool
51132 0 : SgUsingDeclarationStatement::isInMemoryPool ()
51133 : {
51134 0 : typedef unsigned char* TestType;
51135 :
51136 0 : bool found = false;
51137 :
51138 0 : ROSE_ASSERT(this != NULL);
51139 :
51140 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
51141 :
51142 0 : TestType tested = (TestType) ( this ) ;
51143 :
51144 0 : std::vector < unsigned char* > :: const_iterator block = SgUsingDeclarationStatement::pools.begin();
51145 :
51146 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
51147 : // while (found == false && block < Memory_Block_List.end())
51148 0 : while ( (found == false) && (block != SgUsingDeclarationStatement::pools.end()) )
51149 : {
51150 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUsingDeclarationStatement::pool_size * sizeof(SgUsingDeclarationStatement) ) ) ;
51151 0 : ++block;
51152 : }
51153 :
51154 : // Special handling for static data
51155 :
51156 :
51157 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
51158 0 : ROSE_ASSERT(found == true);
51159 :
51160 0 : return found;
51161 : }
51162 : /* #line 51163 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
51163 :
51164 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
51165 :
51166 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
51167 :
51168 : /* #line 51169 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
51169 :
51170 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
51171 :
51172 : void
51173 0 : SgNamelistStatement::checkDataMemberPointersIfInMemoryPool()
51174 : {
51175 : // ------------ checking pointers of SgNamelistStatement -------------------
51176 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
51177 :
51178 0 : SgNameGroupPtrList::iterator i_group_list = p_group_list.begin() ;
51179 0 : for ( ; i_group_list != p_group_list.end(); ++i_group_list )
51180 : {
51181 0 : if ( (*i_group_list) != NULL )
51182 : {
51183 0 : if ( (*i_group_list)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51184 : {
51185 0 : if ( (*i_group_list)->isInMemoryPool() == false )
51186 : {
51187 0 : std::cout << "SgNamelistStatement :: ";
51188 0 : std::cout << " p_group_list ( list of poitners to IR nodes ), entry is not in memory pool of ";
51189 0 : std::cout << (*i_group_list)->class_name() << std::endl;
51190 : }
51191 : }
51192 : else
51193 : {
51194 0 : std::cout << "SgNamelistStatement :: " << std::flush;
51195 0 : std::cout << "SgNameGroupPtrList p_group_list --> " << std::flush;
51196 0 : std::cout << " entry not valid " << std::endl;
51197 : }
51198 : }
51199 : else
51200 : {
51201 0 : std::cout << "SgNameGroupPtrList p_group_list --> NULL " << std::endl;
51202 : }
51203 : }
51204 :
51205 0 : if ( p_definingDeclaration != NULL )
51206 : {
51207 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51208 : {
51209 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
51210 : {
51211 0 : std::cout << "SgNamelistStatement :: ";
51212 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
51213 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
51214 : }
51215 : }
51216 : else
51217 : {
51218 0 : std::cout << "SgNamelistStatement :: " << std::flush;
51219 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
51220 0 : std::cout << " not valid " << std::endl;
51221 : }
51222 : }
51223 :
51224 0 : if ( p_firstNondefiningDeclaration != NULL )
51225 : {
51226 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51227 : {
51228 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
51229 : {
51230 0 : std::cout << "SgNamelistStatement :: ";
51231 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
51232 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
51233 : }
51234 : }
51235 : else
51236 : {
51237 0 : std::cout << "SgNamelistStatement :: " << std::flush;
51238 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
51239 0 : std::cout << " not valid " << std::endl;
51240 : }
51241 : }
51242 :
51243 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
51244 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
51245 : {
51246 0 : if ( (*i_qualifiedNameList) != NULL )
51247 : {
51248 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51249 : {
51250 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
51251 : {
51252 0 : std::cout << "SgNamelistStatement :: ";
51253 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
51254 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
51255 : }
51256 : }
51257 : else
51258 : {
51259 0 : std::cout << "SgNamelistStatement :: " << std::flush;
51260 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
51261 0 : std::cout << " entry not valid " << std::endl;
51262 : }
51263 : }
51264 : else
51265 : {
51266 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
51267 : }
51268 : }
51269 :
51270 0 : if ( p_declarationScope != NULL )
51271 : {
51272 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51273 : {
51274 0 : if ( p_declarationScope->isInMemoryPool() == false )
51275 : {
51276 0 : std::cout << "SgNamelistStatement :: ";
51277 0 : std::cout << " p_declarationScope is not in memory pool of ";
51278 0 : std::cout << p_declarationScope->class_name() << std::endl;
51279 : }
51280 : }
51281 : else
51282 : {
51283 0 : std::cout << "SgNamelistStatement :: " << std::flush;
51284 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
51285 0 : std::cout << " not valid " << std::endl;
51286 : }
51287 : }
51288 :
51289 0 : if ( p_numeric_label != NULL )
51290 : {
51291 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51292 : {
51293 0 : if ( p_numeric_label->isInMemoryPool() == false )
51294 : {
51295 0 : std::cout << "SgNamelistStatement :: ";
51296 0 : std::cout << " p_numeric_label is not in memory pool of ";
51297 0 : std::cout << p_numeric_label->class_name() << std::endl;
51298 : }
51299 : }
51300 : else
51301 : {
51302 0 : std::cout << "SgNamelistStatement :: " << std::flush;
51303 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
51304 0 : std::cout << " not valid " << std::endl;
51305 : }
51306 : }
51307 :
51308 0 : if ( p_startOfConstruct != NULL )
51309 : {
51310 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51311 : {
51312 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
51313 : {
51314 0 : std::cout << "SgNamelistStatement :: ";
51315 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
51316 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
51317 : }
51318 : }
51319 : else
51320 : {
51321 0 : std::cout << "SgNamelistStatement :: " << std::flush;
51322 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
51323 0 : std::cout << " not valid " << std::endl;
51324 : }
51325 : }
51326 :
51327 0 : if ( p_endOfConstruct != NULL )
51328 : {
51329 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51330 : {
51331 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
51332 : {
51333 0 : std::cout << "SgNamelistStatement :: ";
51334 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
51335 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
51336 : }
51337 : }
51338 : else
51339 : {
51340 0 : std::cout << "SgNamelistStatement :: " << std::flush;
51341 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
51342 0 : std::cout << " not valid " << std::endl;
51343 : }
51344 : }
51345 :
51346 0 : if ( p_parent != NULL )
51347 : {
51348 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51349 : {
51350 0 : if ( p_parent->isInMemoryPool() == false )
51351 : {
51352 0 : std::cout << "SgNamelistStatement :: ";
51353 0 : std::cout << " p_parent is not in memory pool of ";
51354 0 : std::cout << p_parent->class_name() << std::endl;
51355 : }
51356 : }
51357 : else
51358 : {
51359 0 : std::cout << "SgNamelistStatement :: " << std::flush;
51360 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
51361 0 : std::cout << " not valid " << std::endl;
51362 : }
51363 : }
51364 :
51365 :
51366 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
51367 :
51368 0 : }
51369 :
51370 :
51371 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
51372 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
51373 : bool
51374 0 : SgNamelistStatement::isInMemoryPool ()
51375 : {
51376 0 : typedef unsigned char* TestType;
51377 :
51378 0 : bool found = false;
51379 :
51380 0 : ROSE_ASSERT(this != NULL);
51381 :
51382 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
51383 :
51384 0 : TestType tested = (TestType) ( this ) ;
51385 :
51386 0 : std::vector < unsigned char* > :: const_iterator block = SgNamelistStatement::pools.begin();
51387 :
51388 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
51389 : // while (found == false && block < Memory_Block_List.end())
51390 0 : while ( (found == false) && (block != SgNamelistStatement::pools.end()) )
51391 : {
51392 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNamelistStatement::pool_size * sizeof(SgNamelistStatement) ) ) ;
51393 0 : ++block;
51394 : }
51395 :
51396 : // Special handling for static data
51397 :
51398 :
51399 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
51400 0 : ROSE_ASSERT(found == true);
51401 :
51402 0 : return found;
51403 : }
51404 : /* #line 51405 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
51405 :
51406 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
51407 :
51408 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
51409 :
51410 : /* #line 51411 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
51411 :
51412 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
51413 :
51414 : void
51415 0 : SgImportStatement::checkDataMemberPointersIfInMemoryPool()
51416 : {
51417 : // ------------ checking pointers of SgImportStatement -------------------
51418 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
51419 :
51420 0 : SgExpressionPtrList::iterator i_import_list = p_import_list.begin() ;
51421 0 : for ( ; i_import_list != p_import_list.end(); ++i_import_list )
51422 : {
51423 0 : if ( (*i_import_list) != NULL )
51424 : {
51425 0 : if ( (*i_import_list)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51426 : {
51427 0 : if ( (*i_import_list)->isInMemoryPool() == false )
51428 : {
51429 0 : std::cout << "SgImportStatement :: ";
51430 0 : std::cout << " p_import_list ( list of poitners to IR nodes ), entry is not in memory pool of ";
51431 0 : std::cout << (*i_import_list)->class_name() << std::endl;
51432 : }
51433 : }
51434 : else
51435 : {
51436 0 : std::cout << "SgImportStatement :: " << std::flush;
51437 0 : std::cout << "SgExpressionPtrList p_import_list --> " << std::flush;
51438 0 : std::cout << " entry not valid " << std::endl;
51439 : }
51440 : }
51441 : else
51442 : {
51443 0 : std::cout << "SgExpressionPtrList p_import_list --> NULL " << std::endl;
51444 : }
51445 : }
51446 :
51447 0 : if ( p_definingDeclaration != NULL )
51448 : {
51449 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51450 : {
51451 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
51452 : {
51453 0 : std::cout << "SgImportStatement :: ";
51454 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
51455 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
51456 : }
51457 : }
51458 : else
51459 : {
51460 0 : std::cout << "SgImportStatement :: " << std::flush;
51461 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
51462 0 : std::cout << " not valid " << std::endl;
51463 : }
51464 : }
51465 :
51466 0 : if ( p_firstNondefiningDeclaration != NULL )
51467 : {
51468 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51469 : {
51470 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
51471 : {
51472 0 : std::cout << "SgImportStatement :: ";
51473 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
51474 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
51475 : }
51476 : }
51477 : else
51478 : {
51479 0 : std::cout << "SgImportStatement :: " << std::flush;
51480 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
51481 0 : std::cout << " not valid " << std::endl;
51482 : }
51483 : }
51484 :
51485 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
51486 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
51487 : {
51488 0 : if ( (*i_qualifiedNameList) != NULL )
51489 : {
51490 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51491 : {
51492 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
51493 : {
51494 0 : std::cout << "SgImportStatement :: ";
51495 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
51496 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
51497 : }
51498 : }
51499 : else
51500 : {
51501 0 : std::cout << "SgImportStatement :: " << std::flush;
51502 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
51503 0 : std::cout << " entry not valid " << std::endl;
51504 : }
51505 : }
51506 : else
51507 : {
51508 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
51509 : }
51510 : }
51511 :
51512 0 : if ( p_declarationScope != NULL )
51513 : {
51514 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51515 : {
51516 0 : if ( p_declarationScope->isInMemoryPool() == false )
51517 : {
51518 0 : std::cout << "SgImportStatement :: ";
51519 0 : std::cout << " p_declarationScope is not in memory pool of ";
51520 0 : std::cout << p_declarationScope->class_name() << std::endl;
51521 : }
51522 : }
51523 : else
51524 : {
51525 0 : std::cout << "SgImportStatement :: " << std::flush;
51526 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
51527 0 : std::cout << " not valid " << std::endl;
51528 : }
51529 : }
51530 :
51531 0 : if ( p_numeric_label != NULL )
51532 : {
51533 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51534 : {
51535 0 : if ( p_numeric_label->isInMemoryPool() == false )
51536 : {
51537 0 : std::cout << "SgImportStatement :: ";
51538 0 : std::cout << " p_numeric_label is not in memory pool of ";
51539 0 : std::cout << p_numeric_label->class_name() << std::endl;
51540 : }
51541 : }
51542 : else
51543 : {
51544 0 : std::cout << "SgImportStatement :: " << std::flush;
51545 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
51546 0 : std::cout << " not valid " << std::endl;
51547 : }
51548 : }
51549 :
51550 0 : if ( p_startOfConstruct != NULL )
51551 : {
51552 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51553 : {
51554 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
51555 : {
51556 0 : std::cout << "SgImportStatement :: ";
51557 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
51558 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
51559 : }
51560 : }
51561 : else
51562 : {
51563 0 : std::cout << "SgImportStatement :: " << std::flush;
51564 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
51565 0 : std::cout << " not valid " << std::endl;
51566 : }
51567 : }
51568 :
51569 0 : if ( p_endOfConstruct != NULL )
51570 : {
51571 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51572 : {
51573 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
51574 : {
51575 0 : std::cout << "SgImportStatement :: ";
51576 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
51577 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
51578 : }
51579 : }
51580 : else
51581 : {
51582 0 : std::cout << "SgImportStatement :: " << std::flush;
51583 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
51584 0 : std::cout << " not valid " << std::endl;
51585 : }
51586 : }
51587 :
51588 0 : if ( p_parent != NULL )
51589 : {
51590 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51591 : {
51592 0 : if ( p_parent->isInMemoryPool() == false )
51593 : {
51594 0 : std::cout << "SgImportStatement :: ";
51595 0 : std::cout << " p_parent is not in memory pool of ";
51596 0 : std::cout << p_parent->class_name() << std::endl;
51597 : }
51598 : }
51599 : else
51600 : {
51601 0 : std::cout << "SgImportStatement :: " << std::flush;
51602 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
51603 0 : std::cout << " not valid " << std::endl;
51604 : }
51605 : }
51606 :
51607 :
51608 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
51609 :
51610 0 : }
51611 :
51612 :
51613 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
51614 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
51615 : bool
51616 0 : SgImportStatement::isInMemoryPool ()
51617 : {
51618 0 : typedef unsigned char* TestType;
51619 :
51620 0 : bool found = false;
51621 :
51622 0 : ROSE_ASSERT(this != NULL);
51623 :
51624 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
51625 :
51626 0 : TestType tested = (TestType) ( this ) ;
51627 :
51628 0 : std::vector < unsigned char* > :: const_iterator block = SgImportStatement::pools.begin();
51629 :
51630 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
51631 : // while (found == false && block < Memory_Block_List.end())
51632 0 : while ( (found == false) && (block != SgImportStatement::pools.end()) )
51633 : {
51634 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgImportStatement::pool_size * sizeof(SgImportStatement) ) ) ;
51635 0 : ++block;
51636 : }
51637 :
51638 : // Special handling for static data
51639 :
51640 :
51641 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
51642 0 : ROSE_ASSERT(found == true);
51643 :
51644 0 : return found;
51645 : }
51646 : /* #line 51647 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
51647 :
51648 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
51649 :
51650 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
51651 :
51652 : /* #line 51653 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
51653 :
51654 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
51655 :
51656 : void
51657 0 : SgFunctionDeclaration::checkDataMemberPointersIfInMemoryPool()
51658 : {
51659 : // ------------ checking pointers of SgFunctionDeclaration -------------------
51660 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
51661 :
51662 0 : if ( p_parameterList != NULL )
51663 : {
51664 0 : if ( p_parameterList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51665 : {
51666 0 : if ( p_parameterList->isInMemoryPool() == false )
51667 : {
51668 0 : std::cout << "SgFunctionDeclaration :: ";
51669 0 : std::cout << " p_parameterList is not in memory pool of ";
51670 0 : std::cout << p_parameterList->class_name() << std::endl;
51671 : }
51672 : }
51673 : else
51674 : {
51675 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51676 0 : std::cout << "SgFunctionParameterList* p_parameterList = " << p_parameterList << " --> " << std::flush;
51677 0 : std::cout << " not valid " << std::endl;
51678 : }
51679 : }
51680 :
51681 0 : SgTypePtrList::iterator i_exceptionSpecification = p_exceptionSpecification.begin() ;
51682 0 : for ( ; i_exceptionSpecification != p_exceptionSpecification.end(); ++i_exceptionSpecification )
51683 : {
51684 0 : if ( (*i_exceptionSpecification) != NULL )
51685 : {
51686 0 : if ( (*i_exceptionSpecification)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51687 : {
51688 0 : if ( (*i_exceptionSpecification)->isInMemoryPool() == false )
51689 : {
51690 0 : std::cout << "SgFunctionDeclaration :: ";
51691 0 : std::cout << " p_exceptionSpecification ( list of poitners to IR nodes ), entry is not in memory pool of ";
51692 0 : std::cout << (*i_exceptionSpecification)->class_name() << std::endl;
51693 : }
51694 : }
51695 : else
51696 : {
51697 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51698 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> " << std::flush;
51699 0 : std::cout << " entry not valid " << std::endl;
51700 : }
51701 : }
51702 : else
51703 : {
51704 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> NULL " << std::endl;
51705 : }
51706 : }
51707 :
51708 0 : if ( p_decoratorList != NULL )
51709 : {
51710 0 : if ( p_decoratorList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51711 : {
51712 0 : if ( p_decoratorList->isInMemoryPool() == false )
51713 : {
51714 0 : std::cout << "SgFunctionDeclaration :: ";
51715 0 : std::cout << " p_decoratorList is not in memory pool of ";
51716 0 : std::cout << p_decoratorList->class_name() << std::endl;
51717 : }
51718 : }
51719 : else
51720 : {
51721 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51722 0 : std::cout << "SgExprListExp* p_decoratorList = " << p_decoratorList << " --> " << std::flush;
51723 0 : std::cout << " not valid " << std::endl;
51724 : }
51725 : }
51726 :
51727 0 : if ( p_type != NULL )
51728 : {
51729 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51730 : {
51731 0 : if ( p_type->isInMemoryPool() == false )
51732 : {
51733 0 : std::cout << "SgFunctionDeclaration :: ";
51734 0 : std::cout << " p_type is not in memory pool of ";
51735 0 : std::cout << p_type->class_name() << std::endl;
51736 : }
51737 : }
51738 : else
51739 : {
51740 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51741 0 : std::cout << "SgFunctionType* p_type = " << p_type << " --> " << std::flush;
51742 0 : std::cout << " not valid " << std::endl;
51743 : }
51744 : }
51745 :
51746 0 : if ( p_definition != NULL )
51747 : {
51748 0 : if ( p_definition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51749 : {
51750 0 : if ( p_definition->isInMemoryPool() == false )
51751 : {
51752 0 : std::cout << "SgFunctionDeclaration :: ";
51753 0 : std::cout << " p_definition is not in memory pool of ";
51754 0 : std::cout << p_definition->class_name() << std::endl;
51755 : }
51756 : }
51757 : else
51758 : {
51759 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51760 0 : std::cout << "SgFunctionDefinition* p_definition = " << p_definition << " --> " << std::flush;
51761 0 : std::cout << " not valid " << std::endl;
51762 : }
51763 : }
51764 :
51765 0 : if ( p_scope != NULL )
51766 : {
51767 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51768 : {
51769 0 : if ( p_scope->isInMemoryPool() == false )
51770 : {
51771 0 : std::cout << "SgFunctionDeclaration :: ";
51772 0 : std::cout << " p_scope is not in memory pool of ";
51773 0 : std::cout << p_scope->class_name() << std::endl;
51774 : }
51775 : }
51776 : else
51777 : {
51778 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51779 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
51780 0 : std::cout << " not valid " << std::endl;
51781 : }
51782 : }
51783 :
51784 0 : if ( p_type_syntax != NULL )
51785 : {
51786 0 : if ( p_type_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51787 : {
51788 0 : if ( p_type_syntax->isInMemoryPool() == false )
51789 : {
51790 0 : std::cout << "SgFunctionDeclaration :: ";
51791 0 : std::cout << " p_type_syntax is not in memory pool of ";
51792 0 : std::cout << p_type_syntax->class_name() << std::endl;
51793 : }
51794 : }
51795 : else
51796 : {
51797 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51798 0 : std::cout << "SgFunctionType* p_type_syntax = " << p_type_syntax << " --> " << std::flush;
51799 0 : std::cout << " not valid " << std::endl;
51800 : }
51801 : }
51802 :
51803 0 : if ( p_parameterList_syntax != NULL )
51804 : {
51805 0 : if ( p_parameterList_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51806 : {
51807 0 : if ( p_parameterList_syntax->isInMemoryPool() == false )
51808 : {
51809 0 : std::cout << "SgFunctionDeclaration :: ";
51810 0 : std::cout << " p_parameterList_syntax is not in memory pool of ";
51811 0 : std::cout << p_parameterList_syntax->class_name() << std::endl;
51812 : }
51813 : }
51814 : else
51815 : {
51816 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51817 0 : std::cout << "SgFunctionParameterList* p_parameterList_syntax = " << p_parameterList_syntax << " --> " << std::flush;
51818 0 : std::cout << " not valid " << std::endl;
51819 : }
51820 : }
51821 :
51822 0 : if ( p_functionParameterScope != NULL )
51823 : {
51824 0 : if ( p_functionParameterScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51825 : {
51826 0 : if ( p_functionParameterScope->isInMemoryPool() == false )
51827 : {
51828 0 : std::cout << "SgFunctionDeclaration :: ";
51829 0 : std::cout << " p_functionParameterScope is not in memory pool of ";
51830 0 : std::cout << p_functionParameterScope->class_name() << std::endl;
51831 : }
51832 : }
51833 : else
51834 : {
51835 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51836 0 : std::cout << "SgFunctionParameterScope* p_functionParameterScope = " << p_functionParameterScope << " --> " << std::flush;
51837 0 : std::cout << " not valid " << std::endl;
51838 : }
51839 : }
51840 :
51841 0 : if ( p_definingDeclaration != NULL )
51842 : {
51843 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51844 : {
51845 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
51846 : {
51847 0 : std::cout << "SgFunctionDeclaration :: ";
51848 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
51849 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
51850 : }
51851 : }
51852 : else
51853 : {
51854 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51855 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
51856 0 : std::cout << " not valid " << std::endl;
51857 : }
51858 : }
51859 :
51860 0 : if ( p_firstNondefiningDeclaration != NULL )
51861 : {
51862 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51863 : {
51864 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
51865 : {
51866 0 : std::cout << "SgFunctionDeclaration :: ";
51867 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
51868 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
51869 : }
51870 : }
51871 : else
51872 : {
51873 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51874 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
51875 0 : std::cout << " not valid " << std::endl;
51876 : }
51877 : }
51878 :
51879 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
51880 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
51881 : {
51882 0 : if ( (*i_qualifiedNameList) != NULL )
51883 : {
51884 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51885 : {
51886 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
51887 : {
51888 0 : std::cout << "SgFunctionDeclaration :: ";
51889 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
51890 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
51891 : }
51892 : }
51893 : else
51894 : {
51895 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51896 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
51897 0 : std::cout << " entry not valid " << std::endl;
51898 : }
51899 : }
51900 : else
51901 : {
51902 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
51903 : }
51904 : }
51905 :
51906 0 : if ( p_declarationScope != NULL )
51907 : {
51908 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51909 : {
51910 0 : if ( p_declarationScope->isInMemoryPool() == false )
51911 : {
51912 0 : std::cout << "SgFunctionDeclaration :: ";
51913 0 : std::cout << " p_declarationScope is not in memory pool of ";
51914 0 : std::cout << p_declarationScope->class_name() << std::endl;
51915 : }
51916 : }
51917 : else
51918 : {
51919 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51920 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
51921 0 : std::cout << " not valid " << std::endl;
51922 : }
51923 : }
51924 :
51925 0 : if ( p_numeric_label != NULL )
51926 : {
51927 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51928 : {
51929 0 : if ( p_numeric_label->isInMemoryPool() == false )
51930 : {
51931 0 : std::cout << "SgFunctionDeclaration :: ";
51932 0 : std::cout << " p_numeric_label is not in memory pool of ";
51933 0 : std::cout << p_numeric_label->class_name() << std::endl;
51934 : }
51935 : }
51936 : else
51937 : {
51938 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51939 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
51940 0 : std::cout << " not valid " << std::endl;
51941 : }
51942 : }
51943 :
51944 0 : if ( p_startOfConstruct != NULL )
51945 : {
51946 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51947 : {
51948 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
51949 : {
51950 0 : std::cout << "SgFunctionDeclaration :: ";
51951 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
51952 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
51953 : }
51954 : }
51955 : else
51956 : {
51957 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51958 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
51959 0 : std::cout << " not valid " << std::endl;
51960 : }
51961 : }
51962 :
51963 0 : if ( p_endOfConstruct != NULL )
51964 : {
51965 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51966 : {
51967 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
51968 : {
51969 0 : std::cout << "SgFunctionDeclaration :: ";
51970 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
51971 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
51972 : }
51973 : }
51974 : else
51975 : {
51976 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51977 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
51978 0 : std::cout << " not valid " << std::endl;
51979 : }
51980 : }
51981 :
51982 0 : if ( p_parent != NULL )
51983 : {
51984 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
51985 : {
51986 0 : if ( p_parent->isInMemoryPool() == false )
51987 : {
51988 0 : std::cout << "SgFunctionDeclaration :: ";
51989 0 : std::cout << " p_parent is not in memory pool of ";
51990 0 : std::cout << p_parent->class_name() << std::endl;
51991 : }
51992 : }
51993 : else
51994 : {
51995 0 : std::cout << "SgFunctionDeclaration :: " << std::flush;
51996 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
51997 0 : std::cout << " not valid " << std::endl;
51998 : }
51999 : }
52000 :
52001 :
52002 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
52003 :
52004 0 : }
52005 :
52006 :
52007 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
52008 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
52009 : bool
52010 0 : SgFunctionDeclaration::isInMemoryPool ()
52011 : {
52012 0 : typedef unsigned char* TestType;
52013 :
52014 0 : bool found = false;
52015 :
52016 0 : ROSE_ASSERT(this != NULL);
52017 :
52018 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
52019 :
52020 0 : TestType tested = (TestType) ( this ) ;
52021 :
52022 0 : std::vector < unsigned char* > :: const_iterator block = SgFunctionDeclaration::pools.begin();
52023 :
52024 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
52025 : // while (found == false && block < Memory_Block_List.end())
52026 0 : while ( (found == false) && (block != SgFunctionDeclaration::pools.end()) )
52027 : {
52028 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFunctionDeclaration::pool_size * sizeof(SgFunctionDeclaration) ) ) ;
52029 0 : ++block;
52030 : }
52031 :
52032 : // Special handling for static data
52033 :
52034 :
52035 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
52036 0 : ROSE_ASSERT(found == true);
52037 :
52038 0 : return found;
52039 : }
52040 : /* #line 52041 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
52041 :
52042 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
52043 :
52044 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
52045 :
52046 : /* #line 52047 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
52047 :
52048 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
52049 :
52050 : void
52051 0 : SgTemplateFunctionDeclaration::checkDataMemberPointersIfInMemoryPool()
52052 : {
52053 : // ------------ checking pointers of SgTemplateFunctionDeclaration -------------------
52054 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
52055 :
52056 0 : SgTemplateParameterPtrList::iterator i_templateParameters = p_templateParameters.begin() ;
52057 0 : for ( ; i_templateParameters != p_templateParameters.end(); ++i_templateParameters )
52058 : {
52059 0 : if ( (*i_templateParameters) != NULL )
52060 : {
52061 0 : if ( (*i_templateParameters)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52062 : {
52063 0 : if ( (*i_templateParameters)->isInMemoryPool() == false )
52064 : {
52065 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52066 0 : std::cout << " p_templateParameters ( list of poitners to IR nodes ), entry is not in memory pool of ";
52067 0 : std::cout << (*i_templateParameters)->class_name() << std::endl;
52068 : }
52069 : }
52070 : else
52071 : {
52072 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52073 0 : std::cout << "SgTemplateParameterPtrList p_templateParameters --> " << std::flush;
52074 0 : std::cout << " entry not valid " << std::endl;
52075 : }
52076 : }
52077 : else
52078 : {
52079 0 : std::cout << "SgTemplateParameterPtrList p_templateParameters --> NULL " << std::endl;
52080 : }
52081 : }
52082 :
52083 0 : SgTemplateArgumentPtrList::iterator i_templateSpecializationArguments = p_templateSpecializationArguments.begin() ;
52084 0 : for ( ; i_templateSpecializationArguments != p_templateSpecializationArguments.end(); ++i_templateSpecializationArguments )
52085 : {
52086 0 : if ( (*i_templateSpecializationArguments) != NULL )
52087 : {
52088 0 : if ( (*i_templateSpecializationArguments)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52089 : {
52090 0 : if ( (*i_templateSpecializationArguments)->isInMemoryPool() == false )
52091 : {
52092 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52093 0 : std::cout << " p_templateSpecializationArguments ( list of poitners to IR nodes ), entry is not in memory pool of ";
52094 0 : std::cout << (*i_templateSpecializationArguments)->class_name() << std::endl;
52095 : }
52096 : }
52097 : else
52098 : {
52099 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52100 0 : std::cout << "SgTemplateArgumentPtrList p_templateSpecializationArguments --> " << std::flush;
52101 0 : std::cout << " entry not valid " << std::endl;
52102 : }
52103 : }
52104 : else
52105 : {
52106 0 : std::cout << "SgTemplateArgumentPtrList p_templateSpecializationArguments --> NULL " << std::endl;
52107 : }
52108 : }
52109 :
52110 0 : if ( p_nonreal_decl_scope != NULL )
52111 : {
52112 0 : if ( p_nonreal_decl_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52113 : {
52114 0 : if ( p_nonreal_decl_scope->isInMemoryPool() == false )
52115 : {
52116 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52117 0 : std::cout << " p_nonreal_decl_scope is not in memory pool of ";
52118 0 : std::cout << p_nonreal_decl_scope->class_name() << std::endl;
52119 : }
52120 : }
52121 : else
52122 : {
52123 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52124 0 : std::cout << "SgDeclarationScope* p_nonreal_decl_scope = " << p_nonreal_decl_scope << " --> " << std::flush;
52125 0 : std::cout << " not valid " << std::endl;
52126 : }
52127 : }
52128 :
52129 0 : if ( p_parameterList != NULL )
52130 : {
52131 0 : if ( p_parameterList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52132 : {
52133 0 : if ( p_parameterList->isInMemoryPool() == false )
52134 : {
52135 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52136 0 : std::cout << " p_parameterList is not in memory pool of ";
52137 0 : std::cout << p_parameterList->class_name() << std::endl;
52138 : }
52139 : }
52140 : else
52141 : {
52142 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52143 0 : std::cout << "SgFunctionParameterList* p_parameterList = " << p_parameterList << " --> " << std::flush;
52144 0 : std::cout << " not valid " << std::endl;
52145 : }
52146 : }
52147 :
52148 0 : SgTypePtrList::iterator i_exceptionSpecification = p_exceptionSpecification.begin() ;
52149 0 : for ( ; i_exceptionSpecification != p_exceptionSpecification.end(); ++i_exceptionSpecification )
52150 : {
52151 0 : if ( (*i_exceptionSpecification) != NULL )
52152 : {
52153 0 : if ( (*i_exceptionSpecification)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52154 : {
52155 0 : if ( (*i_exceptionSpecification)->isInMemoryPool() == false )
52156 : {
52157 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52158 0 : std::cout << " p_exceptionSpecification ( list of poitners to IR nodes ), entry is not in memory pool of ";
52159 0 : std::cout << (*i_exceptionSpecification)->class_name() << std::endl;
52160 : }
52161 : }
52162 : else
52163 : {
52164 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52165 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> " << std::flush;
52166 0 : std::cout << " entry not valid " << std::endl;
52167 : }
52168 : }
52169 : else
52170 : {
52171 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> NULL " << std::endl;
52172 : }
52173 : }
52174 :
52175 0 : if ( p_decoratorList != NULL )
52176 : {
52177 0 : if ( p_decoratorList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52178 : {
52179 0 : if ( p_decoratorList->isInMemoryPool() == false )
52180 : {
52181 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52182 0 : std::cout << " p_decoratorList is not in memory pool of ";
52183 0 : std::cout << p_decoratorList->class_name() << std::endl;
52184 : }
52185 : }
52186 : else
52187 : {
52188 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52189 0 : std::cout << "SgExprListExp* p_decoratorList = " << p_decoratorList << " --> " << std::flush;
52190 0 : std::cout << " not valid " << std::endl;
52191 : }
52192 : }
52193 :
52194 0 : if ( p_type != NULL )
52195 : {
52196 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52197 : {
52198 0 : if ( p_type->isInMemoryPool() == false )
52199 : {
52200 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52201 0 : std::cout << " p_type is not in memory pool of ";
52202 0 : std::cout << p_type->class_name() << std::endl;
52203 : }
52204 : }
52205 : else
52206 : {
52207 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52208 0 : std::cout << "SgFunctionType* p_type = " << p_type << " --> " << std::flush;
52209 0 : std::cout << " not valid " << std::endl;
52210 : }
52211 : }
52212 :
52213 0 : if ( p_definition != NULL )
52214 : {
52215 0 : if ( p_definition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52216 : {
52217 0 : if ( p_definition->isInMemoryPool() == false )
52218 : {
52219 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52220 0 : std::cout << " p_definition is not in memory pool of ";
52221 0 : std::cout << p_definition->class_name() << std::endl;
52222 : }
52223 : }
52224 : else
52225 : {
52226 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52227 0 : std::cout << "SgFunctionDefinition* p_definition = " << p_definition << " --> " << std::flush;
52228 0 : std::cout << " not valid " << std::endl;
52229 : }
52230 : }
52231 :
52232 0 : if ( p_scope != NULL )
52233 : {
52234 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52235 : {
52236 0 : if ( p_scope->isInMemoryPool() == false )
52237 : {
52238 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52239 0 : std::cout << " p_scope is not in memory pool of ";
52240 0 : std::cout << p_scope->class_name() << std::endl;
52241 : }
52242 : }
52243 : else
52244 : {
52245 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52246 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
52247 0 : std::cout << " not valid " << std::endl;
52248 : }
52249 : }
52250 :
52251 0 : if ( p_type_syntax != NULL )
52252 : {
52253 0 : if ( p_type_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52254 : {
52255 0 : if ( p_type_syntax->isInMemoryPool() == false )
52256 : {
52257 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52258 0 : std::cout << " p_type_syntax is not in memory pool of ";
52259 0 : std::cout << p_type_syntax->class_name() << std::endl;
52260 : }
52261 : }
52262 : else
52263 : {
52264 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52265 0 : std::cout << "SgFunctionType* p_type_syntax = " << p_type_syntax << " --> " << std::flush;
52266 0 : std::cout << " not valid " << std::endl;
52267 : }
52268 : }
52269 :
52270 0 : if ( p_parameterList_syntax != NULL )
52271 : {
52272 0 : if ( p_parameterList_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52273 : {
52274 0 : if ( p_parameterList_syntax->isInMemoryPool() == false )
52275 : {
52276 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52277 0 : std::cout << " p_parameterList_syntax is not in memory pool of ";
52278 0 : std::cout << p_parameterList_syntax->class_name() << std::endl;
52279 : }
52280 : }
52281 : else
52282 : {
52283 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52284 0 : std::cout << "SgFunctionParameterList* p_parameterList_syntax = " << p_parameterList_syntax << " --> " << std::flush;
52285 0 : std::cout << " not valid " << std::endl;
52286 : }
52287 : }
52288 :
52289 0 : if ( p_functionParameterScope != NULL )
52290 : {
52291 0 : if ( p_functionParameterScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52292 : {
52293 0 : if ( p_functionParameterScope->isInMemoryPool() == false )
52294 : {
52295 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52296 0 : std::cout << " p_functionParameterScope is not in memory pool of ";
52297 0 : std::cout << p_functionParameterScope->class_name() << std::endl;
52298 : }
52299 : }
52300 : else
52301 : {
52302 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52303 0 : std::cout << "SgFunctionParameterScope* p_functionParameterScope = " << p_functionParameterScope << " --> " << std::flush;
52304 0 : std::cout << " not valid " << std::endl;
52305 : }
52306 : }
52307 :
52308 0 : if ( p_definingDeclaration != NULL )
52309 : {
52310 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52311 : {
52312 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
52313 : {
52314 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52315 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
52316 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
52317 : }
52318 : }
52319 : else
52320 : {
52321 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52322 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
52323 0 : std::cout << " not valid " << std::endl;
52324 : }
52325 : }
52326 :
52327 0 : if ( p_firstNondefiningDeclaration != NULL )
52328 : {
52329 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52330 : {
52331 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
52332 : {
52333 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52334 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
52335 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
52336 : }
52337 : }
52338 : else
52339 : {
52340 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52341 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
52342 0 : std::cout << " not valid " << std::endl;
52343 : }
52344 : }
52345 :
52346 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
52347 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
52348 : {
52349 0 : if ( (*i_qualifiedNameList) != NULL )
52350 : {
52351 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52352 : {
52353 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
52354 : {
52355 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52356 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
52357 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
52358 : }
52359 : }
52360 : else
52361 : {
52362 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52363 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
52364 0 : std::cout << " entry not valid " << std::endl;
52365 : }
52366 : }
52367 : else
52368 : {
52369 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
52370 : }
52371 : }
52372 :
52373 0 : if ( p_declarationScope != NULL )
52374 : {
52375 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52376 : {
52377 0 : if ( p_declarationScope->isInMemoryPool() == false )
52378 : {
52379 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52380 0 : std::cout << " p_declarationScope is not in memory pool of ";
52381 0 : std::cout << p_declarationScope->class_name() << std::endl;
52382 : }
52383 : }
52384 : else
52385 : {
52386 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52387 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
52388 0 : std::cout << " not valid " << std::endl;
52389 : }
52390 : }
52391 :
52392 0 : if ( p_numeric_label != NULL )
52393 : {
52394 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52395 : {
52396 0 : if ( p_numeric_label->isInMemoryPool() == false )
52397 : {
52398 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52399 0 : std::cout << " p_numeric_label is not in memory pool of ";
52400 0 : std::cout << p_numeric_label->class_name() << std::endl;
52401 : }
52402 : }
52403 : else
52404 : {
52405 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52406 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
52407 0 : std::cout << " not valid " << std::endl;
52408 : }
52409 : }
52410 :
52411 0 : if ( p_startOfConstruct != NULL )
52412 : {
52413 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52414 : {
52415 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
52416 : {
52417 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52418 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
52419 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
52420 : }
52421 : }
52422 : else
52423 : {
52424 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52425 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
52426 0 : std::cout << " not valid " << std::endl;
52427 : }
52428 : }
52429 :
52430 0 : if ( p_endOfConstruct != NULL )
52431 : {
52432 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52433 : {
52434 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
52435 : {
52436 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52437 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
52438 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
52439 : }
52440 : }
52441 : else
52442 : {
52443 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52444 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
52445 0 : std::cout << " not valid " << std::endl;
52446 : }
52447 : }
52448 :
52449 0 : if ( p_parent != NULL )
52450 : {
52451 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52452 : {
52453 0 : if ( p_parent->isInMemoryPool() == false )
52454 : {
52455 0 : std::cout << "SgTemplateFunctionDeclaration :: ";
52456 0 : std::cout << " p_parent is not in memory pool of ";
52457 0 : std::cout << p_parent->class_name() << std::endl;
52458 : }
52459 : }
52460 : else
52461 : {
52462 0 : std::cout << "SgTemplateFunctionDeclaration :: " << std::flush;
52463 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
52464 0 : std::cout << " not valid " << std::endl;
52465 : }
52466 : }
52467 :
52468 :
52469 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
52470 :
52471 0 : }
52472 :
52473 :
52474 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
52475 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
52476 : bool
52477 0 : SgTemplateFunctionDeclaration::isInMemoryPool ()
52478 : {
52479 0 : typedef unsigned char* TestType;
52480 :
52481 0 : bool found = false;
52482 :
52483 0 : ROSE_ASSERT(this != NULL);
52484 :
52485 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
52486 :
52487 0 : TestType tested = (TestType) ( this ) ;
52488 :
52489 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateFunctionDeclaration::pools.begin();
52490 :
52491 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
52492 : // while (found == false && block < Memory_Block_List.end())
52493 0 : while ( (found == false) && (block != SgTemplateFunctionDeclaration::pools.end()) )
52494 : {
52495 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateFunctionDeclaration::pool_size * sizeof(SgTemplateFunctionDeclaration) ) ) ;
52496 0 : ++block;
52497 : }
52498 :
52499 : // Special handling for static data
52500 :
52501 :
52502 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
52503 0 : ROSE_ASSERT(found == true);
52504 :
52505 0 : return found;
52506 : }
52507 : /* #line 52508 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
52508 :
52509 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
52510 :
52511 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
52512 :
52513 : /* #line 52514 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
52514 :
52515 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
52516 :
52517 : void
52518 0 : SgMemberFunctionDeclaration::checkDataMemberPointersIfInMemoryPool()
52519 : {
52520 : // ------------ checking pointers of SgMemberFunctionDeclaration -------------------
52521 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
52522 :
52523 0 : if ( p_CtorInitializerList != NULL )
52524 : {
52525 0 : if ( p_CtorInitializerList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52526 : {
52527 0 : if ( p_CtorInitializerList->isInMemoryPool() == false )
52528 : {
52529 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52530 0 : std::cout << " p_CtorInitializerList is not in memory pool of ";
52531 0 : std::cout << p_CtorInitializerList->class_name() << std::endl;
52532 : }
52533 : }
52534 : else
52535 : {
52536 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52537 0 : std::cout << "SgCtorInitializerList* p_CtorInitializerList = " << p_CtorInitializerList << " --> " << std::flush;
52538 0 : std::cout << " not valid " << std::endl;
52539 : }
52540 : }
52541 :
52542 0 : if ( p_associatedClassDeclaration != NULL )
52543 : {
52544 0 : if ( p_associatedClassDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52545 : {
52546 0 : if ( p_associatedClassDeclaration->isInMemoryPool() == false )
52547 : {
52548 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52549 0 : std::cout << " p_associatedClassDeclaration is not in memory pool of ";
52550 0 : std::cout << p_associatedClassDeclaration->class_name() << std::endl;
52551 : }
52552 : }
52553 : else
52554 : {
52555 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52556 0 : std::cout << "SgDeclarationStatement* p_associatedClassDeclaration = " << p_associatedClassDeclaration << " --> " << std::flush;
52557 0 : std::cout << " not valid " << std::endl;
52558 : }
52559 : }
52560 :
52561 0 : if ( p_parameterList != NULL )
52562 : {
52563 0 : if ( p_parameterList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52564 : {
52565 0 : if ( p_parameterList->isInMemoryPool() == false )
52566 : {
52567 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52568 0 : std::cout << " p_parameterList is not in memory pool of ";
52569 0 : std::cout << p_parameterList->class_name() << std::endl;
52570 : }
52571 : }
52572 : else
52573 : {
52574 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52575 0 : std::cout << "SgFunctionParameterList* p_parameterList = " << p_parameterList << " --> " << std::flush;
52576 0 : std::cout << " not valid " << std::endl;
52577 : }
52578 : }
52579 :
52580 0 : SgTypePtrList::iterator i_exceptionSpecification = p_exceptionSpecification.begin() ;
52581 0 : for ( ; i_exceptionSpecification != p_exceptionSpecification.end(); ++i_exceptionSpecification )
52582 : {
52583 0 : if ( (*i_exceptionSpecification) != NULL )
52584 : {
52585 0 : if ( (*i_exceptionSpecification)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52586 : {
52587 0 : if ( (*i_exceptionSpecification)->isInMemoryPool() == false )
52588 : {
52589 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52590 0 : std::cout << " p_exceptionSpecification ( list of poitners to IR nodes ), entry is not in memory pool of ";
52591 0 : std::cout << (*i_exceptionSpecification)->class_name() << std::endl;
52592 : }
52593 : }
52594 : else
52595 : {
52596 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52597 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> " << std::flush;
52598 0 : std::cout << " entry not valid " << std::endl;
52599 : }
52600 : }
52601 : else
52602 : {
52603 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> NULL " << std::endl;
52604 : }
52605 : }
52606 :
52607 0 : if ( p_decoratorList != NULL )
52608 : {
52609 0 : if ( p_decoratorList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52610 : {
52611 0 : if ( p_decoratorList->isInMemoryPool() == false )
52612 : {
52613 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52614 0 : std::cout << " p_decoratorList is not in memory pool of ";
52615 0 : std::cout << p_decoratorList->class_name() << std::endl;
52616 : }
52617 : }
52618 : else
52619 : {
52620 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52621 0 : std::cout << "SgExprListExp* p_decoratorList = " << p_decoratorList << " --> " << std::flush;
52622 0 : std::cout << " not valid " << std::endl;
52623 : }
52624 : }
52625 :
52626 0 : if ( p_type != NULL )
52627 : {
52628 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52629 : {
52630 0 : if ( p_type->isInMemoryPool() == false )
52631 : {
52632 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52633 0 : std::cout << " p_type is not in memory pool of ";
52634 0 : std::cout << p_type->class_name() << std::endl;
52635 : }
52636 : }
52637 : else
52638 : {
52639 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52640 0 : std::cout << "SgFunctionType* p_type = " << p_type << " --> " << std::flush;
52641 0 : std::cout << " not valid " << std::endl;
52642 : }
52643 : }
52644 :
52645 0 : if ( p_definition != NULL )
52646 : {
52647 0 : if ( p_definition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52648 : {
52649 0 : if ( p_definition->isInMemoryPool() == false )
52650 : {
52651 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52652 0 : std::cout << " p_definition is not in memory pool of ";
52653 0 : std::cout << p_definition->class_name() << std::endl;
52654 : }
52655 : }
52656 : else
52657 : {
52658 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52659 0 : std::cout << "SgFunctionDefinition* p_definition = " << p_definition << " --> " << std::flush;
52660 0 : std::cout << " not valid " << std::endl;
52661 : }
52662 : }
52663 :
52664 0 : if ( p_scope != NULL )
52665 : {
52666 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52667 : {
52668 0 : if ( p_scope->isInMemoryPool() == false )
52669 : {
52670 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52671 0 : std::cout << " p_scope is not in memory pool of ";
52672 0 : std::cout << p_scope->class_name() << std::endl;
52673 : }
52674 : }
52675 : else
52676 : {
52677 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52678 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
52679 0 : std::cout << " not valid " << std::endl;
52680 : }
52681 : }
52682 :
52683 0 : if ( p_type_syntax != NULL )
52684 : {
52685 0 : if ( p_type_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52686 : {
52687 0 : if ( p_type_syntax->isInMemoryPool() == false )
52688 : {
52689 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52690 0 : std::cout << " p_type_syntax is not in memory pool of ";
52691 0 : std::cout << p_type_syntax->class_name() << std::endl;
52692 : }
52693 : }
52694 : else
52695 : {
52696 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52697 0 : std::cout << "SgFunctionType* p_type_syntax = " << p_type_syntax << " --> " << std::flush;
52698 0 : std::cout << " not valid " << std::endl;
52699 : }
52700 : }
52701 :
52702 0 : if ( p_parameterList_syntax != NULL )
52703 : {
52704 0 : if ( p_parameterList_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52705 : {
52706 0 : if ( p_parameterList_syntax->isInMemoryPool() == false )
52707 : {
52708 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52709 0 : std::cout << " p_parameterList_syntax is not in memory pool of ";
52710 0 : std::cout << p_parameterList_syntax->class_name() << std::endl;
52711 : }
52712 : }
52713 : else
52714 : {
52715 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52716 0 : std::cout << "SgFunctionParameterList* p_parameterList_syntax = " << p_parameterList_syntax << " --> " << std::flush;
52717 0 : std::cout << " not valid " << std::endl;
52718 : }
52719 : }
52720 :
52721 0 : if ( p_functionParameterScope != NULL )
52722 : {
52723 0 : if ( p_functionParameterScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52724 : {
52725 0 : if ( p_functionParameterScope->isInMemoryPool() == false )
52726 : {
52727 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52728 0 : std::cout << " p_functionParameterScope is not in memory pool of ";
52729 0 : std::cout << p_functionParameterScope->class_name() << std::endl;
52730 : }
52731 : }
52732 : else
52733 : {
52734 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52735 0 : std::cout << "SgFunctionParameterScope* p_functionParameterScope = " << p_functionParameterScope << " --> " << std::flush;
52736 0 : std::cout << " not valid " << std::endl;
52737 : }
52738 : }
52739 :
52740 0 : if ( p_definingDeclaration != NULL )
52741 : {
52742 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52743 : {
52744 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
52745 : {
52746 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52747 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
52748 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
52749 : }
52750 : }
52751 : else
52752 : {
52753 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52754 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
52755 0 : std::cout << " not valid " << std::endl;
52756 : }
52757 : }
52758 :
52759 0 : if ( p_firstNondefiningDeclaration != NULL )
52760 : {
52761 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52762 : {
52763 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
52764 : {
52765 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52766 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
52767 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
52768 : }
52769 : }
52770 : else
52771 : {
52772 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52773 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
52774 0 : std::cout << " not valid " << std::endl;
52775 : }
52776 : }
52777 :
52778 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
52779 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
52780 : {
52781 0 : if ( (*i_qualifiedNameList) != NULL )
52782 : {
52783 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52784 : {
52785 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
52786 : {
52787 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52788 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
52789 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
52790 : }
52791 : }
52792 : else
52793 : {
52794 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52795 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
52796 0 : std::cout << " entry not valid " << std::endl;
52797 : }
52798 : }
52799 : else
52800 : {
52801 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
52802 : }
52803 : }
52804 :
52805 0 : if ( p_declarationScope != NULL )
52806 : {
52807 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52808 : {
52809 0 : if ( p_declarationScope->isInMemoryPool() == false )
52810 : {
52811 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52812 0 : std::cout << " p_declarationScope is not in memory pool of ";
52813 0 : std::cout << p_declarationScope->class_name() << std::endl;
52814 : }
52815 : }
52816 : else
52817 : {
52818 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52819 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
52820 0 : std::cout << " not valid " << std::endl;
52821 : }
52822 : }
52823 :
52824 0 : if ( p_numeric_label != NULL )
52825 : {
52826 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52827 : {
52828 0 : if ( p_numeric_label->isInMemoryPool() == false )
52829 : {
52830 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52831 0 : std::cout << " p_numeric_label is not in memory pool of ";
52832 0 : std::cout << p_numeric_label->class_name() << std::endl;
52833 : }
52834 : }
52835 : else
52836 : {
52837 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52838 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
52839 0 : std::cout << " not valid " << std::endl;
52840 : }
52841 : }
52842 :
52843 0 : if ( p_startOfConstruct != NULL )
52844 : {
52845 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52846 : {
52847 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
52848 : {
52849 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52850 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
52851 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
52852 : }
52853 : }
52854 : else
52855 : {
52856 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52857 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
52858 0 : std::cout << " not valid " << std::endl;
52859 : }
52860 : }
52861 :
52862 0 : if ( p_endOfConstruct != NULL )
52863 : {
52864 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52865 : {
52866 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
52867 : {
52868 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52869 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
52870 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
52871 : }
52872 : }
52873 : else
52874 : {
52875 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52876 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
52877 0 : std::cout << " not valid " << std::endl;
52878 : }
52879 : }
52880 :
52881 0 : if ( p_parent != NULL )
52882 : {
52883 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52884 : {
52885 0 : if ( p_parent->isInMemoryPool() == false )
52886 : {
52887 0 : std::cout << "SgMemberFunctionDeclaration :: ";
52888 0 : std::cout << " p_parent is not in memory pool of ";
52889 0 : std::cout << p_parent->class_name() << std::endl;
52890 : }
52891 : }
52892 : else
52893 : {
52894 0 : std::cout << "SgMemberFunctionDeclaration :: " << std::flush;
52895 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
52896 0 : std::cout << " not valid " << std::endl;
52897 : }
52898 : }
52899 :
52900 :
52901 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
52902 :
52903 0 : }
52904 :
52905 :
52906 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
52907 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
52908 : bool
52909 0 : SgMemberFunctionDeclaration::isInMemoryPool ()
52910 : {
52911 0 : typedef unsigned char* TestType;
52912 :
52913 0 : bool found = false;
52914 :
52915 0 : ROSE_ASSERT(this != NULL);
52916 :
52917 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
52918 :
52919 0 : TestType tested = (TestType) ( this ) ;
52920 :
52921 0 : std::vector < unsigned char* > :: const_iterator block = SgMemberFunctionDeclaration::pools.begin();
52922 :
52923 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
52924 : // while (found == false && block < Memory_Block_List.end())
52925 0 : while ( (found == false) && (block != SgMemberFunctionDeclaration::pools.end()) )
52926 : {
52927 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgMemberFunctionDeclaration::pool_size * sizeof(SgMemberFunctionDeclaration) ) ) ;
52928 0 : ++block;
52929 : }
52930 :
52931 : // Special handling for static data
52932 :
52933 :
52934 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
52935 0 : ROSE_ASSERT(found == true);
52936 :
52937 0 : return found;
52938 : }
52939 : /* #line 52940 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
52940 :
52941 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
52942 :
52943 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
52944 :
52945 : /* #line 52946 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
52946 :
52947 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
52948 :
52949 : void
52950 0 : SgTemplateMemberFunctionDeclaration::checkDataMemberPointersIfInMemoryPool()
52951 : {
52952 : // ------------ checking pointers of SgTemplateMemberFunctionDeclaration -------------------
52953 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
52954 :
52955 0 : SgTemplateParameterPtrList::iterator i_templateParameters = p_templateParameters.begin() ;
52956 0 : for ( ; i_templateParameters != p_templateParameters.end(); ++i_templateParameters )
52957 : {
52958 0 : if ( (*i_templateParameters) != NULL )
52959 : {
52960 0 : if ( (*i_templateParameters)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52961 : {
52962 0 : if ( (*i_templateParameters)->isInMemoryPool() == false )
52963 : {
52964 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
52965 0 : std::cout << " p_templateParameters ( list of poitners to IR nodes ), entry is not in memory pool of ";
52966 0 : std::cout << (*i_templateParameters)->class_name() << std::endl;
52967 : }
52968 : }
52969 : else
52970 : {
52971 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
52972 0 : std::cout << "SgTemplateParameterPtrList p_templateParameters --> " << std::flush;
52973 0 : std::cout << " entry not valid " << std::endl;
52974 : }
52975 : }
52976 : else
52977 : {
52978 0 : std::cout << "SgTemplateParameterPtrList p_templateParameters --> NULL " << std::endl;
52979 : }
52980 : }
52981 :
52982 0 : SgTemplateArgumentPtrList::iterator i_templateSpecializationArguments = p_templateSpecializationArguments.begin() ;
52983 0 : for ( ; i_templateSpecializationArguments != p_templateSpecializationArguments.end(); ++i_templateSpecializationArguments )
52984 : {
52985 0 : if ( (*i_templateSpecializationArguments) != NULL )
52986 : {
52987 0 : if ( (*i_templateSpecializationArguments)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
52988 : {
52989 0 : if ( (*i_templateSpecializationArguments)->isInMemoryPool() == false )
52990 : {
52991 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
52992 0 : std::cout << " p_templateSpecializationArguments ( list of poitners to IR nodes ), entry is not in memory pool of ";
52993 0 : std::cout << (*i_templateSpecializationArguments)->class_name() << std::endl;
52994 : }
52995 : }
52996 : else
52997 : {
52998 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
52999 0 : std::cout << "SgTemplateArgumentPtrList p_templateSpecializationArguments --> " << std::flush;
53000 0 : std::cout << " entry not valid " << std::endl;
53001 : }
53002 : }
53003 : else
53004 : {
53005 0 : std::cout << "SgTemplateArgumentPtrList p_templateSpecializationArguments --> NULL " << std::endl;
53006 : }
53007 : }
53008 :
53009 0 : if ( p_nonreal_decl_scope != NULL )
53010 : {
53011 0 : if ( p_nonreal_decl_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53012 : {
53013 0 : if ( p_nonreal_decl_scope->isInMemoryPool() == false )
53014 : {
53015 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53016 0 : std::cout << " p_nonreal_decl_scope is not in memory pool of ";
53017 0 : std::cout << p_nonreal_decl_scope->class_name() << std::endl;
53018 : }
53019 : }
53020 : else
53021 : {
53022 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53023 0 : std::cout << "SgDeclarationScope* p_nonreal_decl_scope = " << p_nonreal_decl_scope << " --> " << std::flush;
53024 0 : std::cout << " not valid " << std::endl;
53025 : }
53026 : }
53027 :
53028 0 : if ( p_CtorInitializerList != NULL )
53029 : {
53030 0 : if ( p_CtorInitializerList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53031 : {
53032 0 : if ( p_CtorInitializerList->isInMemoryPool() == false )
53033 : {
53034 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53035 0 : std::cout << " p_CtorInitializerList is not in memory pool of ";
53036 0 : std::cout << p_CtorInitializerList->class_name() << std::endl;
53037 : }
53038 : }
53039 : else
53040 : {
53041 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53042 0 : std::cout << "SgCtorInitializerList* p_CtorInitializerList = " << p_CtorInitializerList << " --> " << std::flush;
53043 0 : std::cout << " not valid " << std::endl;
53044 : }
53045 : }
53046 :
53047 0 : if ( p_associatedClassDeclaration != NULL )
53048 : {
53049 0 : if ( p_associatedClassDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53050 : {
53051 0 : if ( p_associatedClassDeclaration->isInMemoryPool() == false )
53052 : {
53053 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53054 0 : std::cout << " p_associatedClassDeclaration is not in memory pool of ";
53055 0 : std::cout << p_associatedClassDeclaration->class_name() << std::endl;
53056 : }
53057 : }
53058 : else
53059 : {
53060 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53061 0 : std::cout << "SgDeclarationStatement* p_associatedClassDeclaration = " << p_associatedClassDeclaration << " --> " << std::flush;
53062 0 : std::cout << " not valid " << std::endl;
53063 : }
53064 : }
53065 :
53066 0 : if ( p_parameterList != NULL )
53067 : {
53068 0 : if ( p_parameterList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53069 : {
53070 0 : if ( p_parameterList->isInMemoryPool() == false )
53071 : {
53072 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53073 0 : std::cout << " p_parameterList is not in memory pool of ";
53074 0 : std::cout << p_parameterList->class_name() << std::endl;
53075 : }
53076 : }
53077 : else
53078 : {
53079 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53080 0 : std::cout << "SgFunctionParameterList* p_parameterList = " << p_parameterList << " --> " << std::flush;
53081 0 : std::cout << " not valid " << std::endl;
53082 : }
53083 : }
53084 :
53085 0 : SgTypePtrList::iterator i_exceptionSpecification = p_exceptionSpecification.begin() ;
53086 0 : for ( ; i_exceptionSpecification != p_exceptionSpecification.end(); ++i_exceptionSpecification )
53087 : {
53088 0 : if ( (*i_exceptionSpecification) != NULL )
53089 : {
53090 0 : if ( (*i_exceptionSpecification)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53091 : {
53092 0 : if ( (*i_exceptionSpecification)->isInMemoryPool() == false )
53093 : {
53094 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53095 0 : std::cout << " p_exceptionSpecification ( list of poitners to IR nodes ), entry is not in memory pool of ";
53096 0 : std::cout << (*i_exceptionSpecification)->class_name() << std::endl;
53097 : }
53098 : }
53099 : else
53100 : {
53101 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53102 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> " << std::flush;
53103 0 : std::cout << " entry not valid " << std::endl;
53104 : }
53105 : }
53106 : else
53107 : {
53108 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> NULL " << std::endl;
53109 : }
53110 : }
53111 :
53112 0 : if ( p_decoratorList != NULL )
53113 : {
53114 0 : if ( p_decoratorList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53115 : {
53116 0 : if ( p_decoratorList->isInMemoryPool() == false )
53117 : {
53118 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53119 0 : std::cout << " p_decoratorList is not in memory pool of ";
53120 0 : std::cout << p_decoratorList->class_name() << std::endl;
53121 : }
53122 : }
53123 : else
53124 : {
53125 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53126 0 : std::cout << "SgExprListExp* p_decoratorList = " << p_decoratorList << " --> " << std::flush;
53127 0 : std::cout << " not valid " << std::endl;
53128 : }
53129 : }
53130 :
53131 0 : if ( p_type != NULL )
53132 : {
53133 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53134 : {
53135 0 : if ( p_type->isInMemoryPool() == false )
53136 : {
53137 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53138 0 : std::cout << " p_type is not in memory pool of ";
53139 0 : std::cout << p_type->class_name() << std::endl;
53140 : }
53141 : }
53142 : else
53143 : {
53144 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53145 0 : std::cout << "SgFunctionType* p_type = " << p_type << " --> " << std::flush;
53146 0 : std::cout << " not valid " << std::endl;
53147 : }
53148 : }
53149 :
53150 0 : if ( p_definition != NULL )
53151 : {
53152 0 : if ( p_definition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53153 : {
53154 0 : if ( p_definition->isInMemoryPool() == false )
53155 : {
53156 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53157 0 : std::cout << " p_definition is not in memory pool of ";
53158 0 : std::cout << p_definition->class_name() << std::endl;
53159 : }
53160 : }
53161 : else
53162 : {
53163 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53164 0 : std::cout << "SgFunctionDefinition* p_definition = " << p_definition << " --> " << std::flush;
53165 0 : std::cout << " not valid " << std::endl;
53166 : }
53167 : }
53168 :
53169 0 : if ( p_scope != NULL )
53170 : {
53171 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53172 : {
53173 0 : if ( p_scope->isInMemoryPool() == false )
53174 : {
53175 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53176 0 : std::cout << " p_scope is not in memory pool of ";
53177 0 : std::cout << p_scope->class_name() << std::endl;
53178 : }
53179 : }
53180 : else
53181 : {
53182 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53183 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
53184 0 : std::cout << " not valid " << std::endl;
53185 : }
53186 : }
53187 :
53188 0 : if ( p_type_syntax != NULL )
53189 : {
53190 0 : if ( p_type_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53191 : {
53192 0 : if ( p_type_syntax->isInMemoryPool() == false )
53193 : {
53194 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53195 0 : std::cout << " p_type_syntax is not in memory pool of ";
53196 0 : std::cout << p_type_syntax->class_name() << std::endl;
53197 : }
53198 : }
53199 : else
53200 : {
53201 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53202 0 : std::cout << "SgFunctionType* p_type_syntax = " << p_type_syntax << " --> " << std::flush;
53203 0 : std::cout << " not valid " << std::endl;
53204 : }
53205 : }
53206 :
53207 0 : if ( p_parameterList_syntax != NULL )
53208 : {
53209 0 : if ( p_parameterList_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53210 : {
53211 0 : if ( p_parameterList_syntax->isInMemoryPool() == false )
53212 : {
53213 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53214 0 : std::cout << " p_parameterList_syntax is not in memory pool of ";
53215 0 : std::cout << p_parameterList_syntax->class_name() << std::endl;
53216 : }
53217 : }
53218 : else
53219 : {
53220 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53221 0 : std::cout << "SgFunctionParameterList* p_parameterList_syntax = " << p_parameterList_syntax << " --> " << std::flush;
53222 0 : std::cout << " not valid " << std::endl;
53223 : }
53224 : }
53225 :
53226 0 : if ( p_functionParameterScope != NULL )
53227 : {
53228 0 : if ( p_functionParameterScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53229 : {
53230 0 : if ( p_functionParameterScope->isInMemoryPool() == false )
53231 : {
53232 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53233 0 : std::cout << " p_functionParameterScope is not in memory pool of ";
53234 0 : std::cout << p_functionParameterScope->class_name() << std::endl;
53235 : }
53236 : }
53237 : else
53238 : {
53239 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53240 0 : std::cout << "SgFunctionParameterScope* p_functionParameterScope = " << p_functionParameterScope << " --> " << std::flush;
53241 0 : std::cout << " not valid " << std::endl;
53242 : }
53243 : }
53244 :
53245 0 : if ( p_definingDeclaration != NULL )
53246 : {
53247 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53248 : {
53249 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
53250 : {
53251 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53252 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
53253 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
53254 : }
53255 : }
53256 : else
53257 : {
53258 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53259 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
53260 0 : std::cout << " not valid " << std::endl;
53261 : }
53262 : }
53263 :
53264 0 : if ( p_firstNondefiningDeclaration != NULL )
53265 : {
53266 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53267 : {
53268 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
53269 : {
53270 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53271 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
53272 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
53273 : }
53274 : }
53275 : else
53276 : {
53277 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53278 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
53279 0 : std::cout << " not valid " << std::endl;
53280 : }
53281 : }
53282 :
53283 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
53284 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
53285 : {
53286 0 : if ( (*i_qualifiedNameList) != NULL )
53287 : {
53288 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53289 : {
53290 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
53291 : {
53292 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53293 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
53294 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
53295 : }
53296 : }
53297 : else
53298 : {
53299 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53300 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
53301 0 : std::cout << " entry not valid " << std::endl;
53302 : }
53303 : }
53304 : else
53305 : {
53306 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
53307 : }
53308 : }
53309 :
53310 0 : if ( p_declarationScope != NULL )
53311 : {
53312 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53313 : {
53314 0 : if ( p_declarationScope->isInMemoryPool() == false )
53315 : {
53316 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53317 0 : std::cout << " p_declarationScope is not in memory pool of ";
53318 0 : std::cout << p_declarationScope->class_name() << std::endl;
53319 : }
53320 : }
53321 : else
53322 : {
53323 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53324 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
53325 0 : std::cout << " not valid " << std::endl;
53326 : }
53327 : }
53328 :
53329 0 : if ( p_numeric_label != NULL )
53330 : {
53331 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53332 : {
53333 0 : if ( p_numeric_label->isInMemoryPool() == false )
53334 : {
53335 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53336 0 : std::cout << " p_numeric_label is not in memory pool of ";
53337 0 : std::cout << p_numeric_label->class_name() << std::endl;
53338 : }
53339 : }
53340 : else
53341 : {
53342 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53343 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
53344 0 : std::cout << " not valid " << std::endl;
53345 : }
53346 : }
53347 :
53348 0 : if ( p_startOfConstruct != NULL )
53349 : {
53350 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53351 : {
53352 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
53353 : {
53354 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53355 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
53356 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
53357 : }
53358 : }
53359 : else
53360 : {
53361 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53362 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
53363 0 : std::cout << " not valid " << std::endl;
53364 : }
53365 : }
53366 :
53367 0 : if ( p_endOfConstruct != NULL )
53368 : {
53369 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53370 : {
53371 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
53372 : {
53373 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53374 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
53375 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
53376 : }
53377 : }
53378 : else
53379 : {
53380 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53381 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
53382 0 : std::cout << " not valid " << std::endl;
53383 : }
53384 : }
53385 :
53386 0 : if ( p_parent != NULL )
53387 : {
53388 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53389 : {
53390 0 : if ( p_parent->isInMemoryPool() == false )
53391 : {
53392 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: ";
53393 0 : std::cout << " p_parent is not in memory pool of ";
53394 0 : std::cout << p_parent->class_name() << std::endl;
53395 : }
53396 : }
53397 : else
53398 : {
53399 0 : std::cout << "SgTemplateMemberFunctionDeclaration :: " << std::flush;
53400 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
53401 0 : std::cout << " not valid " << std::endl;
53402 : }
53403 : }
53404 :
53405 :
53406 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
53407 :
53408 0 : }
53409 :
53410 :
53411 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
53412 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
53413 : bool
53414 0 : SgTemplateMemberFunctionDeclaration::isInMemoryPool ()
53415 : {
53416 0 : typedef unsigned char* TestType;
53417 :
53418 0 : bool found = false;
53419 :
53420 0 : ROSE_ASSERT(this != NULL);
53421 :
53422 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
53423 :
53424 0 : TestType tested = (TestType) ( this ) ;
53425 :
53426 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateMemberFunctionDeclaration::pools.begin();
53427 :
53428 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
53429 : // while (found == false && block < Memory_Block_List.end())
53430 0 : while ( (found == false) && (block != SgTemplateMemberFunctionDeclaration::pools.end()) )
53431 : {
53432 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateMemberFunctionDeclaration::pool_size * sizeof(SgTemplateMemberFunctionDeclaration) ) ) ;
53433 0 : ++block;
53434 : }
53435 :
53436 : // Special handling for static data
53437 :
53438 :
53439 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
53440 0 : ROSE_ASSERT(found == true);
53441 :
53442 0 : return found;
53443 : }
53444 : /* #line 53445 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
53445 :
53446 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
53447 :
53448 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
53449 :
53450 : /* #line 53451 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
53451 :
53452 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
53453 :
53454 : void
53455 0 : SgTemplateInstantiationMemberFunctionDecl::checkDataMemberPointersIfInMemoryPool()
53456 : {
53457 : // ------------ checking pointers of SgTemplateInstantiationMemberFunctionDecl -------------------
53458 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
53459 :
53460 0 : if ( p_templateDeclaration != NULL )
53461 : {
53462 0 : if ( p_templateDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53463 : {
53464 0 : if ( p_templateDeclaration->isInMemoryPool() == false )
53465 : {
53466 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53467 0 : std::cout << " p_templateDeclaration is not in memory pool of ";
53468 0 : std::cout << p_templateDeclaration->class_name() << std::endl;
53469 : }
53470 : }
53471 : else
53472 : {
53473 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53474 0 : std::cout << "SgTemplateMemberFunctionDeclaration* p_templateDeclaration = " << p_templateDeclaration << " --> " << std::flush;
53475 0 : std::cout << " not valid " << std::endl;
53476 : }
53477 : }
53478 :
53479 0 : SgTemplateArgumentPtrList::iterator i_templateArguments = p_templateArguments.begin() ;
53480 0 : for ( ; i_templateArguments != p_templateArguments.end(); ++i_templateArguments )
53481 : {
53482 0 : if ( (*i_templateArguments) != NULL )
53483 : {
53484 0 : if ( (*i_templateArguments)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53485 : {
53486 0 : if ( (*i_templateArguments)->isInMemoryPool() == false )
53487 : {
53488 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53489 0 : std::cout << " p_templateArguments ( list of poitners to IR nodes ), entry is not in memory pool of ";
53490 0 : std::cout << (*i_templateArguments)->class_name() << std::endl;
53491 : }
53492 : }
53493 : else
53494 : {
53495 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53496 0 : std::cout << "SgTemplateArgumentPtrList p_templateArguments --> " << std::flush;
53497 0 : std::cout << " entry not valid " << std::endl;
53498 : }
53499 : }
53500 : else
53501 : {
53502 0 : std::cout << "SgTemplateArgumentPtrList p_templateArguments --> NULL " << std::endl;
53503 : }
53504 : }
53505 :
53506 0 : if ( p_CtorInitializerList != NULL )
53507 : {
53508 0 : if ( p_CtorInitializerList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53509 : {
53510 0 : if ( p_CtorInitializerList->isInMemoryPool() == false )
53511 : {
53512 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53513 0 : std::cout << " p_CtorInitializerList is not in memory pool of ";
53514 0 : std::cout << p_CtorInitializerList->class_name() << std::endl;
53515 : }
53516 : }
53517 : else
53518 : {
53519 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53520 0 : std::cout << "SgCtorInitializerList* p_CtorInitializerList = " << p_CtorInitializerList << " --> " << std::flush;
53521 0 : std::cout << " not valid " << std::endl;
53522 : }
53523 : }
53524 :
53525 0 : if ( p_associatedClassDeclaration != NULL )
53526 : {
53527 0 : if ( p_associatedClassDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53528 : {
53529 0 : if ( p_associatedClassDeclaration->isInMemoryPool() == false )
53530 : {
53531 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53532 0 : std::cout << " p_associatedClassDeclaration is not in memory pool of ";
53533 0 : std::cout << p_associatedClassDeclaration->class_name() << std::endl;
53534 : }
53535 : }
53536 : else
53537 : {
53538 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53539 0 : std::cout << "SgDeclarationStatement* p_associatedClassDeclaration = " << p_associatedClassDeclaration << " --> " << std::flush;
53540 0 : std::cout << " not valid " << std::endl;
53541 : }
53542 : }
53543 :
53544 0 : if ( p_parameterList != NULL )
53545 : {
53546 0 : if ( p_parameterList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53547 : {
53548 0 : if ( p_parameterList->isInMemoryPool() == false )
53549 : {
53550 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53551 0 : std::cout << " p_parameterList is not in memory pool of ";
53552 0 : std::cout << p_parameterList->class_name() << std::endl;
53553 : }
53554 : }
53555 : else
53556 : {
53557 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53558 0 : std::cout << "SgFunctionParameterList* p_parameterList = " << p_parameterList << " --> " << std::flush;
53559 0 : std::cout << " not valid " << std::endl;
53560 : }
53561 : }
53562 :
53563 0 : SgTypePtrList::iterator i_exceptionSpecification = p_exceptionSpecification.begin() ;
53564 0 : for ( ; i_exceptionSpecification != p_exceptionSpecification.end(); ++i_exceptionSpecification )
53565 : {
53566 0 : if ( (*i_exceptionSpecification) != NULL )
53567 : {
53568 0 : if ( (*i_exceptionSpecification)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53569 : {
53570 0 : if ( (*i_exceptionSpecification)->isInMemoryPool() == false )
53571 : {
53572 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53573 0 : std::cout << " p_exceptionSpecification ( list of poitners to IR nodes ), entry is not in memory pool of ";
53574 0 : std::cout << (*i_exceptionSpecification)->class_name() << std::endl;
53575 : }
53576 : }
53577 : else
53578 : {
53579 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53580 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> " << std::flush;
53581 0 : std::cout << " entry not valid " << std::endl;
53582 : }
53583 : }
53584 : else
53585 : {
53586 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> NULL " << std::endl;
53587 : }
53588 : }
53589 :
53590 0 : if ( p_decoratorList != NULL )
53591 : {
53592 0 : if ( p_decoratorList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53593 : {
53594 0 : if ( p_decoratorList->isInMemoryPool() == false )
53595 : {
53596 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53597 0 : std::cout << " p_decoratorList is not in memory pool of ";
53598 0 : std::cout << p_decoratorList->class_name() << std::endl;
53599 : }
53600 : }
53601 : else
53602 : {
53603 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53604 0 : std::cout << "SgExprListExp* p_decoratorList = " << p_decoratorList << " --> " << std::flush;
53605 0 : std::cout << " not valid " << std::endl;
53606 : }
53607 : }
53608 :
53609 0 : if ( p_type != NULL )
53610 : {
53611 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53612 : {
53613 0 : if ( p_type->isInMemoryPool() == false )
53614 : {
53615 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53616 0 : std::cout << " p_type is not in memory pool of ";
53617 0 : std::cout << p_type->class_name() << std::endl;
53618 : }
53619 : }
53620 : else
53621 : {
53622 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53623 0 : std::cout << "SgFunctionType* p_type = " << p_type << " --> " << std::flush;
53624 0 : std::cout << " not valid " << std::endl;
53625 : }
53626 : }
53627 :
53628 0 : if ( p_definition != NULL )
53629 : {
53630 0 : if ( p_definition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53631 : {
53632 0 : if ( p_definition->isInMemoryPool() == false )
53633 : {
53634 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53635 0 : std::cout << " p_definition is not in memory pool of ";
53636 0 : std::cout << p_definition->class_name() << std::endl;
53637 : }
53638 : }
53639 : else
53640 : {
53641 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53642 0 : std::cout << "SgFunctionDefinition* p_definition = " << p_definition << " --> " << std::flush;
53643 0 : std::cout << " not valid " << std::endl;
53644 : }
53645 : }
53646 :
53647 0 : if ( p_scope != NULL )
53648 : {
53649 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53650 : {
53651 0 : if ( p_scope->isInMemoryPool() == false )
53652 : {
53653 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53654 0 : std::cout << " p_scope is not in memory pool of ";
53655 0 : std::cout << p_scope->class_name() << std::endl;
53656 : }
53657 : }
53658 : else
53659 : {
53660 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53661 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
53662 0 : std::cout << " not valid " << std::endl;
53663 : }
53664 : }
53665 :
53666 0 : if ( p_type_syntax != NULL )
53667 : {
53668 0 : if ( p_type_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53669 : {
53670 0 : if ( p_type_syntax->isInMemoryPool() == false )
53671 : {
53672 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53673 0 : std::cout << " p_type_syntax is not in memory pool of ";
53674 0 : std::cout << p_type_syntax->class_name() << std::endl;
53675 : }
53676 : }
53677 : else
53678 : {
53679 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53680 0 : std::cout << "SgFunctionType* p_type_syntax = " << p_type_syntax << " --> " << std::flush;
53681 0 : std::cout << " not valid " << std::endl;
53682 : }
53683 : }
53684 :
53685 0 : if ( p_parameterList_syntax != NULL )
53686 : {
53687 0 : if ( p_parameterList_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53688 : {
53689 0 : if ( p_parameterList_syntax->isInMemoryPool() == false )
53690 : {
53691 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53692 0 : std::cout << " p_parameterList_syntax is not in memory pool of ";
53693 0 : std::cout << p_parameterList_syntax->class_name() << std::endl;
53694 : }
53695 : }
53696 : else
53697 : {
53698 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53699 0 : std::cout << "SgFunctionParameterList* p_parameterList_syntax = " << p_parameterList_syntax << " --> " << std::flush;
53700 0 : std::cout << " not valid " << std::endl;
53701 : }
53702 : }
53703 :
53704 0 : if ( p_functionParameterScope != NULL )
53705 : {
53706 0 : if ( p_functionParameterScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53707 : {
53708 0 : if ( p_functionParameterScope->isInMemoryPool() == false )
53709 : {
53710 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53711 0 : std::cout << " p_functionParameterScope is not in memory pool of ";
53712 0 : std::cout << p_functionParameterScope->class_name() << std::endl;
53713 : }
53714 : }
53715 : else
53716 : {
53717 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53718 0 : std::cout << "SgFunctionParameterScope* p_functionParameterScope = " << p_functionParameterScope << " --> " << std::flush;
53719 0 : std::cout << " not valid " << std::endl;
53720 : }
53721 : }
53722 :
53723 0 : if ( p_definingDeclaration != NULL )
53724 : {
53725 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53726 : {
53727 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
53728 : {
53729 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53730 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
53731 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
53732 : }
53733 : }
53734 : else
53735 : {
53736 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53737 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
53738 0 : std::cout << " not valid " << std::endl;
53739 : }
53740 : }
53741 :
53742 0 : if ( p_firstNondefiningDeclaration != NULL )
53743 : {
53744 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53745 : {
53746 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
53747 : {
53748 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53749 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
53750 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
53751 : }
53752 : }
53753 : else
53754 : {
53755 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53756 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
53757 0 : std::cout << " not valid " << std::endl;
53758 : }
53759 : }
53760 :
53761 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
53762 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
53763 : {
53764 0 : if ( (*i_qualifiedNameList) != NULL )
53765 : {
53766 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53767 : {
53768 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
53769 : {
53770 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53771 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
53772 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
53773 : }
53774 : }
53775 : else
53776 : {
53777 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53778 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
53779 0 : std::cout << " entry not valid " << std::endl;
53780 : }
53781 : }
53782 : else
53783 : {
53784 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
53785 : }
53786 : }
53787 :
53788 0 : if ( p_declarationScope != NULL )
53789 : {
53790 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53791 : {
53792 0 : if ( p_declarationScope->isInMemoryPool() == false )
53793 : {
53794 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53795 0 : std::cout << " p_declarationScope is not in memory pool of ";
53796 0 : std::cout << p_declarationScope->class_name() << std::endl;
53797 : }
53798 : }
53799 : else
53800 : {
53801 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53802 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
53803 0 : std::cout << " not valid " << std::endl;
53804 : }
53805 : }
53806 :
53807 0 : if ( p_numeric_label != NULL )
53808 : {
53809 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53810 : {
53811 0 : if ( p_numeric_label->isInMemoryPool() == false )
53812 : {
53813 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53814 0 : std::cout << " p_numeric_label is not in memory pool of ";
53815 0 : std::cout << p_numeric_label->class_name() << std::endl;
53816 : }
53817 : }
53818 : else
53819 : {
53820 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53821 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
53822 0 : std::cout << " not valid " << std::endl;
53823 : }
53824 : }
53825 :
53826 0 : if ( p_startOfConstruct != NULL )
53827 : {
53828 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53829 : {
53830 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
53831 : {
53832 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53833 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
53834 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
53835 : }
53836 : }
53837 : else
53838 : {
53839 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53840 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
53841 0 : std::cout << " not valid " << std::endl;
53842 : }
53843 : }
53844 :
53845 0 : if ( p_endOfConstruct != NULL )
53846 : {
53847 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53848 : {
53849 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
53850 : {
53851 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53852 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
53853 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
53854 : }
53855 : }
53856 : else
53857 : {
53858 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53859 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
53860 0 : std::cout << " not valid " << std::endl;
53861 : }
53862 : }
53863 :
53864 0 : if ( p_parent != NULL )
53865 : {
53866 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53867 : {
53868 0 : if ( p_parent->isInMemoryPool() == false )
53869 : {
53870 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: ";
53871 0 : std::cout << " p_parent is not in memory pool of ";
53872 0 : std::cout << p_parent->class_name() << std::endl;
53873 : }
53874 : }
53875 : else
53876 : {
53877 0 : std::cout << "SgTemplateInstantiationMemberFunctionDecl :: " << std::flush;
53878 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
53879 0 : std::cout << " not valid " << std::endl;
53880 : }
53881 : }
53882 :
53883 :
53884 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
53885 :
53886 0 : }
53887 :
53888 :
53889 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
53890 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
53891 : bool
53892 0 : SgTemplateInstantiationMemberFunctionDecl::isInMemoryPool ()
53893 : {
53894 0 : typedef unsigned char* TestType;
53895 :
53896 0 : bool found = false;
53897 :
53898 0 : ROSE_ASSERT(this != NULL);
53899 :
53900 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
53901 :
53902 0 : TestType tested = (TestType) ( this ) ;
53903 :
53904 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateInstantiationMemberFunctionDecl::pools.begin();
53905 :
53906 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
53907 : // while (found == false && block < Memory_Block_List.end())
53908 0 : while ( (found == false) && (block != SgTemplateInstantiationMemberFunctionDecl::pools.end()) )
53909 : {
53910 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateInstantiationMemberFunctionDecl::pool_size * sizeof(SgTemplateInstantiationMemberFunctionDecl) ) ) ;
53911 0 : ++block;
53912 : }
53913 :
53914 : // Special handling for static data
53915 :
53916 :
53917 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
53918 0 : ROSE_ASSERT(found == true);
53919 :
53920 0 : return found;
53921 : }
53922 : /* #line 53923 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
53923 :
53924 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
53925 :
53926 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
53927 :
53928 : /* #line 53929 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
53929 :
53930 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
53931 :
53932 : void
53933 0 : SgTemplateInstantiationFunctionDecl::checkDataMemberPointersIfInMemoryPool()
53934 : {
53935 : // ------------ checking pointers of SgTemplateInstantiationFunctionDecl -------------------
53936 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
53937 :
53938 0 : if ( p_templateDeclaration != NULL )
53939 : {
53940 0 : if ( p_templateDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53941 : {
53942 0 : if ( p_templateDeclaration->isInMemoryPool() == false )
53943 : {
53944 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
53945 0 : std::cout << " p_templateDeclaration is not in memory pool of ";
53946 0 : std::cout << p_templateDeclaration->class_name() << std::endl;
53947 : }
53948 : }
53949 : else
53950 : {
53951 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
53952 0 : std::cout << "SgTemplateFunctionDeclaration* p_templateDeclaration = " << p_templateDeclaration << " --> " << std::flush;
53953 0 : std::cout << " not valid " << std::endl;
53954 : }
53955 : }
53956 :
53957 0 : SgTemplateArgumentPtrList::iterator i_templateArguments = p_templateArguments.begin() ;
53958 0 : for ( ; i_templateArguments != p_templateArguments.end(); ++i_templateArguments )
53959 : {
53960 0 : if ( (*i_templateArguments) != NULL )
53961 : {
53962 0 : if ( (*i_templateArguments)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53963 : {
53964 0 : if ( (*i_templateArguments)->isInMemoryPool() == false )
53965 : {
53966 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
53967 0 : std::cout << " p_templateArguments ( list of poitners to IR nodes ), entry is not in memory pool of ";
53968 0 : std::cout << (*i_templateArguments)->class_name() << std::endl;
53969 : }
53970 : }
53971 : else
53972 : {
53973 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
53974 0 : std::cout << "SgTemplateArgumentPtrList p_templateArguments --> " << std::flush;
53975 0 : std::cout << " entry not valid " << std::endl;
53976 : }
53977 : }
53978 : else
53979 : {
53980 0 : std::cout << "SgTemplateArgumentPtrList p_templateArguments --> NULL " << std::endl;
53981 : }
53982 : }
53983 :
53984 0 : if ( p_parameterList != NULL )
53985 : {
53986 0 : if ( p_parameterList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
53987 : {
53988 0 : if ( p_parameterList->isInMemoryPool() == false )
53989 : {
53990 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
53991 0 : std::cout << " p_parameterList is not in memory pool of ";
53992 0 : std::cout << p_parameterList->class_name() << std::endl;
53993 : }
53994 : }
53995 : else
53996 : {
53997 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
53998 0 : std::cout << "SgFunctionParameterList* p_parameterList = " << p_parameterList << " --> " << std::flush;
53999 0 : std::cout << " not valid " << std::endl;
54000 : }
54001 : }
54002 :
54003 0 : SgTypePtrList::iterator i_exceptionSpecification = p_exceptionSpecification.begin() ;
54004 0 : for ( ; i_exceptionSpecification != p_exceptionSpecification.end(); ++i_exceptionSpecification )
54005 : {
54006 0 : if ( (*i_exceptionSpecification) != NULL )
54007 : {
54008 0 : if ( (*i_exceptionSpecification)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54009 : {
54010 0 : if ( (*i_exceptionSpecification)->isInMemoryPool() == false )
54011 : {
54012 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
54013 0 : std::cout << " p_exceptionSpecification ( list of poitners to IR nodes ), entry is not in memory pool of ";
54014 0 : std::cout << (*i_exceptionSpecification)->class_name() << std::endl;
54015 : }
54016 : }
54017 : else
54018 : {
54019 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
54020 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> " << std::flush;
54021 0 : std::cout << " entry not valid " << std::endl;
54022 : }
54023 : }
54024 : else
54025 : {
54026 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> NULL " << std::endl;
54027 : }
54028 : }
54029 :
54030 0 : if ( p_decoratorList != NULL )
54031 : {
54032 0 : if ( p_decoratorList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54033 : {
54034 0 : if ( p_decoratorList->isInMemoryPool() == false )
54035 : {
54036 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
54037 0 : std::cout << " p_decoratorList is not in memory pool of ";
54038 0 : std::cout << p_decoratorList->class_name() << std::endl;
54039 : }
54040 : }
54041 : else
54042 : {
54043 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
54044 0 : std::cout << "SgExprListExp* p_decoratorList = " << p_decoratorList << " --> " << std::flush;
54045 0 : std::cout << " not valid " << std::endl;
54046 : }
54047 : }
54048 :
54049 0 : if ( p_type != NULL )
54050 : {
54051 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54052 : {
54053 0 : if ( p_type->isInMemoryPool() == false )
54054 : {
54055 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
54056 0 : std::cout << " p_type is not in memory pool of ";
54057 0 : std::cout << p_type->class_name() << std::endl;
54058 : }
54059 : }
54060 : else
54061 : {
54062 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
54063 0 : std::cout << "SgFunctionType* p_type = " << p_type << " --> " << std::flush;
54064 0 : std::cout << " not valid " << std::endl;
54065 : }
54066 : }
54067 :
54068 0 : if ( p_definition != NULL )
54069 : {
54070 0 : if ( p_definition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54071 : {
54072 0 : if ( p_definition->isInMemoryPool() == false )
54073 : {
54074 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
54075 0 : std::cout << " p_definition is not in memory pool of ";
54076 0 : std::cout << p_definition->class_name() << std::endl;
54077 : }
54078 : }
54079 : else
54080 : {
54081 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
54082 0 : std::cout << "SgFunctionDefinition* p_definition = " << p_definition << " --> " << std::flush;
54083 0 : std::cout << " not valid " << std::endl;
54084 : }
54085 : }
54086 :
54087 0 : if ( p_scope != NULL )
54088 : {
54089 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54090 : {
54091 0 : if ( p_scope->isInMemoryPool() == false )
54092 : {
54093 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
54094 0 : std::cout << " p_scope is not in memory pool of ";
54095 0 : std::cout << p_scope->class_name() << std::endl;
54096 : }
54097 : }
54098 : else
54099 : {
54100 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
54101 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
54102 0 : std::cout << " not valid " << std::endl;
54103 : }
54104 : }
54105 :
54106 0 : if ( p_type_syntax != NULL )
54107 : {
54108 0 : if ( p_type_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54109 : {
54110 0 : if ( p_type_syntax->isInMemoryPool() == false )
54111 : {
54112 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
54113 0 : std::cout << " p_type_syntax is not in memory pool of ";
54114 0 : std::cout << p_type_syntax->class_name() << std::endl;
54115 : }
54116 : }
54117 : else
54118 : {
54119 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
54120 0 : std::cout << "SgFunctionType* p_type_syntax = " << p_type_syntax << " --> " << std::flush;
54121 0 : std::cout << " not valid " << std::endl;
54122 : }
54123 : }
54124 :
54125 0 : if ( p_parameterList_syntax != NULL )
54126 : {
54127 0 : if ( p_parameterList_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54128 : {
54129 0 : if ( p_parameterList_syntax->isInMemoryPool() == false )
54130 : {
54131 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
54132 0 : std::cout << " p_parameterList_syntax is not in memory pool of ";
54133 0 : std::cout << p_parameterList_syntax->class_name() << std::endl;
54134 : }
54135 : }
54136 : else
54137 : {
54138 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
54139 0 : std::cout << "SgFunctionParameterList* p_parameterList_syntax = " << p_parameterList_syntax << " --> " << std::flush;
54140 0 : std::cout << " not valid " << std::endl;
54141 : }
54142 : }
54143 :
54144 0 : if ( p_functionParameterScope != NULL )
54145 : {
54146 0 : if ( p_functionParameterScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54147 : {
54148 0 : if ( p_functionParameterScope->isInMemoryPool() == false )
54149 : {
54150 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
54151 0 : std::cout << " p_functionParameterScope is not in memory pool of ";
54152 0 : std::cout << p_functionParameterScope->class_name() << std::endl;
54153 : }
54154 : }
54155 : else
54156 : {
54157 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
54158 0 : std::cout << "SgFunctionParameterScope* p_functionParameterScope = " << p_functionParameterScope << " --> " << std::flush;
54159 0 : std::cout << " not valid " << std::endl;
54160 : }
54161 : }
54162 :
54163 0 : if ( p_definingDeclaration != NULL )
54164 : {
54165 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54166 : {
54167 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
54168 : {
54169 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
54170 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
54171 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
54172 : }
54173 : }
54174 : else
54175 : {
54176 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
54177 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
54178 0 : std::cout << " not valid " << std::endl;
54179 : }
54180 : }
54181 :
54182 0 : if ( p_firstNondefiningDeclaration != NULL )
54183 : {
54184 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54185 : {
54186 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
54187 : {
54188 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
54189 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
54190 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
54191 : }
54192 : }
54193 : else
54194 : {
54195 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
54196 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
54197 0 : std::cout << " not valid " << std::endl;
54198 : }
54199 : }
54200 :
54201 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
54202 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
54203 : {
54204 0 : if ( (*i_qualifiedNameList) != NULL )
54205 : {
54206 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54207 : {
54208 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
54209 : {
54210 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
54211 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
54212 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
54213 : }
54214 : }
54215 : else
54216 : {
54217 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
54218 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
54219 0 : std::cout << " entry not valid " << std::endl;
54220 : }
54221 : }
54222 : else
54223 : {
54224 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
54225 : }
54226 : }
54227 :
54228 0 : if ( p_declarationScope != NULL )
54229 : {
54230 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54231 : {
54232 0 : if ( p_declarationScope->isInMemoryPool() == false )
54233 : {
54234 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
54235 0 : std::cout << " p_declarationScope is not in memory pool of ";
54236 0 : std::cout << p_declarationScope->class_name() << std::endl;
54237 : }
54238 : }
54239 : else
54240 : {
54241 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
54242 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
54243 0 : std::cout << " not valid " << std::endl;
54244 : }
54245 : }
54246 :
54247 0 : if ( p_numeric_label != NULL )
54248 : {
54249 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54250 : {
54251 0 : if ( p_numeric_label->isInMemoryPool() == false )
54252 : {
54253 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
54254 0 : std::cout << " p_numeric_label is not in memory pool of ";
54255 0 : std::cout << p_numeric_label->class_name() << std::endl;
54256 : }
54257 : }
54258 : else
54259 : {
54260 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
54261 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
54262 0 : std::cout << " not valid " << std::endl;
54263 : }
54264 : }
54265 :
54266 0 : if ( p_startOfConstruct != NULL )
54267 : {
54268 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54269 : {
54270 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
54271 : {
54272 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
54273 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
54274 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
54275 : }
54276 : }
54277 : else
54278 : {
54279 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
54280 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
54281 0 : std::cout << " not valid " << std::endl;
54282 : }
54283 : }
54284 :
54285 0 : if ( p_endOfConstruct != NULL )
54286 : {
54287 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54288 : {
54289 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
54290 : {
54291 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
54292 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
54293 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
54294 : }
54295 : }
54296 : else
54297 : {
54298 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
54299 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
54300 0 : std::cout << " not valid " << std::endl;
54301 : }
54302 : }
54303 :
54304 0 : if ( p_parent != NULL )
54305 : {
54306 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54307 : {
54308 0 : if ( p_parent->isInMemoryPool() == false )
54309 : {
54310 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: ";
54311 0 : std::cout << " p_parent is not in memory pool of ";
54312 0 : std::cout << p_parent->class_name() << std::endl;
54313 : }
54314 : }
54315 : else
54316 : {
54317 0 : std::cout << "SgTemplateInstantiationFunctionDecl :: " << std::flush;
54318 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
54319 0 : std::cout << " not valid " << std::endl;
54320 : }
54321 : }
54322 :
54323 :
54324 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
54325 :
54326 0 : }
54327 :
54328 :
54329 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
54330 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
54331 : bool
54332 0 : SgTemplateInstantiationFunctionDecl::isInMemoryPool ()
54333 : {
54334 0 : typedef unsigned char* TestType;
54335 :
54336 0 : bool found = false;
54337 :
54338 0 : ROSE_ASSERT(this != NULL);
54339 :
54340 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
54341 :
54342 0 : TestType tested = (TestType) ( this ) ;
54343 :
54344 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateInstantiationFunctionDecl::pools.begin();
54345 :
54346 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
54347 : // while (found == false && block < Memory_Block_List.end())
54348 0 : while ( (found == false) && (block != SgTemplateInstantiationFunctionDecl::pools.end()) )
54349 : {
54350 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateInstantiationFunctionDecl::pool_size * sizeof(SgTemplateInstantiationFunctionDecl) ) ) ;
54351 0 : ++block;
54352 : }
54353 :
54354 : // Special handling for static data
54355 :
54356 :
54357 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
54358 0 : ROSE_ASSERT(found == true);
54359 :
54360 0 : return found;
54361 : }
54362 : /* #line 54363 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
54363 :
54364 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
54365 :
54366 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
54367 :
54368 : /* #line 54369 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
54369 :
54370 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
54371 :
54372 : void
54373 0 : SgProgramHeaderStatement::checkDataMemberPointersIfInMemoryPool()
54374 : {
54375 : // ------------ checking pointers of SgProgramHeaderStatement -------------------
54376 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
54377 :
54378 0 : if ( p_end_numeric_label != NULL )
54379 : {
54380 0 : if ( p_end_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54381 : {
54382 0 : if ( p_end_numeric_label->isInMemoryPool() == false )
54383 : {
54384 0 : std::cout << "SgProgramHeaderStatement :: ";
54385 0 : std::cout << " p_end_numeric_label is not in memory pool of ";
54386 0 : std::cout << p_end_numeric_label->class_name() << std::endl;
54387 : }
54388 : }
54389 : else
54390 : {
54391 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54392 0 : std::cout << "SgLabelRefExp* p_end_numeric_label = " << p_end_numeric_label << " --> " << std::flush;
54393 0 : std::cout << " not valid " << std::endl;
54394 : }
54395 : }
54396 :
54397 0 : if ( p_parameterList != NULL )
54398 : {
54399 0 : if ( p_parameterList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54400 : {
54401 0 : if ( p_parameterList->isInMemoryPool() == false )
54402 : {
54403 0 : std::cout << "SgProgramHeaderStatement :: ";
54404 0 : std::cout << " p_parameterList is not in memory pool of ";
54405 0 : std::cout << p_parameterList->class_name() << std::endl;
54406 : }
54407 : }
54408 : else
54409 : {
54410 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54411 0 : std::cout << "SgFunctionParameterList* p_parameterList = " << p_parameterList << " --> " << std::flush;
54412 0 : std::cout << " not valid " << std::endl;
54413 : }
54414 : }
54415 :
54416 0 : SgTypePtrList::iterator i_exceptionSpecification = p_exceptionSpecification.begin() ;
54417 0 : for ( ; i_exceptionSpecification != p_exceptionSpecification.end(); ++i_exceptionSpecification )
54418 : {
54419 0 : if ( (*i_exceptionSpecification) != NULL )
54420 : {
54421 0 : if ( (*i_exceptionSpecification)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54422 : {
54423 0 : if ( (*i_exceptionSpecification)->isInMemoryPool() == false )
54424 : {
54425 0 : std::cout << "SgProgramHeaderStatement :: ";
54426 0 : std::cout << " p_exceptionSpecification ( list of poitners to IR nodes ), entry is not in memory pool of ";
54427 0 : std::cout << (*i_exceptionSpecification)->class_name() << std::endl;
54428 : }
54429 : }
54430 : else
54431 : {
54432 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54433 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> " << std::flush;
54434 0 : std::cout << " entry not valid " << std::endl;
54435 : }
54436 : }
54437 : else
54438 : {
54439 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> NULL " << std::endl;
54440 : }
54441 : }
54442 :
54443 0 : if ( p_decoratorList != NULL )
54444 : {
54445 0 : if ( p_decoratorList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54446 : {
54447 0 : if ( p_decoratorList->isInMemoryPool() == false )
54448 : {
54449 0 : std::cout << "SgProgramHeaderStatement :: ";
54450 0 : std::cout << " p_decoratorList is not in memory pool of ";
54451 0 : std::cout << p_decoratorList->class_name() << std::endl;
54452 : }
54453 : }
54454 : else
54455 : {
54456 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54457 0 : std::cout << "SgExprListExp* p_decoratorList = " << p_decoratorList << " --> " << std::flush;
54458 0 : std::cout << " not valid " << std::endl;
54459 : }
54460 : }
54461 :
54462 0 : if ( p_type != NULL )
54463 : {
54464 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54465 : {
54466 0 : if ( p_type->isInMemoryPool() == false )
54467 : {
54468 0 : std::cout << "SgProgramHeaderStatement :: ";
54469 0 : std::cout << " p_type is not in memory pool of ";
54470 0 : std::cout << p_type->class_name() << std::endl;
54471 : }
54472 : }
54473 : else
54474 : {
54475 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54476 0 : std::cout << "SgFunctionType* p_type = " << p_type << " --> " << std::flush;
54477 0 : std::cout << " not valid " << std::endl;
54478 : }
54479 : }
54480 :
54481 0 : if ( p_definition != NULL )
54482 : {
54483 0 : if ( p_definition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54484 : {
54485 0 : if ( p_definition->isInMemoryPool() == false )
54486 : {
54487 0 : std::cout << "SgProgramHeaderStatement :: ";
54488 0 : std::cout << " p_definition is not in memory pool of ";
54489 0 : std::cout << p_definition->class_name() << std::endl;
54490 : }
54491 : }
54492 : else
54493 : {
54494 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54495 0 : std::cout << "SgFunctionDefinition* p_definition = " << p_definition << " --> " << std::flush;
54496 0 : std::cout << " not valid " << std::endl;
54497 : }
54498 : }
54499 :
54500 0 : if ( p_scope != NULL )
54501 : {
54502 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54503 : {
54504 0 : if ( p_scope->isInMemoryPool() == false )
54505 : {
54506 0 : std::cout << "SgProgramHeaderStatement :: ";
54507 0 : std::cout << " p_scope is not in memory pool of ";
54508 0 : std::cout << p_scope->class_name() << std::endl;
54509 : }
54510 : }
54511 : else
54512 : {
54513 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54514 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
54515 0 : std::cout << " not valid " << std::endl;
54516 : }
54517 : }
54518 :
54519 0 : if ( p_type_syntax != NULL )
54520 : {
54521 0 : if ( p_type_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54522 : {
54523 0 : if ( p_type_syntax->isInMemoryPool() == false )
54524 : {
54525 0 : std::cout << "SgProgramHeaderStatement :: ";
54526 0 : std::cout << " p_type_syntax is not in memory pool of ";
54527 0 : std::cout << p_type_syntax->class_name() << std::endl;
54528 : }
54529 : }
54530 : else
54531 : {
54532 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54533 0 : std::cout << "SgFunctionType* p_type_syntax = " << p_type_syntax << " --> " << std::flush;
54534 0 : std::cout << " not valid " << std::endl;
54535 : }
54536 : }
54537 :
54538 0 : if ( p_parameterList_syntax != NULL )
54539 : {
54540 0 : if ( p_parameterList_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54541 : {
54542 0 : if ( p_parameterList_syntax->isInMemoryPool() == false )
54543 : {
54544 0 : std::cout << "SgProgramHeaderStatement :: ";
54545 0 : std::cout << " p_parameterList_syntax is not in memory pool of ";
54546 0 : std::cout << p_parameterList_syntax->class_name() << std::endl;
54547 : }
54548 : }
54549 : else
54550 : {
54551 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54552 0 : std::cout << "SgFunctionParameterList* p_parameterList_syntax = " << p_parameterList_syntax << " --> " << std::flush;
54553 0 : std::cout << " not valid " << std::endl;
54554 : }
54555 : }
54556 :
54557 0 : if ( p_functionParameterScope != NULL )
54558 : {
54559 0 : if ( p_functionParameterScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54560 : {
54561 0 : if ( p_functionParameterScope->isInMemoryPool() == false )
54562 : {
54563 0 : std::cout << "SgProgramHeaderStatement :: ";
54564 0 : std::cout << " p_functionParameterScope is not in memory pool of ";
54565 0 : std::cout << p_functionParameterScope->class_name() << std::endl;
54566 : }
54567 : }
54568 : else
54569 : {
54570 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54571 0 : std::cout << "SgFunctionParameterScope* p_functionParameterScope = " << p_functionParameterScope << " --> " << std::flush;
54572 0 : std::cout << " not valid " << std::endl;
54573 : }
54574 : }
54575 :
54576 0 : if ( p_definingDeclaration != NULL )
54577 : {
54578 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54579 : {
54580 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
54581 : {
54582 0 : std::cout << "SgProgramHeaderStatement :: ";
54583 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
54584 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
54585 : }
54586 : }
54587 : else
54588 : {
54589 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54590 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
54591 0 : std::cout << " not valid " << std::endl;
54592 : }
54593 : }
54594 :
54595 0 : if ( p_firstNondefiningDeclaration != NULL )
54596 : {
54597 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54598 : {
54599 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
54600 : {
54601 0 : std::cout << "SgProgramHeaderStatement :: ";
54602 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
54603 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
54604 : }
54605 : }
54606 : else
54607 : {
54608 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54609 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
54610 0 : std::cout << " not valid " << std::endl;
54611 : }
54612 : }
54613 :
54614 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
54615 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
54616 : {
54617 0 : if ( (*i_qualifiedNameList) != NULL )
54618 : {
54619 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54620 : {
54621 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
54622 : {
54623 0 : std::cout << "SgProgramHeaderStatement :: ";
54624 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
54625 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
54626 : }
54627 : }
54628 : else
54629 : {
54630 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54631 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
54632 0 : std::cout << " entry not valid " << std::endl;
54633 : }
54634 : }
54635 : else
54636 : {
54637 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
54638 : }
54639 : }
54640 :
54641 0 : if ( p_declarationScope != NULL )
54642 : {
54643 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54644 : {
54645 0 : if ( p_declarationScope->isInMemoryPool() == false )
54646 : {
54647 0 : std::cout << "SgProgramHeaderStatement :: ";
54648 0 : std::cout << " p_declarationScope is not in memory pool of ";
54649 0 : std::cout << p_declarationScope->class_name() << std::endl;
54650 : }
54651 : }
54652 : else
54653 : {
54654 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54655 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
54656 0 : std::cout << " not valid " << std::endl;
54657 : }
54658 : }
54659 :
54660 0 : if ( p_numeric_label != NULL )
54661 : {
54662 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54663 : {
54664 0 : if ( p_numeric_label->isInMemoryPool() == false )
54665 : {
54666 0 : std::cout << "SgProgramHeaderStatement :: ";
54667 0 : std::cout << " p_numeric_label is not in memory pool of ";
54668 0 : std::cout << p_numeric_label->class_name() << std::endl;
54669 : }
54670 : }
54671 : else
54672 : {
54673 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54674 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
54675 0 : std::cout << " not valid " << std::endl;
54676 : }
54677 : }
54678 :
54679 0 : if ( p_startOfConstruct != NULL )
54680 : {
54681 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54682 : {
54683 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
54684 : {
54685 0 : std::cout << "SgProgramHeaderStatement :: ";
54686 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
54687 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
54688 : }
54689 : }
54690 : else
54691 : {
54692 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54693 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
54694 0 : std::cout << " not valid " << std::endl;
54695 : }
54696 : }
54697 :
54698 0 : if ( p_endOfConstruct != NULL )
54699 : {
54700 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54701 : {
54702 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
54703 : {
54704 0 : std::cout << "SgProgramHeaderStatement :: ";
54705 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
54706 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
54707 : }
54708 : }
54709 : else
54710 : {
54711 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54712 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
54713 0 : std::cout << " not valid " << std::endl;
54714 : }
54715 : }
54716 :
54717 0 : if ( p_parent != NULL )
54718 : {
54719 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54720 : {
54721 0 : if ( p_parent->isInMemoryPool() == false )
54722 : {
54723 0 : std::cout << "SgProgramHeaderStatement :: ";
54724 0 : std::cout << " p_parent is not in memory pool of ";
54725 0 : std::cout << p_parent->class_name() << std::endl;
54726 : }
54727 : }
54728 : else
54729 : {
54730 0 : std::cout << "SgProgramHeaderStatement :: " << std::flush;
54731 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
54732 0 : std::cout << " not valid " << std::endl;
54733 : }
54734 : }
54735 :
54736 :
54737 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
54738 :
54739 0 : }
54740 :
54741 :
54742 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
54743 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
54744 : bool
54745 0 : SgProgramHeaderStatement::isInMemoryPool ()
54746 : {
54747 0 : typedef unsigned char* TestType;
54748 :
54749 0 : bool found = false;
54750 :
54751 0 : ROSE_ASSERT(this != NULL);
54752 :
54753 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
54754 :
54755 0 : TestType tested = (TestType) ( this ) ;
54756 :
54757 0 : std::vector < unsigned char* > :: const_iterator block = SgProgramHeaderStatement::pools.begin();
54758 :
54759 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
54760 : // while (found == false && block < Memory_Block_List.end())
54761 0 : while ( (found == false) && (block != SgProgramHeaderStatement::pools.end()) )
54762 : {
54763 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgProgramHeaderStatement::pool_size * sizeof(SgProgramHeaderStatement) ) ) ;
54764 0 : ++block;
54765 : }
54766 :
54767 : // Special handling for static data
54768 :
54769 :
54770 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
54771 0 : ROSE_ASSERT(found == true);
54772 :
54773 0 : return found;
54774 : }
54775 : /* #line 54776 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
54776 :
54777 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
54778 :
54779 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
54780 :
54781 : /* #line 54782 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
54782 :
54783 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
54784 :
54785 : void
54786 0 : SgProcedureHeaderStatement::checkDataMemberPointersIfInMemoryPool()
54787 : {
54788 : // ------------ checking pointers of SgProcedureHeaderStatement -------------------
54789 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
54790 :
54791 0 : if ( p_end_numeric_label != NULL )
54792 : {
54793 0 : if ( p_end_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54794 : {
54795 0 : if ( p_end_numeric_label->isInMemoryPool() == false )
54796 : {
54797 0 : std::cout << "SgProcedureHeaderStatement :: ";
54798 0 : std::cout << " p_end_numeric_label is not in memory pool of ";
54799 0 : std::cout << p_end_numeric_label->class_name() << std::endl;
54800 : }
54801 : }
54802 : else
54803 : {
54804 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
54805 0 : std::cout << "SgLabelRefExp* p_end_numeric_label = " << p_end_numeric_label << " --> " << std::flush;
54806 0 : std::cout << " not valid " << std::endl;
54807 : }
54808 : }
54809 :
54810 0 : if ( p_result_name != NULL )
54811 : {
54812 0 : if ( p_result_name->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54813 : {
54814 0 : if ( p_result_name->isInMemoryPool() == false )
54815 : {
54816 0 : std::cout << "SgProcedureHeaderStatement :: ";
54817 0 : std::cout << " p_result_name is not in memory pool of ";
54818 0 : std::cout << p_result_name->class_name() << std::endl;
54819 : }
54820 : }
54821 : else
54822 : {
54823 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
54824 0 : std::cout << "SgInitializedName* p_result_name = " << p_result_name << " --> " << std::flush;
54825 0 : std::cout << " not valid " << std::endl;
54826 : }
54827 : }
54828 :
54829 0 : if ( p_parameterList != NULL )
54830 : {
54831 0 : if ( p_parameterList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54832 : {
54833 0 : if ( p_parameterList->isInMemoryPool() == false )
54834 : {
54835 0 : std::cout << "SgProcedureHeaderStatement :: ";
54836 0 : std::cout << " p_parameterList is not in memory pool of ";
54837 0 : std::cout << p_parameterList->class_name() << std::endl;
54838 : }
54839 : }
54840 : else
54841 : {
54842 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
54843 0 : std::cout << "SgFunctionParameterList* p_parameterList = " << p_parameterList << " --> " << std::flush;
54844 0 : std::cout << " not valid " << std::endl;
54845 : }
54846 : }
54847 :
54848 0 : SgTypePtrList::iterator i_exceptionSpecification = p_exceptionSpecification.begin() ;
54849 0 : for ( ; i_exceptionSpecification != p_exceptionSpecification.end(); ++i_exceptionSpecification )
54850 : {
54851 0 : if ( (*i_exceptionSpecification) != NULL )
54852 : {
54853 0 : if ( (*i_exceptionSpecification)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54854 : {
54855 0 : if ( (*i_exceptionSpecification)->isInMemoryPool() == false )
54856 : {
54857 0 : std::cout << "SgProcedureHeaderStatement :: ";
54858 0 : std::cout << " p_exceptionSpecification ( list of poitners to IR nodes ), entry is not in memory pool of ";
54859 0 : std::cout << (*i_exceptionSpecification)->class_name() << std::endl;
54860 : }
54861 : }
54862 : else
54863 : {
54864 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
54865 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> " << std::flush;
54866 0 : std::cout << " entry not valid " << std::endl;
54867 : }
54868 : }
54869 : else
54870 : {
54871 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> NULL " << std::endl;
54872 : }
54873 : }
54874 :
54875 0 : if ( p_decoratorList != NULL )
54876 : {
54877 0 : if ( p_decoratorList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54878 : {
54879 0 : if ( p_decoratorList->isInMemoryPool() == false )
54880 : {
54881 0 : std::cout << "SgProcedureHeaderStatement :: ";
54882 0 : std::cout << " p_decoratorList is not in memory pool of ";
54883 0 : std::cout << p_decoratorList->class_name() << std::endl;
54884 : }
54885 : }
54886 : else
54887 : {
54888 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
54889 0 : std::cout << "SgExprListExp* p_decoratorList = " << p_decoratorList << " --> " << std::flush;
54890 0 : std::cout << " not valid " << std::endl;
54891 : }
54892 : }
54893 :
54894 0 : if ( p_type != NULL )
54895 : {
54896 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54897 : {
54898 0 : if ( p_type->isInMemoryPool() == false )
54899 : {
54900 0 : std::cout << "SgProcedureHeaderStatement :: ";
54901 0 : std::cout << " p_type is not in memory pool of ";
54902 0 : std::cout << p_type->class_name() << std::endl;
54903 : }
54904 : }
54905 : else
54906 : {
54907 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
54908 0 : std::cout << "SgFunctionType* p_type = " << p_type << " --> " << std::flush;
54909 0 : std::cout << " not valid " << std::endl;
54910 : }
54911 : }
54912 :
54913 0 : if ( p_definition != NULL )
54914 : {
54915 0 : if ( p_definition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54916 : {
54917 0 : if ( p_definition->isInMemoryPool() == false )
54918 : {
54919 0 : std::cout << "SgProcedureHeaderStatement :: ";
54920 0 : std::cout << " p_definition is not in memory pool of ";
54921 0 : std::cout << p_definition->class_name() << std::endl;
54922 : }
54923 : }
54924 : else
54925 : {
54926 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
54927 0 : std::cout << "SgFunctionDefinition* p_definition = " << p_definition << " --> " << std::flush;
54928 0 : std::cout << " not valid " << std::endl;
54929 : }
54930 : }
54931 :
54932 0 : if ( p_scope != NULL )
54933 : {
54934 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54935 : {
54936 0 : if ( p_scope->isInMemoryPool() == false )
54937 : {
54938 0 : std::cout << "SgProcedureHeaderStatement :: ";
54939 0 : std::cout << " p_scope is not in memory pool of ";
54940 0 : std::cout << p_scope->class_name() << std::endl;
54941 : }
54942 : }
54943 : else
54944 : {
54945 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
54946 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
54947 0 : std::cout << " not valid " << std::endl;
54948 : }
54949 : }
54950 :
54951 0 : if ( p_type_syntax != NULL )
54952 : {
54953 0 : if ( p_type_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54954 : {
54955 0 : if ( p_type_syntax->isInMemoryPool() == false )
54956 : {
54957 0 : std::cout << "SgProcedureHeaderStatement :: ";
54958 0 : std::cout << " p_type_syntax is not in memory pool of ";
54959 0 : std::cout << p_type_syntax->class_name() << std::endl;
54960 : }
54961 : }
54962 : else
54963 : {
54964 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
54965 0 : std::cout << "SgFunctionType* p_type_syntax = " << p_type_syntax << " --> " << std::flush;
54966 0 : std::cout << " not valid " << std::endl;
54967 : }
54968 : }
54969 :
54970 0 : if ( p_parameterList_syntax != NULL )
54971 : {
54972 0 : if ( p_parameterList_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54973 : {
54974 0 : if ( p_parameterList_syntax->isInMemoryPool() == false )
54975 : {
54976 0 : std::cout << "SgProcedureHeaderStatement :: ";
54977 0 : std::cout << " p_parameterList_syntax is not in memory pool of ";
54978 0 : std::cout << p_parameterList_syntax->class_name() << std::endl;
54979 : }
54980 : }
54981 : else
54982 : {
54983 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
54984 0 : std::cout << "SgFunctionParameterList* p_parameterList_syntax = " << p_parameterList_syntax << " --> " << std::flush;
54985 0 : std::cout << " not valid " << std::endl;
54986 : }
54987 : }
54988 :
54989 0 : if ( p_functionParameterScope != NULL )
54990 : {
54991 0 : if ( p_functionParameterScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
54992 : {
54993 0 : if ( p_functionParameterScope->isInMemoryPool() == false )
54994 : {
54995 0 : std::cout << "SgProcedureHeaderStatement :: ";
54996 0 : std::cout << " p_functionParameterScope is not in memory pool of ";
54997 0 : std::cout << p_functionParameterScope->class_name() << std::endl;
54998 : }
54999 : }
55000 : else
55001 : {
55002 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
55003 0 : std::cout << "SgFunctionParameterScope* p_functionParameterScope = " << p_functionParameterScope << " --> " << std::flush;
55004 0 : std::cout << " not valid " << std::endl;
55005 : }
55006 : }
55007 :
55008 0 : if ( p_definingDeclaration != NULL )
55009 : {
55010 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55011 : {
55012 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
55013 : {
55014 0 : std::cout << "SgProcedureHeaderStatement :: ";
55015 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
55016 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
55017 : }
55018 : }
55019 : else
55020 : {
55021 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
55022 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
55023 0 : std::cout << " not valid " << std::endl;
55024 : }
55025 : }
55026 :
55027 0 : if ( p_firstNondefiningDeclaration != NULL )
55028 : {
55029 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55030 : {
55031 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
55032 : {
55033 0 : std::cout << "SgProcedureHeaderStatement :: ";
55034 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
55035 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
55036 : }
55037 : }
55038 : else
55039 : {
55040 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
55041 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
55042 0 : std::cout << " not valid " << std::endl;
55043 : }
55044 : }
55045 :
55046 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
55047 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
55048 : {
55049 0 : if ( (*i_qualifiedNameList) != NULL )
55050 : {
55051 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55052 : {
55053 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
55054 : {
55055 0 : std::cout << "SgProcedureHeaderStatement :: ";
55056 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
55057 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
55058 : }
55059 : }
55060 : else
55061 : {
55062 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
55063 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
55064 0 : std::cout << " entry not valid " << std::endl;
55065 : }
55066 : }
55067 : else
55068 : {
55069 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
55070 : }
55071 : }
55072 :
55073 0 : if ( p_declarationScope != NULL )
55074 : {
55075 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55076 : {
55077 0 : if ( p_declarationScope->isInMemoryPool() == false )
55078 : {
55079 0 : std::cout << "SgProcedureHeaderStatement :: ";
55080 0 : std::cout << " p_declarationScope is not in memory pool of ";
55081 0 : std::cout << p_declarationScope->class_name() << std::endl;
55082 : }
55083 : }
55084 : else
55085 : {
55086 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
55087 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
55088 0 : std::cout << " not valid " << std::endl;
55089 : }
55090 : }
55091 :
55092 0 : if ( p_numeric_label != NULL )
55093 : {
55094 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55095 : {
55096 0 : if ( p_numeric_label->isInMemoryPool() == false )
55097 : {
55098 0 : std::cout << "SgProcedureHeaderStatement :: ";
55099 0 : std::cout << " p_numeric_label is not in memory pool of ";
55100 0 : std::cout << p_numeric_label->class_name() << std::endl;
55101 : }
55102 : }
55103 : else
55104 : {
55105 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
55106 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
55107 0 : std::cout << " not valid " << std::endl;
55108 : }
55109 : }
55110 :
55111 0 : if ( p_startOfConstruct != NULL )
55112 : {
55113 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55114 : {
55115 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
55116 : {
55117 0 : std::cout << "SgProcedureHeaderStatement :: ";
55118 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
55119 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
55120 : }
55121 : }
55122 : else
55123 : {
55124 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
55125 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
55126 0 : std::cout << " not valid " << std::endl;
55127 : }
55128 : }
55129 :
55130 0 : if ( p_endOfConstruct != NULL )
55131 : {
55132 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55133 : {
55134 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
55135 : {
55136 0 : std::cout << "SgProcedureHeaderStatement :: ";
55137 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
55138 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
55139 : }
55140 : }
55141 : else
55142 : {
55143 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
55144 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
55145 0 : std::cout << " not valid " << std::endl;
55146 : }
55147 : }
55148 :
55149 0 : if ( p_parent != NULL )
55150 : {
55151 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55152 : {
55153 0 : if ( p_parent->isInMemoryPool() == false )
55154 : {
55155 0 : std::cout << "SgProcedureHeaderStatement :: ";
55156 0 : std::cout << " p_parent is not in memory pool of ";
55157 0 : std::cout << p_parent->class_name() << std::endl;
55158 : }
55159 : }
55160 : else
55161 : {
55162 0 : std::cout << "SgProcedureHeaderStatement :: " << std::flush;
55163 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
55164 0 : std::cout << " not valid " << std::endl;
55165 : }
55166 : }
55167 :
55168 :
55169 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
55170 :
55171 0 : }
55172 :
55173 :
55174 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
55175 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
55176 : bool
55177 0 : SgProcedureHeaderStatement::isInMemoryPool ()
55178 : {
55179 0 : typedef unsigned char* TestType;
55180 :
55181 0 : bool found = false;
55182 :
55183 0 : ROSE_ASSERT(this != NULL);
55184 :
55185 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
55186 :
55187 0 : TestType tested = (TestType) ( this ) ;
55188 :
55189 0 : std::vector < unsigned char* > :: const_iterator block = SgProcedureHeaderStatement::pools.begin();
55190 :
55191 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
55192 : // while (found == false && block < Memory_Block_List.end())
55193 0 : while ( (found == false) && (block != SgProcedureHeaderStatement::pools.end()) )
55194 : {
55195 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgProcedureHeaderStatement::pool_size * sizeof(SgProcedureHeaderStatement) ) ) ;
55196 0 : ++block;
55197 : }
55198 :
55199 : // Special handling for static data
55200 :
55201 :
55202 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
55203 0 : ROSE_ASSERT(found == true);
55204 :
55205 0 : return found;
55206 : }
55207 : /* #line 55208 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
55208 :
55209 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
55210 :
55211 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
55212 :
55213 : /* #line 55214 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
55214 :
55215 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
55216 :
55217 : void
55218 0 : SgEntryStatement::checkDataMemberPointersIfInMemoryPool()
55219 : {
55220 : // ------------ checking pointers of SgEntryStatement -------------------
55221 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
55222 :
55223 0 : if ( p_result_name != NULL )
55224 : {
55225 0 : if ( p_result_name->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55226 : {
55227 0 : if ( p_result_name->isInMemoryPool() == false )
55228 : {
55229 0 : std::cout << "SgEntryStatement :: ";
55230 0 : std::cout << " p_result_name is not in memory pool of ";
55231 0 : std::cout << p_result_name->class_name() << std::endl;
55232 : }
55233 : }
55234 : else
55235 : {
55236 0 : std::cout << "SgEntryStatement :: " << std::flush;
55237 0 : std::cout << "SgInitializedName* p_result_name = " << p_result_name << " --> " << std::flush;
55238 0 : std::cout << " not valid " << std::endl;
55239 : }
55240 : }
55241 :
55242 0 : if ( p_parameterList != NULL )
55243 : {
55244 0 : if ( p_parameterList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55245 : {
55246 0 : if ( p_parameterList->isInMemoryPool() == false )
55247 : {
55248 0 : std::cout << "SgEntryStatement :: ";
55249 0 : std::cout << " p_parameterList is not in memory pool of ";
55250 0 : std::cout << p_parameterList->class_name() << std::endl;
55251 : }
55252 : }
55253 : else
55254 : {
55255 0 : std::cout << "SgEntryStatement :: " << std::flush;
55256 0 : std::cout << "SgFunctionParameterList* p_parameterList = " << p_parameterList << " --> " << std::flush;
55257 0 : std::cout << " not valid " << std::endl;
55258 : }
55259 : }
55260 :
55261 0 : SgTypePtrList::iterator i_exceptionSpecification = p_exceptionSpecification.begin() ;
55262 0 : for ( ; i_exceptionSpecification != p_exceptionSpecification.end(); ++i_exceptionSpecification )
55263 : {
55264 0 : if ( (*i_exceptionSpecification) != NULL )
55265 : {
55266 0 : if ( (*i_exceptionSpecification)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55267 : {
55268 0 : if ( (*i_exceptionSpecification)->isInMemoryPool() == false )
55269 : {
55270 0 : std::cout << "SgEntryStatement :: ";
55271 0 : std::cout << " p_exceptionSpecification ( list of poitners to IR nodes ), entry is not in memory pool of ";
55272 0 : std::cout << (*i_exceptionSpecification)->class_name() << std::endl;
55273 : }
55274 : }
55275 : else
55276 : {
55277 0 : std::cout << "SgEntryStatement :: " << std::flush;
55278 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> " << std::flush;
55279 0 : std::cout << " entry not valid " << std::endl;
55280 : }
55281 : }
55282 : else
55283 : {
55284 0 : std::cout << "SgTypePtrList p_exceptionSpecification --> NULL " << std::endl;
55285 : }
55286 : }
55287 :
55288 0 : if ( p_decoratorList != NULL )
55289 : {
55290 0 : if ( p_decoratorList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55291 : {
55292 0 : if ( p_decoratorList->isInMemoryPool() == false )
55293 : {
55294 0 : std::cout << "SgEntryStatement :: ";
55295 0 : std::cout << " p_decoratorList is not in memory pool of ";
55296 0 : std::cout << p_decoratorList->class_name() << std::endl;
55297 : }
55298 : }
55299 : else
55300 : {
55301 0 : std::cout << "SgEntryStatement :: " << std::flush;
55302 0 : std::cout << "SgExprListExp* p_decoratorList = " << p_decoratorList << " --> " << std::flush;
55303 0 : std::cout << " not valid " << std::endl;
55304 : }
55305 : }
55306 :
55307 0 : if ( p_type != NULL )
55308 : {
55309 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55310 : {
55311 0 : if ( p_type->isInMemoryPool() == false )
55312 : {
55313 0 : std::cout << "SgEntryStatement :: ";
55314 0 : std::cout << " p_type is not in memory pool of ";
55315 0 : std::cout << p_type->class_name() << std::endl;
55316 : }
55317 : }
55318 : else
55319 : {
55320 0 : std::cout << "SgEntryStatement :: " << std::flush;
55321 0 : std::cout << "SgFunctionType* p_type = " << p_type << " --> " << std::flush;
55322 0 : std::cout << " not valid " << std::endl;
55323 : }
55324 : }
55325 :
55326 0 : if ( p_definition != NULL )
55327 : {
55328 0 : if ( p_definition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55329 : {
55330 0 : if ( p_definition->isInMemoryPool() == false )
55331 : {
55332 0 : std::cout << "SgEntryStatement :: ";
55333 0 : std::cout << " p_definition is not in memory pool of ";
55334 0 : std::cout << p_definition->class_name() << std::endl;
55335 : }
55336 : }
55337 : else
55338 : {
55339 0 : std::cout << "SgEntryStatement :: " << std::flush;
55340 0 : std::cout << "SgFunctionDefinition* p_definition = " << p_definition << " --> " << std::flush;
55341 0 : std::cout << " not valid " << std::endl;
55342 : }
55343 : }
55344 :
55345 0 : if ( p_scope != NULL )
55346 : {
55347 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55348 : {
55349 0 : if ( p_scope->isInMemoryPool() == false )
55350 : {
55351 0 : std::cout << "SgEntryStatement :: ";
55352 0 : std::cout << " p_scope is not in memory pool of ";
55353 0 : std::cout << p_scope->class_name() << std::endl;
55354 : }
55355 : }
55356 : else
55357 : {
55358 0 : std::cout << "SgEntryStatement :: " << std::flush;
55359 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
55360 0 : std::cout << " not valid " << std::endl;
55361 : }
55362 : }
55363 :
55364 0 : if ( p_type_syntax != NULL )
55365 : {
55366 0 : if ( p_type_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55367 : {
55368 0 : if ( p_type_syntax->isInMemoryPool() == false )
55369 : {
55370 0 : std::cout << "SgEntryStatement :: ";
55371 0 : std::cout << " p_type_syntax is not in memory pool of ";
55372 0 : std::cout << p_type_syntax->class_name() << std::endl;
55373 : }
55374 : }
55375 : else
55376 : {
55377 0 : std::cout << "SgEntryStatement :: " << std::flush;
55378 0 : std::cout << "SgFunctionType* p_type_syntax = " << p_type_syntax << " --> " << std::flush;
55379 0 : std::cout << " not valid " << std::endl;
55380 : }
55381 : }
55382 :
55383 0 : if ( p_parameterList_syntax != NULL )
55384 : {
55385 0 : if ( p_parameterList_syntax->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55386 : {
55387 0 : if ( p_parameterList_syntax->isInMemoryPool() == false )
55388 : {
55389 0 : std::cout << "SgEntryStatement :: ";
55390 0 : std::cout << " p_parameterList_syntax is not in memory pool of ";
55391 0 : std::cout << p_parameterList_syntax->class_name() << std::endl;
55392 : }
55393 : }
55394 : else
55395 : {
55396 0 : std::cout << "SgEntryStatement :: " << std::flush;
55397 0 : std::cout << "SgFunctionParameterList* p_parameterList_syntax = " << p_parameterList_syntax << " --> " << std::flush;
55398 0 : std::cout << " not valid " << std::endl;
55399 : }
55400 : }
55401 :
55402 0 : if ( p_functionParameterScope != NULL )
55403 : {
55404 0 : if ( p_functionParameterScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55405 : {
55406 0 : if ( p_functionParameterScope->isInMemoryPool() == false )
55407 : {
55408 0 : std::cout << "SgEntryStatement :: ";
55409 0 : std::cout << " p_functionParameterScope is not in memory pool of ";
55410 0 : std::cout << p_functionParameterScope->class_name() << std::endl;
55411 : }
55412 : }
55413 : else
55414 : {
55415 0 : std::cout << "SgEntryStatement :: " << std::flush;
55416 0 : std::cout << "SgFunctionParameterScope* p_functionParameterScope = " << p_functionParameterScope << " --> " << std::flush;
55417 0 : std::cout << " not valid " << std::endl;
55418 : }
55419 : }
55420 :
55421 0 : if ( p_definingDeclaration != NULL )
55422 : {
55423 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55424 : {
55425 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
55426 : {
55427 0 : std::cout << "SgEntryStatement :: ";
55428 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
55429 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
55430 : }
55431 : }
55432 : else
55433 : {
55434 0 : std::cout << "SgEntryStatement :: " << std::flush;
55435 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
55436 0 : std::cout << " not valid " << std::endl;
55437 : }
55438 : }
55439 :
55440 0 : if ( p_firstNondefiningDeclaration != NULL )
55441 : {
55442 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55443 : {
55444 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
55445 : {
55446 0 : std::cout << "SgEntryStatement :: ";
55447 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
55448 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
55449 : }
55450 : }
55451 : else
55452 : {
55453 0 : std::cout << "SgEntryStatement :: " << std::flush;
55454 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
55455 0 : std::cout << " not valid " << std::endl;
55456 : }
55457 : }
55458 :
55459 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
55460 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
55461 : {
55462 0 : if ( (*i_qualifiedNameList) != NULL )
55463 : {
55464 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55465 : {
55466 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
55467 : {
55468 0 : std::cout << "SgEntryStatement :: ";
55469 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
55470 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
55471 : }
55472 : }
55473 : else
55474 : {
55475 0 : std::cout << "SgEntryStatement :: " << std::flush;
55476 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
55477 0 : std::cout << " entry not valid " << std::endl;
55478 : }
55479 : }
55480 : else
55481 : {
55482 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
55483 : }
55484 : }
55485 :
55486 0 : if ( p_declarationScope != NULL )
55487 : {
55488 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55489 : {
55490 0 : if ( p_declarationScope->isInMemoryPool() == false )
55491 : {
55492 0 : std::cout << "SgEntryStatement :: ";
55493 0 : std::cout << " p_declarationScope is not in memory pool of ";
55494 0 : std::cout << p_declarationScope->class_name() << std::endl;
55495 : }
55496 : }
55497 : else
55498 : {
55499 0 : std::cout << "SgEntryStatement :: " << std::flush;
55500 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
55501 0 : std::cout << " not valid " << std::endl;
55502 : }
55503 : }
55504 :
55505 0 : if ( p_numeric_label != NULL )
55506 : {
55507 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55508 : {
55509 0 : if ( p_numeric_label->isInMemoryPool() == false )
55510 : {
55511 0 : std::cout << "SgEntryStatement :: ";
55512 0 : std::cout << " p_numeric_label is not in memory pool of ";
55513 0 : std::cout << p_numeric_label->class_name() << std::endl;
55514 : }
55515 : }
55516 : else
55517 : {
55518 0 : std::cout << "SgEntryStatement :: " << std::flush;
55519 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
55520 0 : std::cout << " not valid " << std::endl;
55521 : }
55522 : }
55523 :
55524 0 : if ( p_startOfConstruct != NULL )
55525 : {
55526 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55527 : {
55528 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
55529 : {
55530 0 : std::cout << "SgEntryStatement :: ";
55531 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
55532 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
55533 : }
55534 : }
55535 : else
55536 : {
55537 0 : std::cout << "SgEntryStatement :: " << std::flush;
55538 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
55539 0 : std::cout << " not valid " << std::endl;
55540 : }
55541 : }
55542 :
55543 0 : if ( p_endOfConstruct != NULL )
55544 : {
55545 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55546 : {
55547 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
55548 : {
55549 0 : std::cout << "SgEntryStatement :: ";
55550 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
55551 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
55552 : }
55553 : }
55554 : else
55555 : {
55556 0 : std::cout << "SgEntryStatement :: " << std::flush;
55557 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
55558 0 : std::cout << " not valid " << std::endl;
55559 : }
55560 : }
55561 :
55562 0 : if ( p_parent != NULL )
55563 : {
55564 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55565 : {
55566 0 : if ( p_parent->isInMemoryPool() == false )
55567 : {
55568 0 : std::cout << "SgEntryStatement :: ";
55569 0 : std::cout << " p_parent is not in memory pool of ";
55570 0 : std::cout << p_parent->class_name() << std::endl;
55571 : }
55572 : }
55573 : else
55574 : {
55575 0 : std::cout << "SgEntryStatement :: " << std::flush;
55576 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
55577 0 : std::cout << " not valid " << std::endl;
55578 : }
55579 : }
55580 :
55581 :
55582 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
55583 :
55584 0 : }
55585 :
55586 :
55587 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
55588 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
55589 : bool
55590 0 : SgEntryStatement::isInMemoryPool ()
55591 : {
55592 0 : typedef unsigned char* TestType;
55593 :
55594 0 : bool found = false;
55595 :
55596 0 : ROSE_ASSERT(this != NULL);
55597 :
55598 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
55599 :
55600 0 : TestType tested = (TestType) ( this ) ;
55601 :
55602 0 : std::vector < unsigned char* > :: const_iterator block = SgEntryStatement::pools.begin();
55603 :
55604 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
55605 : // while (found == false && block < Memory_Block_List.end())
55606 0 : while ( (found == false) && (block != SgEntryStatement::pools.end()) )
55607 : {
55608 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgEntryStatement::pool_size * sizeof(SgEntryStatement) ) ) ;
55609 0 : ++block;
55610 : }
55611 :
55612 : // Special handling for static data
55613 :
55614 :
55615 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
55616 0 : ROSE_ASSERT(found == true);
55617 :
55618 0 : return found;
55619 : }
55620 : /* #line 55621 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
55621 :
55622 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
55623 :
55624 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
55625 :
55626 : /* #line 55627 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
55627 :
55628 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
55629 :
55630 : void
55631 0 : SgContainsStatement::checkDataMemberPointersIfInMemoryPool()
55632 : {
55633 : // ------------ checking pointers of SgContainsStatement -------------------
55634 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
55635 :
55636 0 : if ( p_definingDeclaration != NULL )
55637 : {
55638 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55639 : {
55640 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
55641 : {
55642 0 : std::cout << "SgContainsStatement :: ";
55643 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
55644 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
55645 : }
55646 : }
55647 : else
55648 : {
55649 0 : std::cout << "SgContainsStatement :: " << std::flush;
55650 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
55651 0 : std::cout << " not valid " << std::endl;
55652 : }
55653 : }
55654 :
55655 0 : if ( p_firstNondefiningDeclaration != NULL )
55656 : {
55657 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55658 : {
55659 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
55660 : {
55661 0 : std::cout << "SgContainsStatement :: ";
55662 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
55663 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
55664 : }
55665 : }
55666 : else
55667 : {
55668 0 : std::cout << "SgContainsStatement :: " << std::flush;
55669 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
55670 0 : std::cout << " not valid " << std::endl;
55671 : }
55672 : }
55673 :
55674 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
55675 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
55676 : {
55677 0 : if ( (*i_qualifiedNameList) != NULL )
55678 : {
55679 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55680 : {
55681 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
55682 : {
55683 0 : std::cout << "SgContainsStatement :: ";
55684 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
55685 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
55686 : }
55687 : }
55688 : else
55689 : {
55690 0 : std::cout << "SgContainsStatement :: " << std::flush;
55691 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
55692 0 : std::cout << " entry not valid " << std::endl;
55693 : }
55694 : }
55695 : else
55696 : {
55697 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
55698 : }
55699 : }
55700 :
55701 0 : if ( p_declarationScope != NULL )
55702 : {
55703 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55704 : {
55705 0 : if ( p_declarationScope->isInMemoryPool() == false )
55706 : {
55707 0 : std::cout << "SgContainsStatement :: ";
55708 0 : std::cout << " p_declarationScope is not in memory pool of ";
55709 0 : std::cout << p_declarationScope->class_name() << std::endl;
55710 : }
55711 : }
55712 : else
55713 : {
55714 0 : std::cout << "SgContainsStatement :: " << std::flush;
55715 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
55716 0 : std::cout << " not valid " << std::endl;
55717 : }
55718 : }
55719 :
55720 0 : if ( p_numeric_label != NULL )
55721 : {
55722 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55723 : {
55724 0 : if ( p_numeric_label->isInMemoryPool() == false )
55725 : {
55726 0 : std::cout << "SgContainsStatement :: ";
55727 0 : std::cout << " p_numeric_label is not in memory pool of ";
55728 0 : std::cout << p_numeric_label->class_name() << std::endl;
55729 : }
55730 : }
55731 : else
55732 : {
55733 0 : std::cout << "SgContainsStatement :: " << std::flush;
55734 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
55735 0 : std::cout << " not valid " << std::endl;
55736 : }
55737 : }
55738 :
55739 0 : if ( p_startOfConstruct != NULL )
55740 : {
55741 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55742 : {
55743 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
55744 : {
55745 0 : std::cout << "SgContainsStatement :: ";
55746 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
55747 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
55748 : }
55749 : }
55750 : else
55751 : {
55752 0 : std::cout << "SgContainsStatement :: " << std::flush;
55753 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
55754 0 : std::cout << " not valid " << std::endl;
55755 : }
55756 : }
55757 :
55758 0 : if ( p_endOfConstruct != NULL )
55759 : {
55760 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55761 : {
55762 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
55763 : {
55764 0 : std::cout << "SgContainsStatement :: ";
55765 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
55766 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
55767 : }
55768 : }
55769 : else
55770 : {
55771 0 : std::cout << "SgContainsStatement :: " << std::flush;
55772 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
55773 0 : std::cout << " not valid " << std::endl;
55774 : }
55775 : }
55776 :
55777 0 : if ( p_parent != NULL )
55778 : {
55779 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55780 : {
55781 0 : if ( p_parent->isInMemoryPool() == false )
55782 : {
55783 0 : std::cout << "SgContainsStatement :: ";
55784 0 : std::cout << " p_parent is not in memory pool of ";
55785 0 : std::cout << p_parent->class_name() << std::endl;
55786 : }
55787 : }
55788 : else
55789 : {
55790 0 : std::cout << "SgContainsStatement :: " << std::flush;
55791 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
55792 0 : std::cout << " not valid " << std::endl;
55793 : }
55794 : }
55795 :
55796 :
55797 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
55798 :
55799 0 : }
55800 :
55801 :
55802 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
55803 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
55804 : bool
55805 0 : SgContainsStatement::isInMemoryPool ()
55806 : {
55807 0 : typedef unsigned char* TestType;
55808 :
55809 0 : bool found = false;
55810 :
55811 0 : ROSE_ASSERT(this != NULL);
55812 :
55813 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
55814 :
55815 0 : TestType tested = (TestType) ( this ) ;
55816 :
55817 0 : std::vector < unsigned char* > :: const_iterator block = SgContainsStatement::pools.begin();
55818 :
55819 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
55820 : // while (found == false && block < Memory_Block_List.end())
55821 0 : while ( (found == false) && (block != SgContainsStatement::pools.end()) )
55822 : {
55823 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgContainsStatement::pool_size * sizeof(SgContainsStatement) ) ) ;
55824 0 : ++block;
55825 : }
55826 :
55827 : // Special handling for static data
55828 :
55829 :
55830 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
55831 0 : ROSE_ASSERT(found == true);
55832 :
55833 0 : return found;
55834 : }
55835 : /* #line 55836 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
55836 :
55837 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
55838 :
55839 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
55840 :
55841 : /* #line 55842 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
55842 :
55843 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
55844 :
55845 : void
55846 0 : SgC_PreprocessorDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
55847 : {
55848 : // ------------ checking pointers of SgC_PreprocessorDirectiveStatement -------------------
55849 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
55850 :
55851 0 : if ( p_definingDeclaration != NULL )
55852 : {
55853 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55854 : {
55855 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
55856 : {
55857 0 : std::cout << "SgC_PreprocessorDirectiveStatement :: ";
55858 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
55859 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
55860 : }
55861 : }
55862 : else
55863 : {
55864 0 : std::cout << "SgC_PreprocessorDirectiveStatement :: " << std::flush;
55865 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
55866 0 : std::cout << " not valid " << std::endl;
55867 : }
55868 : }
55869 :
55870 0 : if ( p_firstNondefiningDeclaration != NULL )
55871 : {
55872 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55873 : {
55874 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
55875 : {
55876 0 : std::cout << "SgC_PreprocessorDirectiveStatement :: ";
55877 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
55878 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
55879 : }
55880 : }
55881 : else
55882 : {
55883 0 : std::cout << "SgC_PreprocessorDirectiveStatement :: " << std::flush;
55884 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
55885 0 : std::cout << " not valid " << std::endl;
55886 : }
55887 : }
55888 :
55889 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
55890 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
55891 : {
55892 0 : if ( (*i_qualifiedNameList) != NULL )
55893 : {
55894 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55895 : {
55896 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
55897 : {
55898 0 : std::cout << "SgC_PreprocessorDirectiveStatement :: ";
55899 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
55900 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
55901 : }
55902 : }
55903 : else
55904 : {
55905 0 : std::cout << "SgC_PreprocessorDirectiveStatement :: " << std::flush;
55906 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
55907 0 : std::cout << " entry not valid " << std::endl;
55908 : }
55909 : }
55910 : else
55911 : {
55912 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
55913 : }
55914 : }
55915 :
55916 0 : if ( p_declarationScope != NULL )
55917 : {
55918 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55919 : {
55920 0 : if ( p_declarationScope->isInMemoryPool() == false )
55921 : {
55922 0 : std::cout << "SgC_PreprocessorDirectiveStatement :: ";
55923 0 : std::cout << " p_declarationScope is not in memory pool of ";
55924 0 : std::cout << p_declarationScope->class_name() << std::endl;
55925 : }
55926 : }
55927 : else
55928 : {
55929 0 : std::cout << "SgC_PreprocessorDirectiveStatement :: " << std::flush;
55930 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
55931 0 : std::cout << " not valid " << std::endl;
55932 : }
55933 : }
55934 :
55935 0 : if ( p_numeric_label != NULL )
55936 : {
55937 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55938 : {
55939 0 : if ( p_numeric_label->isInMemoryPool() == false )
55940 : {
55941 0 : std::cout << "SgC_PreprocessorDirectiveStatement :: ";
55942 0 : std::cout << " p_numeric_label is not in memory pool of ";
55943 0 : std::cout << p_numeric_label->class_name() << std::endl;
55944 : }
55945 : }
55946 : else
55947 : {
55948 0 : std::cout << "SgC_PreprocessorDirectiveStatement :: " << std::flush;
55949 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
55950 0 : std::cout << " not valid " << std::endl;
55951 : }
55952 : }
55953 :
55954 0 : if ( p_startOfConstruct != NULL )
55955 : {
55956 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55957 : {
55958 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
55959 : {
55960 0 : std::cout << "SgC_PreprocessorDirectiveStatement :: ";
55961 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
55962 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
55963 : }
55964 : }
55965 : else
55966 : {
55967 0 : std::cout << "SgC_PreprocessorDirectiveStatement :: " << std::flush;
55968 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
55969 0 : std::cout << " not valid " << std::endl;
55970 : }
55971 : }
55972 :
55973 0 : if ( p_endOfConstruct != NULL )
55974 : {
55975 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55976 : {
55977 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
55978 : {
55979 0 : std::cout << "SgC_PreprocessorDirectiveStatement :: ";
55980 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
55981 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
55982 : }
55983 : }
55984 : else
55985 : {
55986 0 : std::cout << "SgC_PreprocessorDirectiveStatement :: " << std::flush;
55987 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
55988 0 : std::cout << " not valid " << std::endl;
55989 : }
55990 : }
55991 :
55992 0 : if ( p_parent != NULL )
55993 : {
55994 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
55995 : {
55996 0 : if ( p_parent->isInMemoryPool() == false )
55997 : {
55998 0 : std::cout << "SgC_PreprocessorDirectiveStatement :: ";
55999 0 : std::cout << " p_parent is not in memory pool of ";
56000 0 : std::cout << p_parent->class_name() << std::endl;
56001 : }
56002 : }
56003 : else
56004 : {
56005 0 : std::cout << "SgC_PreprocessorDirectiveStatement :: " << std::flush;
56006 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
56007 0 : std::cout << " not valid " << std::endl;
56008 : }
56009 : }
56010 :
56011 :
56012 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
56013 :
56014 0 : }
56015 :
56016 :
56017 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
56018 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
56019 : bool
56020 0 : SgC_PreprocessorDirectiveStatement::isInMemoryPool ()
56021 : {
56022 0 : typedef unsigned char* TestType;
56023 :
56024 0 : bool found = false;
56025 :
56026 0 : ROSE_ASSERT(this != NULL);
56027 :
56028 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
56029 :
56030 0 : TestType tested = (TestType) ( this ) ;
56031 :
56032 0 : std::vector < unsigned char* > :: const_iterator block = SgC_PreprocessorDirectiveStatement::pools.begin();
56033 :
56034 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
56035 : // while (found == false && block < Memory_Block_List.end())
56036 0 : while ( (found == false) && (block != SgC_PreprocessorDirectiveStatement::pools.end()) )
56037 : {
56038 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgC_PreprocessorDirectiveStatement::pool_size * sizeof(SgC_PreprocessorDirectiveStatement) ) ) ;
56039 0 : ++block;
56040 : }
56041 :
56042 : // Special handling for static data
56043 :
56044 :
56045 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
56046 0 : ROSE_ASSERT(found == true);
56047 :
56048 0 : return found;
56049 : }
56050 : /* #line 56051 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
56051 :
56052 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
56053 :
56054 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
56055 :
56056 : /* #line 56057 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
56057 :
56058 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
56059 :
56060 : void
56061 0 : SgIncludeDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
56062 : {
56063 : // ------------ checking pointers of SgIncludeDirectiveStatement -------------------
56064 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
56065 :
56066 0 : if ( p_headerFileBody != NULL )
56067 : {
56068 0 : if ( p_headerFileBody->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56069 : {
56070 0 : if ( p_headerFileBody->isInMemoryPool() == false )
56071 : {
56072 0 : std::cout << "SgIncludeDirectiveStatement :: ";
56073 0 : std::cout << " p_headerFileBody is not in memory pool of ";
56074 0 : std::cout << p_headerFileBody->class_name() << std::endl;
56075 : }
56076 : }
56077 : else
56078 : {
56079 0 : std::cout << "SgIncludeDirectiveStatement :: " << std::flush;
56080 0 : std::cout << "SgHeaderFileBody* p_headerFileBody = " << p_headerFileBody << " --> " << std::flush;
56081 0 : std::cout << " not valid " << std::endl;
56082 : }
56083 : }
56084 :
56085 0 : if ( p_include_file_heirarchy != NULL )
56086 : {
56087 0 : if ( p_include_file_heirarchy->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56088 : {
56089 0 : if ( p_include_file_heirarchy->isInMemoryPool() == false )
56090 : {
56091 0 : std::cout << "SgIncludeDirectiveStatement :: ";
56092 0 : std::cout << " p_include_file_heirarchy is not in memory pool of ";
56093 0 : std::cout << p_include_file_heirarchy->class_name() << std::endl;
56094 : }
56095 : }
56096 : else
56097 : {
56098 0 : std::cout << "SgIncludeDirectiveStatement :: " << std::flush;
56099 0 : std::cout << "SgIncludeFile* p_include_file_heirarchy = " << p_include_file_heirarchy << " --> " << std::flush;
56100 0 : std::cout << " not valid " << std::endl;
56101 : }
56102 : }
56103 :
56104 0 : if ( p_definingDeclaration != NULL )
56105 : {
56106 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56107 : {
56108 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
56109 : {
56110 0 : std::cout << "SgIncludeDirectiveStatement :: ";
56111 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
56112 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
56113 : }
56114 : }
56115 : else
56116 : {
56117 0 : std::cout << "SgIncludeDirectiveStatement :: " << std::flush;
56118 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
56119 0 : std::cout << " not valid " << std::endl;
56120 : }
56121 : }
56122 :
56123 0 : if ( p_firstNondefiningDeclaration != NULL )
56124 : {
56125 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56126 : {
56127 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
56128 : {
56129 0 : std::cout << "SgIncludeDirectiveStatement :: ";
56130 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
56131 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
56132 : }
56133 : }
56134 : else
56135 : {
56136 0 : std::cout << "SgIncludeDirectiveStatement :: " << std::flush;
56137 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
56138 0 : std::cout << " not valid " << std::endl;
56139 : }
56140 : }
56141 :
56142 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
56143 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
56144 : {
56145 0 : if ( (*i_qualifiedNameList) != NULL )
56146 : {
56147 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56148 : {
56149 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
56150 : {
56151 0 : std::cout << "SgIncludeDirectiveStatement :: ";
56152 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
56153 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
56154 : }
56155 : }
56156 : else
56157 : {
56158 0 : std::cout << "SgIncludeDirectiveStatement :: " << std::flush;
56159 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
56160 0 : std::cout << " entry not valid " << std::endl;
56161 : }
56162 : }
56163 : else
56164 : {
56165 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
56166 : }
56167 : }
56168 :
56169 0 : if ( p_declarationScope != NULL )
56170 : {
56171 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56172 : {
56173 0 : if ( p_declarationScope->isInMemoryPool() == false )
56174 : {
56175 0 : std::cout << "SgIncludeDirectiveStatement :: ";
56176 0 : std::cout << " p_declarationScope is not in memory pool of ";
56177 0 : std::cout << p_declarationScope->class_name() << std::endl;
56178 : }
56179 : }
56180 : else
56181 : {
56182 0 : std::cout << "SgIncludeDirectiveStatement :: " << std::flush;
56183 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
56184 0 : std::cout << " not valid " << std::endl;
56185 : }
56186 : }
56187 :
56188 0 : if ( p_numeric_label != NULL )
56189 : {
56190 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56191 : {
56192 0 : if ( p_numeric_label->isInMemoryPool() == false )
56193 : {
56194 0 : std::cout << "SgIncludeDirectiveStatement :: ";
56195 0 : std::cout << " p_numeric_label is not in memory pool of ";
56196 0 : std::cout << p_numeric_label->class_name() << std::endl;
56197 : }
56198 : }
56199 : else
56200 : {
56201 0 : std::cout << "SgIncludeDirectiveStatement :: " << std::flush;
56202 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
56203 0 : std::cout << " not valid " << std::endl;
56204 : }
56205 : }
56206 :
56207 0 : if ( p_startOfConstruct != NULL )
56208 : {
56209 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56210 : {
56211 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
56212 : {
56213 0 : std::cout << "SgIncludeDirectiveStatement :: ";
56214 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
56215 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
56216 : }
56217 : }
56218 : else
56219 : {
56220 0 : std::cout << "SgIncludeDirectiveStatement :: " << std::flush;
56221 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
56222 0 : std::cout << " not valid " << std::endl;
56223 : }
56224 : }
56225 :
56226 0 : if ( p_endOfConstruct != NULL )
56227 : {
56228 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56229 : {
56230 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
56231 : {
56232 0 : std::cout << "SgIncludeDirectiveStatement :: ";
56233 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
56234 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
56235 : }
56236 : }
56237 : else
56238 : {
56239 0 : std::cout << "SgIncludeDirectiveStatement :: " << std::flush;
56240 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
56241 0 : std::cout << " not valid " << std::endl;
56242 : }
56243 : }
56244 :
56245 0 : if ( p_parent != NULL )
56246 : {
56247 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56248 : {
56249 0 : if ( p_parent->isInMemoryPool() == false )
56250 : {
56251 0 : std::cout << "SgIncludeDirectiveStatement :: ";
56252 0 : std::cout << " p_parent is not in memory pool of ";
56253 0 : std::cout << p_parent->class_name() << std::endl;
56254 : }
56255 : }
56256 : else
56257 : {
56258 0 : std::cout << "SgIncludeDirectiveStatement :: " << std::flush;
56259 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
56260 0 : std::cout << " not valid " << std::endl;
56261 : }
56262 : }
56263 :
56264 :
56265 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
56266 :
56267 0 : }
56268 :
56269 :
56270 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
56271 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
56272 : bool
56273 0 : SgIncludeDirectiveStatement::isInMemoryPool ()
56274 : {
56275 0 : typedef unsigned char* TestType;
56276 :
56277 0 : bool found = false;
56278 :
56279 0 : ROSE_ASSERT(this != NULL);
56280 :
56281 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
56282 :
56283 0 : TestType tested = (TestType) ( this ) ;
56284 :
56285 0 : std::vector < unsigned char* > :: const_iterator block = SgIncludeDirectiveStatement::pools.begin();
56286 :
56287 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
56288 : // while (found == false && block < Memory_Block_List.end())
56289 0 : while ( (found == false) && (block != SgIncludeDirectiveStatement::pools.end()) )
56290 : {
56291 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIncludeDirectiveStatement::pool_size * sizeof(SgIncludeDirectiveStatement) ) ) ;
56292 0 : ++block;
56293 : }
56294 :
56295 : // Special handling for static data
56296 :
56297 :
56298 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
56299 0 : ROSE_ASSERT(found == true);
56300 :
56301 0 : return found;
56302 : }
56303 : /* #line 56304 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
56304 :
56305 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
56306 :
56307 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
56308 :
56309 : /* #line 56310 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
56310 :
56311 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
56312 :
56313 : void
56314 0 : SgDefineDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
56315 : {
56316 : // ------------ checking pointers of SgDefineDirectiveStatement -------------------
56317 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
56318 :
56319 0 : if ( p_definingDeclaration != NULL )
56320 : {
56321 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56322 : {
56323 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
56324 : {
56325 0 : std::cout << "SgDefineDirectiveStatement :: ";
56326 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
56327 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
56328 : }
56329 : }
56330 : else
56331 : {
56332 0 : std::cout << "SgDefineDirectiveStatement :: " << std::flush;
56333 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
56334 0 : std::cout << " not valid " << std::endl;
56335 : }
56336 : }
56337 :
56338 0 : if ( p_firstNondefiningDeclaration != NULL )
56339 : {
56340 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56341 : {
56342 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
56343 : {
56344 0 : std::cout << "SgDefineDirectiveStatement :: ";
56345 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
56346 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
56347 : }
56348 : }
56349 : else
56350 : {
56351 0 : std::cout << "SgDefineDirectiveStatement :: " << std::flush;
56352 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
56353 0 : std::cout << " not valid " << std::endl;
56354 : }
56355 : }
56356 :
56357 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
56358 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
56359 : {
56360 0 : if ( (*i_qualifiedNameList) != NULL )
56361 : {
56362 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56363 : {
56364 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
56365 : {
56366 0 : std::cout << "SgDefineDirectiveStatement :: ";
56367 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
56368 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
56369 : }
56370 : }
56371 : else
56372 : {
56373 0 : std::cout << "SgDefineDirectiveStatement :: " << std::flush;
56374 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
56375 0 : std::cout << " entry not valid " << std::endl;
56376 : }
56377 : }
56378 : else
56379 : {
56380 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
56381 : }
56382 : }
56383 :
56384 0 : if ( p_declarationScope != NULL )
56385 : {
56386 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56387 : {
56388 0 : if ( p_declarationScope->isInMemoryPool() == false )
56389 : {
56390 0 : std::cout << "SgDefineDirectiveStatement :: ";
56391 0 : std::cout << " p_declarationScope is not in memory pool of ";
56392 0 : std::cout << p_declarationScope->class_name() << std::endl;
56393 : }
56394 : }
56395 : else
56396 : {
56397 0 : std::cout << "SgDefineDirectiveStatement :: " << std::flush;
56398 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
56399 0 : std::cout << " not valid " << std::endl;
56400 : }
56401 : }
56402 :
56403 0 : if ( p_numeric_label != NULL )
56404 : {
56405 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56406 : {
56407 0 : if ( p_numeric_label->isInMemoryPool() == false )
56408 : {
56409 0 : std::cout << "SgDefineDirectiveStatement :: ";
56410 0 : std::cout << " p_numeric_label is not in memory pool of ";
56411 0 : std::cout << p_numeric_label->class_name() << std::endl;
56412 : }
56413 : }
56414 : else
56415 : {
56416 0 : std::cout << "SgDefineDirectiveStatement :: " << std::flush;
56417 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
56418 0 : std::cout << " not valid " << std::endl;
56419 : }
56420 : }
56421 :
56422 0 : if ( p_startOfConstruct != NULL )
56423 : {
56424 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56425 : {
56426 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
56427 : {
56428 0 : std::cout << "SgDefineDirectiveStatement :: ";
56429 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
56430 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
56431 : }
56432 : }
56433 : else
56434 : {
56435 0 : std::cout << "SgDefineDirectiveStatement :: " << std::flush;
56436 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
56437 0 : std::cout << " not valid " << std::endl;
56438 : }
56439 : }
56440 :
56441 0 : if ( p_endOfConstruct != NULL )
56442 : {
56443 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56444 : {
56445 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
56446 : {
56447 0 : std::cout << "SgDefineDirectiveStatement :: ";
56448 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
56449 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
56450 : }
56451 : }
56452 : else
56453 : {
56454 0 : std::cout << "SgDefineDirectiveStatement :: " << std::flush;
56455 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
56456 0 : std::cout << " not valid " << std::endl;
56457 : }
56458 : }
56459 :
56460 0 : if ( p_parent != NULL )
56461 : {
56462 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56463 : {
56464 0 : if ( p_parent->isInMemoryPool() == false )
56465 : {
56466 0 : std::cout << "SgDefineDirectiveStatement :: ";
56467 0 : std::cout << " p_parent is not in memory pool of ";
56468 0 : std::cout << p_parent->class_name() << std::endl;
56469 : }
56470 : }
56471 : else
56472 : {
56473 0 : std::cout << "SgDefineDirectiveStatement :: " << std::flush;
56474 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
56475 0 : std::cout << " not valid " << std::endl;
56476 : }
56477 : }
56478 :
56479 :
56480 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
56481 :
56482 0 : }
56483 :
56484 :
56485 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
56486 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
56487 : bool
56488 0 : SgDefineDirectiveStatement::isInMemoryPool ()
56489 : {
56490 0 : typedef unsigned char* TestType;
56491 :
56492 0 : bool found = false;
56493 :
56494 0 : ROSE_ASSERT(this != NULL);
56495 :
56496 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
56497 :
56498 0 : TestType tested = (TestType) ( this ) ;
56499 :
56500 0 : std::vector < unsigned char* > :: const_iterator block = SgDefineDirectiveStatement::pools.begin();
56501 :
56502 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
56503 : // while (found == false && block < Memory_Block_List.end())
56504 0 : while ( (found == false) && (block != SgDefineDirectiveStatement::pools.end()) )
56505 : {
56506 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDefineDirectiveStatement::pool_size * sizeof(SgDefineDirectiveStatement) ) ) ;
56507 0 : ++block;
56508 : }
56509 :
56510 : // Special handling for static data
56511 :
56512 :
56513 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
56514 0 : ROSE_ASSERT(found == true);
56515 :
56516 0 : return found;
56517 : }
56518 : /* #line 56519 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
56519 :
56520 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
56521 :
56522 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
56523 :
56524 : /* #line 56525 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
56525 :
56526 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
56527 :
56528 : void
56529 0 : SgUndefDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
56530 : {
56531 : // ------------ checking pointers of SgUndefDirectiveStatement -------------------
56532 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
56533 :
56534 0 : if ( p_definingDeclaration != NULL )
56535 : {
56536 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56537 : {
56538 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
56539 : {
56540 0 : std::cout << "SgUndefDirectiveStatement :: ";
56541 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
56542 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
56543 : }
56544 : }
56545 : else
56546 : {
56547 0 : std::cout << "SgUndefDirectiveStatement :: " << std::flush;
56548 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
56549 0 : std::cout << " not valid " << std::endl;
56550 : }
56551 : }
56552 :
56553 0 : if ( p_firstNondefiningDeclaration != NULL )
56554 : {
56555 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56556 : {
56557 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
56558 : {
56559 0 : std::cout << "SgUndefDirectiveStatement :: ";
56560 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
56561 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
56562 : }
56563 : }
56564 : else
56565 : {
56566 0 : std::cout << "SgUndefDirectiveStatement :: " << std::flush;
56567 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
56568 0 : std::cout << " not valid " << std::endl;
56569 : }
56570 : }
56571 :
56572 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
56573 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
56574 : {
56575 0 : if ( (*i_qualifiedNameList) != NULL )
56576 : {
56577 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56578 : {
56579 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
56580 : {
56581 0 : std::cout << "SgUndefDirectiveStatement :: ";
56582 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
56583 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
56584 : }
56585 : }
56586 : else
56587 : {
56588 0 : std::cout << "SgUndefDirectiveStatement :: " << std::flush;
56589 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
56590 0 : std::cout << " entry not valid " << std::endl;
56591 : }
56592 : }
56593 : else
56594 : {
56595 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
56596 : }
56597 : }
56598 :
56599 0 : if ( p_declarationScope != NULL )
56600 : {
56601 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56602 : {
56603 0 : if ( p_declarationScope->isInMemoryPool() == false )
56604 : {
56605 0 : std::cout << "SgUndefDirectiveStatement :: ";
56606 0 : std::cout << " p_declarationScope is not in memory pool of ";
56607 0 : std::cout << p_declarationScope->class_name() << std::endl;
56608 : }
56609 : }
56610 : else
56611 : {
56612 0 : std::cout << "SgUndefDirectiveStatement :: " << std::flush;
56613 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
56614 0 : std::cout << " not valid " << std::endl;
56615 : }
56616 : }
56617 :
56618 0 : if ( p_numeric_label != NULL )
56619 : {
56620 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56621 : {
56622 0 : if ( p_numeric_label->isInMemoryPool() == false )
56623 : {
56624 0 : std::cout << "SgUndefDirectiveStatement :: ";
56625 0 : std::cout << " p_numeric_label is not in memory pool of ";
56626 0 : std::cout << p_numeric_label->class_name() << std::endl;
56627 : }
56628 : }
56629 : else
56630 : {
56631 0 : std::cout << "SgUndefDirectiveStatement :: " << std::flush;
56632 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
56633 0 : std::cout << " not valid " << std::endl;
56634 : }
56635 : }
56636 :
56637 0 : if ( p_startOfConstruct != NULL )
56638 : {
56639 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56640 : {
56641 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
56642 : {
56643 0 : std::cout << "SgUndefDirectiveStatement :: ";
56644 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
56645 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
56646 : }
56647 : }
56648 : else
56649 : {
56650 0 : std::cout << "SgUndefDirectiveStatement :: " << std::flush;
56651 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
56652 0 : std::cout << " not valid " << std::endl;
56653 : }
56654 : }
56655 :
56656 0 : if ( p_endOfConstruct != NULL )
56657 : {
56658 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56659 : {
56660 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
56661 : {
56662 0 : std::cout << "SgUndefDirectiveStatement :: ";
56663 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
56664 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
56665 : }
56666 : }
56667 : else
56668 : {
56669 0 : std::cout << "SgUndefDirectiveStatement :: " << std::flush;
56670 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
56671 0 : std::cout << " not valid " << std::endl;
56672 : }
56673 : }
56674 :
56675 0 : if ( p_parent != NULL )
56676 : {
56677 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56678 : {
56679 0 : if ( p_parent->isInMemoryPool() == false )
56680 : {
56681 0 : std::cout << "SgUndefDirectiveStatement :: ";
56682 0 : std::cout << " p_parent is not in memory pool of ";
56683 0 : std::cout << p_parent->class_name() << std::endl;
56684 : }
56685 : }
56686 : else
56687 : {
56688 0 : std::cout << "SgUndefDirectiveStatement :: " << std::flush;
56689 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
56690 0 : std::cout << " not valid " << std::endl;
56691 : }
56692 : }
56693 :
56694 :
56695 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
56696 :
56697 0 : }
56698 :
56699 :
56700 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
56701 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
56702 : bool
56703 0 : SgUndefDirectiveStatement::isInMemoryPool ()
56704 : {
56705 0 : typedef unsigned char* TestType;
56706 :
56707 0 : bool found = false;
56708 :
56709 0 : ROSE_ASSERT(this != NULL);
56710 :
56711 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
56712 :
56713 0 : TestType tested = (TestType) ( this ) ;
56714 :
56715 0 : std::vector < unsigned char* > :: const_iterator block = SgUndefDirectiveStatement::pools.begin();
56716 :
56717 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
56718 : // while (found == false && block < Memory_Block_List.end())
56719 0 : while ( (found == false) && (block != SgUndefDirectiveStatement::pools.end()) )
56720 : {
56721 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUndefDirectiveStatement::pool_size * sizeof(SgUndefDirectiveStatement) ) ) ;
56722 0 : ++block;
56723 : }
56724 :
56725 : // Special handling for static data
56726 :
56727 :
56728 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
56729 0 : ROSE_ASSERT(found == true);
56730 :
56731 0 : return found;
56732 : }
56733 : /* #line 56734 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
56734 :
56735 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
56736 :
56737 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
56738 :
56739 : /* #line 56740 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
56740 :
56741 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
56742 :
56743 : void
56744 0 : SgIfdefDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
56745 : {
56746 : // ------------ checking pointers of SgIfdefDirectiveStatement -------------------
56747 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
56748 :
56749 0 : if ( p_definingDeclaration != NULL )
56750 : {
56751 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56752 : {
56753 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
56754 : {
56755 0 : std::cout << "SgIfdefDirectiveStatement :: ";
56756 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
56757 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
56758 : }
56759 : }
56760 : else
56761 : {
56762 0 : std::cout << "SgIfdefDirectiveStatement :: " << std::flush;
56763 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
56764 0 : std::cout << " not valid " << std::endl;
56765 : }
56766 : }
56767 :
56768 0 : if ( p_firstNondefiningDeclaration != NULL )
56769 : {
56770 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56771 : {
56772 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
56773 : {
56774 0 : std::cout << "SgIfdefDirectiveStatement :: ";
56775 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
56776 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
56777 : }
56778 : }
56779 : else
56780 : {
56781 0 : std::cout << "SgIfdefDirectiveStatement :: " << std::flush;
56782 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
56783 0 : std::cout << " not valid " << std::endl;
56784 : }
56785 : }
56786 :
56787 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
56788 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
56789 : {
56790 0 : if ( (*i_qualifiedNameList) != NULL )
56791 : {
56792 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56793 : {
56794 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
56795 : {
56796 0 : std::cout << "SgIfdefDirectiveStatement :: ";
56797 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
56798 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
56799 : }
56800 : }
56801 : else
56802 : {
56803 0 : std::cout << "SgIfdefDirectiveStatement :: " << std::flush;
56804 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
56805 0 : std::cout << " entry not valid " << std::endl;
56806 : }
56807 : }
56808 : else
56809 : {
56810 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
56811 : }
56812 : }
56813 :
56814 0 : if ( p_declarationScope != NULL )
56815 : {
56816 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56817 : {
56818 0 : if ( p_declarationScope->isInMemoryPool() == false )
56819 : {
56820 0 : std::cout << "SgIfdefDirectiveStatement :: ";
56821 0 : std::cout << " p_declarationScope is not in memory pool of ";
56822 0 : std::cout << p_declarationScope->class_name() << std::endl;
56823 : }
56824 : }
56825 : else
56826 : {
56827 0 : std::cout << "SgIfdefDirectiveStatement :: " << std::flush;
56828 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
56829 0 : std::cout << " not valid " << std::endl;
56830 : }
56831 : }
56832 :
56833 0 : if ( p_numeric_label != NULL )
56834 : {
56835 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56836 : {
56837 0 : if ( p_numeric_label->isInMemoryPool() == false )
56838 : {
56839 0 : std::cout << "SgIfdefDirectiveStatement :: ";
56840 0 : std::cout << " p_numeric_label is not in memory pool of ";
56841 0 : std::cout << p_numeric_label->class_name() << std::endl;
56842 : }
56843 : }
56844 : else
56845 : {
56846 0 : std::cout << "SgIfdefDirectiveStatement :: " << std::flush;
56847 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
56848 0 : std::cout << " not valid " << std::endl;
56849 : }
56850 : }
56851 :
56852 0 : if ( p_startOfConstruct != NULL )
56853 : {
56854 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56855 : {
56856 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
56857 : {
56858 0 : std::cout << "SgIfdefDirectiveStatement :: ";
56859 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
56860 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
56861 : }
56862 : }
56863 : else
56864 : {
56865 0 : std::cout << "SgIfdefDirectiveStatement :: " << std::flush;
56866 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
56867 0 : std::cout << " not valid " << std::endl;
56868 : }
56869 : }
56870 :
56871 0 : if ( p_endOfConstruct != NULL )
56872 : {
56873 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56874 : {
56875 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
56876 : {
56877 0 : std::cout << "SgIfdefDirectiveStatement :: ";
56878 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
56879 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
56880 : }
56881 : }
56882 : else
56883 : {
56884 0 : std::cout << "SgIfdefDirectiveStatement :: " << std::flush;
56885 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
56886 0 : std::cout << " not valid " << std::endl;
56887 : }
56888 : }
56889 :
56890 0 : if ( p_parent != NULL )
56891 : {
56892 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56893 : {
56894 0 : if ( p_parent->isInMemoryPool() == false )
56895 : {
56896 0 : std::cout << "SgIfdefDirectiveStatement :: ";
56897 0 : std::cout << " p_parent is not in memory pool of ";
56898 0 : std::cout << p_parent->class_name() << std::endl;
56899 : }
56900 : }
56901 : else
56902 : {
56903 0 : std::cout << "SgIfdefDirectiveStatement :: " << std::flush;
56904 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
56905 0 : std::cout << " not valid " << std::endl;
56906 : }
56907 : }
56908 :
56909 :
56910 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
56911 :
56912 0 : }
56913 :
56914 :
56915 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
56916 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
56917 : bool
56918 0 : SgIfdefDirectiveStatement::isInMemoryPool ()
56919 : {
56920 0 : typedef unsigned char* TestType;
56921 :
56922 0 : bool found = false;
56923 :
56924 0 : ROSE_ASSERT(this != NULL);
56925 :
56926 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
56927 :
56928 0 : TestType tested = (TestType) ( this ) ;
56929 :
56930 0 : std::vector < unsigned char* > :: const_iterator block = SgIfdefDirectiveStatement::pools.begin();
56931 :
56932 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
56933 : // while (found == false && block < Memory_Block_List.end())
56934 0 : while ( (found == false) && (block != SgIfdefDirectiveStatement::pools.end()) )
56935 : {
56936 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIfdefDirectiveStatement::pool_size * sizeof(SgIfdefDirectiveStatement) ) ) ;
56937 0 : ++block;
56938 : }
56939 :
56940 : // Special handling for static data
56941 :
56942 :
56943 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
56944 0 : ROSE_ASSERT(found == true);
56945 :
56946 0 : return found;
56947 : }
56948 : /* #line 56949 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
56949 :
56950 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
56951 :
56952 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
56953 :
56954 : /* #line 56955 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
56955 :
56956 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
56957 :
56958 : void
56959 0 : SgIfndefDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
56960 : {
56961 : // ------------ checking pointers of SgIfndefDirectiveStatement -------------------
56962 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
56963 :
56964 0 : if ( p_definingDeclaration != NULL )
56965 : {
56966 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56967 : {
56968 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
56969 : {
56970 0 : std::cout << "SgIfndefDirectiveStatement :: ";
56971 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
56972 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
56973 : }
56974 : }
56975 : else
56976 : {
56977 0 : std::cout << "SgIfndefDirectiveStatement :: " << std::flush;
56978 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
56979 0 : std::cout << " not valid " << std::endl;
56980 : }
56981 : }
56982 :
56983 0 : if ( p_firstNondefiningDeclaration != NULL )
56984 : {
56985 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
56986 : {
56987 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
56988 : {
56989 0 : std::cout << "SgIfndefDirectiveStatement :: ";
56990 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
56991 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
56992 : }
56993 : }
56994 : else
56995 : {
56996 0 : std::cout << "SgIfndefDirectiveStatement :: " << std::flush;
56997 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
56998 0 : std::cout << " not valid " << std::endl;
56999 : }
57000 : }
57001 :
57002 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
57003 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
57004 : {
57005 0 : if ( (*i_qualifiedNameList) != NULL )
57006 : {
57007 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57008 : {
57009 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
57010 : {
57011 0 : std::cout << "SgIfndefDirectiveStatement :: ";
57012 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
57013 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
57014 : }
57015 : }
57016 : else
57017 : {
57018 0 : std::cout << "SgIfndefDirectiveStatement :: " << std::flush;
57019 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
57020 0 : std::cout << " entry not valid " << std::endl;
57021 : }
57022 : }
57023 : else
57024 : {
57025 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
57026 : }
57027 : }
57028 :
57029 0 : if ( p_declarationScope != NULL )
57030 : {
57031 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57032 : {
57033 0 : if ( p_declarationScope->isInMemoryPool() == false )
57034 : {
57035 0 : std::cout << "SgIfndefDirectiveStatement :: ";
57036 0 : std::cout << " p_declarationScope is not in memory pool of ";
57037 0 : std::cout << p_declarationScope->class_name() << std::endl;
57038 : }
57039 : }
57040 : else
57041 : {
57042 0 : std::cout << "SgIfndefDirectiveStatement :: " << std::flush;
57043 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
57044 0 : std::cout << " not valid " << std::endl;
57045 : }
57046 : }
57047 :
57048 0 : if ( p_numeric_label != NULL )
57049 : {
57050 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57051 : {
57052 0 : if ( p_numeric_label->isInMemoryPool() == false )
57053 : {
57054 0 : std::cout << "SgIfndefDirectiveStatement :: ";
57055 0 : std::cout << " p_numeric_label is not in memory pool of ";
57056 0 : std::cout << p_numeric_label->class_name() << std::endl;
57057 : }
57058 : }
57059 : else
57060 : {
57061 0 : std::cout << "SgIfndefDirectiveStatement :: " << std::flush;
57062 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
57063 0 : std::cout << " not valid " << std::endl;
57064 : }
57065 : }
57066 :
57067 0 : if ( p_startOfConstruct != NULL )
57068 : {
57069 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57070 : {
57071 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
57072 : {
57073 0 : std::cout << "SgIfndefDirectiveStatement :: ";
57074 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
57075 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
57076 : }
57077 : }
57078 : else
57079 : {
57080 0 : std::cout << "SgIfndefDirectiveStatement :: " << std::flush;
57081 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
57082 0 : std::cout << " not valid " << std::endl;
57083 : }
57084 : }
57085 :
57086 0 : if ( p_endOfConstruct != NULL )
57087 : {
57088 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57089 : {
57090 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
57091 : {
57092 0 : std::cout << "SgIfndefDirectiveStatement :: ";
57093 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
57094 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
57095 : }
57096 : }
57097 : else
57098 : {
57099 0 : std::cout << "SgIfndefDirectiveStatement :: " << std::flush;
57100 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
57101 0 : std::cout << " not valid " << std::endl;
57102 : }
57103 : }
57104 :
57105 0 : if ( p_parent != NULL )
57106 : {
57107 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57108 : {
57109 0 : if ( p_parent->isInMemoryPool() == false )
57110 : {
57111 0 : std::cout << "SgIfndefDirectiveStatement :: ";
57112 0 : std::cout << " p_parent is not in memory pool of ";
57113 0 : std::cout << p_parent->class_name() << std::endl;
57114 : }
57115 : }
57116 : else
57117 : {
57118 0 : std::cout << "SgIfndefDirectiveStatement :: " << std::flush;
57119 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
57120 0 : std::cout << " not valid " << std::endl;
57121 : }
57122 : }
57123 :
57124 :
57125 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
57126 :
57127 0 : }
57128 :
57129 :
57130 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
57131 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
57132 : bool
57133 0 : SgIfndefDirectiveStatement::isInMemoryPool ()
57134 : {
57135 0 : typedef unsigned char* TestType;
57136 :
57137 0 : bool found = false;
57138 :
57139 0 : ROSE_ASSERT(this != NULL);
57140 :
57141 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
57142 :
57143 0 : TestType tested = (TestType) ( this ) ;
57144 :
57145 0 : std::vector < unsigned char* > :: const_iterator block = SgIfndefDirectiveStatement::pools.begin();
57146 :
57147 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
57148 : // while (found == false && block < Memory_Block_List.end())
57149 0 : while ( (found == false) && (block != SgIfndefDirectiveStatement::pools.end()) )
57150 : {
57151 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIfndefDirectiveStatement::pool_size * sizeof(SgIfndefDirectiveStatement) ) ) ;
57152 0 : ++block;
57153 : }
57154 :
57155 : // Special handling for static data
57156 :
57157 :
57158 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
57159 0 : ROSE_ASSERT(found == true);
57160 :
57161 0 : return found;
57162 : }
57163 : /* #line 57164 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
57164 :
57165 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
57166 :
57167 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
57168 :
57169 : /* #line 57170 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
57170 :
57171 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
57172 :
57173 : void
57174 0 : SgIfDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
57175 : {
57176 : // ------------ checking pointers of SgIfDirectiveStatement -------------------
57177 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
57178 :
57179 0 : if ( p_definingDeclaration != NULL )
57180 : {
57181 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57182 : {
57183 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
57184 : {
57185 0 : std::cout << "SgIfDirectiveStatement :: ";
57186 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
57187 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
57188 : }
57189 : }
57190 : else
57191 : {
57192 0 : std::cout << "SgIfDirectiveStatement :: " << std::flush;
57193 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
57194 0 : std::cout << " not valid " << std::endl;
57195 : }
57196 : }
57197 :
57198 0 : if ( p_firstNondefiningDeclaration != NULL )
57199 : {
57200 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57201 : {
57202 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
57203 : {
57204 0 : std::cout << "SgIfDirectiveStatement :: ";
57205 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
57206 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
57207 : }
57208 : }
57209 : else
57210 : {
57211 0 : std::cout << "SgIfDirectiveStatement :: " << std::flush;
57212 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
57213 0 : std::cout << " not valid " << std::endl;
57214 : }
57215 : }
57216 :
57217 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
57218 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
57219 : {
57220 0 : if ( (*i_qualifiedNameList) != NULL )
57221 : {
57222 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57223 : {
57224 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
57225 : {
57226 0 : std::cout << "SgIfDirectiveStatement :: ";
57227 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
57228 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
57229 : }
57230 : }
57231 : else
57232 : {
57233 0 : std::cout << "SgIfDirectiveStatement :: " << std::flush;
57234 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
57235 0 : std::cout << " entry not valid " << std::endl;
57236 : }
57237 : }
57238 : else
57239 : {
57240 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
57241 : }
57242 : }
57243 :
57244 0 : if ( p_declarationScope != NULL )
57245 : {
57246 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57247 : {
57248 0 : if ( p_declarationScope->isInMemoryPool() == false )
57249 : {
57250 0 : std::cout << "SgIfDirectiveStatement :: ";
57251 0 : std::cout << " p_declarationScope is not in memory pool of ";
57252 0 : std::cout << p_declarationScope->class_name() << std::endl;
57253 : }
57254 : }
57255 : else
57256 : {
57257 0 : std::cout << "SgIfDirectiveStatement :: " << std::flush;
57258 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
57259 0 : std::cout << " not valid " << std::endl;
57260 : }
57261 : }
57262 :
57263 0 : if ( p_numeric_label != NULL )
57264 : {
57265 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57266 : {
57267 0 : if ( p_numeric_label->isInMemoryPool() == false )
57268 : {
57269 0 : std::cout << "SgIfDirectiveStatement :: ";
57270 0 : std::cout << " p_numeric_label is not in memory pool of ";
57271 0 : std::cout << p_numeric_label->class_name() << std::endl;
57272 : }
57273 : }
57274 : else
57275 : {
57276 0 : std::cout << "SgIfDirectiveStatement :: " << std::flush;
57277 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
57278 0 : std::cout << " not valid " << std::endl;
57279 : }
57280 : }
57281 :
57282 0 : if ( p_startOfConstruct != NULL )
57283 : {
57284 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57285 : {
57286 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
57287 : {
57288 0 : std::cout << "SgIfDirectiveStatement :: ";
57289 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
57290 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
57291 : }
57292 : }
57293 : else
57294 : {
57295 0 : std::cout << "SgIfDirectiveStatement :: " << std::flush;
57296 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
57297 0 : std::cout << " not valid " << std::endl;
57298 : }
57299 : }
57300 :
57301 0 : if ( p_endOfConstruct != NULL )
57302 : {
57303 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57304 : {
57305 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
57306 : {
57307 0 : std::cout << "SgIfDirectiveStatement :: ";
57308 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
57309 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
57310 : }
57311 : }
57312 : else
57313 : {
57314 0 : std::cout << "SgIfDirectiveStatement :: " << std::flush;
57315 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
57316 0 : std::cout << " not valid " << std::endl;
57317 : }
57318 : }
57319 :
57320 0 : if ( p_parent != NULL )
57321 : {
57322 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57323 : {
57324 0 : if ( p_parent->isInMemoryPool() == false )
57325 : {
57326 0 : std::cout << "SgIfDirectiveStatement :: ";
57327 0 : std::cout << " p_parent is not in memory pool of ";
57328 0 : std::cout << p_parent->class_name() << std::endl;
57329 : }
57330 : }
57331 : else
57332 : {
57333 0 : std::cout << "SgIfDirectiveStatement :: " << std::flush;
57334 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
57335 0 : std::cout << " not valid " << std::endl;
57336 : }
57337 : }
57338 :
57339 :
57340 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
57341 :
57342 0 : }
57343 :
57344 :
57345 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
57346 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
57347 : bool
57348 0 : SgIfDirectiveStatement::isInMemoryPool ()
57349 : {
57350 0 : typedef unsigned char* TestType;
57351 :
57352 0 : bool found = false;
57353 :
57354 0 : ROSE_ASSERT(this != NULL);
57355 :
57356 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
57357 :
57358 0 : TestType tested = (TestType) ( this ) ;
57359 :
57360 0 : std::vector < unsigned char* > :: const_iterator block = SgIfDirectiveStatement::pools.begin();
57361 :
57362 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
57363 : // while (found == false && block < Memory_Block_List.end())
57364 0 : while ( (found == false) && (block != SgIfDirectiveStatement::pools.end()) )
57365 : {
57366 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIfDirectiveStatement::pool_size * sizeof(SgIfDirectiveStatement) ) ) ;
57367 0 : ++block;
57368 : }
57369 :
57370 : // Special handling for static data
57371 :
57372 :
57373 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
57374 0 : ROSE_ASSERT(found == true);
57375 :
57376 0 : return found;
57377 : }
57378 : /* #line 57379 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
57379 :
57380 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
57381 :
57382 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
57383 :
57384 : /* #line 57385 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
57385 :
57386 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
57387 :
57388 : void
57389 0 : SgDeadIfDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
57390 : {
57391 : // ------------ checking pointers of SgDeadIfDirectiveStatement -------------------
57392 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
57393 :
57394 0 : if ( p_definingDeclaration != NULL )
57395 : {
57396 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57397 : {
57398 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
57399 : {
57400 0 : std::cout << "SgDeadIfDirectiveStatement :: ";
57401 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
57402 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
57403 : }
57404 : }
57405 : else
57406 : {
57407 0 : std::cout << "SgDeadIfDirectiveStatement :: " << std::flush;
57408 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
57409 0 : std::cout << " not valid " << std::endl;
57410 : }
57411 : }
57412 :
57413 0 : if ( p_firstNondefiningDeclaration != NULL )
57414 : {
57415 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57416 : {
57417 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
57418 : {
57419 0 : std::cout << "SgDeadIfDirectiveStatement :: ";
57420 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
57421 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
57422 : }
57423 : }
57424 : else
57425 : {
57426 0 : std::cout << "SgDeadIfDirectiveStatement :: " << std::flush;
57427 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
57428 0 : std::cout << " not valid " << std::endl;
57429 : }
57430 : }
57431 :
57432 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
57433 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
57434 : {
57435 0 : if ( (*i_qualifiedNameList) != NULL )
57436 : {
57437 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57438 : {
57439 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
57440 : {
57441 0 : std::cout << "SgDeadIfDirectiveStatement :: ";
57442 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
57443 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
57444 : }
57445 : }
57446 : else
57447 : {
57448 0 : std::cout << "SgDeadIfDirectiveStatement :: " << std::flush;
57449 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
57450 0 : std::cout << " entry not valid " << std::endl;
57451 : }
57452 : }
57453 : else
57454 : {
57455 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
57456 : }
57457 : }
57458 :
57459 0 : if ( p_declarationScope != NULL )
57460 : {
57461 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57462 : {
57463 0 : if ( p_declarationScope->isInMemoryPool() == false )
57464 : {
57465 0 : std::cout << "SgDeadIfDirectiveStatement :: ";
57466 0 : std::cout << " p_declarationScope is not in memory pool of ";
57467 0 : std::cout << p_declarationScope->class_name() << std::endl;
57468 : }
57469 : }
57470 : else
57471 : {
57472 0 : std::cout << "SgDeadIfDirectiveStatement :: " << std::flush;
57473 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
57474 0 : std::cout << " not valid " << std::endl;
57475 : }
57476 : }
57477 :
57478 0 : if ( p_numeric_label != NULL )
57479 : {
57480 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57481 : {
57482 0 : if ( p_numeric_label->isInMemoryPool() == false )
57483 : {
57484 0 : std::cout << "SgDeadIfDirectiveStatement :: ";
57485 0 : std::cout << " p_numeric_label is not in memory pool of ";
57486 0 : std::cout << p_numeric_label->class_name() << std::endl;
57487 : }
57488 : }
57489 : else
57490 : {
57491 0 : std::cout << "SgDeadIfDirectiveStatement :: " << std::flush;
57492 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
57493 0 : std::cout << " not valid " << std::endl;
57494 : }
57495 : }
57496 :
57497 0 : if ( p_startOfConstruct != NULL )
57498 : {
57499 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57500 : {
57501 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
57502 : {
57503 0 : std::cout << "SgDeadIfDirectiveStatement :: ";
57504 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
57505 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
57506 : }
57507 : }
57508 : else
57509 : {
57510 0 : std::cout << "SgDeadIfDirectiveStatement :: " << std::flush;
57511 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
57512 0 : std::cout << " not valid " << std::endl;
57513 : }
57514 : }
57515 :
57516 0 : if ( p_endOfConstruct != NULL )
57517 : {
57518 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57519 : {
57520 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
57521 : {
57522 0 : std::cout << "SgDeadIfDirectiveStatement :: ";
57523 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
57524 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
57525 : }
57526 : }
57527 : else
57528 : {
57529 0 : std::cout << "SgDeadIfDirectiveStatement :: " << std::flush;
57530 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
57531 0 : std::cout << " not valid " << std::endl;
57532 : }
57533 : }
57534 :
57535 0 : if ( p_parent != NULL )
57536 : {
57537 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57538 : {
57539 0 : if ( p_parent->isInMemoryPool() == false )
57540 : {
57541 0 : std::cout << "SgDeadIfDirectiveStatement :: ";
57542 0 : std::cout << " p_parent is not in memory pool of ";
57543 0 : std::cout << p_parent->class_name() << std::endl;
57544 : }
57545 : }
57546 : else
57547 : {
57548 0 : std::cout << "SgDeadIfDirectiveStatement :: " << std::flush;
57549 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
57550 0 : std::cout << " not valid " << std::endl;
57551 : }
57552 : }
57553 :
57554 :
57555 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
57556 :
57557 0 : }
57558 :
57559 :
57560 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
57561 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
57562 : bool
57563 0 : SgDeadIfDirectiveStatement::isInMemoryPool ()
57564 : {
57565 0 : typedef unsigned char* TestType;
57566 :
57567 0 : bool found = false;
57568 :
57569 0 : ROSE_ASSERT(this != NULL);
57570 :
57571 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
57572 :
57573 0 : TestType tested = (TestType) ( this ) ;
57574 :
57575 0 : std::vector < unsigned char* > :: const_iterator block = SgDeadIfDirectiveStatement::pools.begin();
57576 :
57577 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
57578 : // while (found == false && block < Memory_Block_List.end())
57579 0 : while ( (found == false) && (block != SgDeadIfDirectiveStatement::pools.end()) )
57580 : {
57581 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDeadIfDirectiveStatement::pool_size * sizeof(SgDeadIfDirectiveStatement) ) ) ;
57582 0 : ++block;
57583 : }
57584 :
57585 : // Special handling for static data
57586 :
57587 :
57588 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
57589 0 : ROSE_ASSERT(found == true);
57590 :
57591 0 : return found;
57592 : }
57593 : /* #line 57594 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
57594 :
57595 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
57596 :
57597 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
57598 :
57599 : /* #line 57600 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
57600 :
57601 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
57602 :
57603 : void
57604 0 : SgElseDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
57605 : {
57606 : // ------------ checking pointers of SgElseDirectiveStatement -------------------
57607 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
57608 :
57609 0 : if ( p_definingDeclaration != NULL )
57610 : {
57611 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57612 : {
57613 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
57614 : {
57615 0 : std::cout << "SgElseDirectiveStatement :: ";
57616 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
57617 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
57618 : }
57619 : }
57620 : else
57621 : {
57622 0 : std::cout << "SgElseDirectiveStatement :: " << std::flush;
57623 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
57624 0 : std::cout << " not valid " << std::endl;
57625 : }
57626 : }
57627 :
57628 0 : if ( p_firstNondefiningDeclaration != NULL )
57629 : {
57630 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57631 : {
57632 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
57633 : {
57634 0 : std::cout << "SgElseDirectiveStatement :: ";
57635 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
57636 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
57637 : }
57638 : }
57639 : else
57640 : {
57641 0 : std::cout << "SgElseDirectiveStatement :: " << std::flush;
57642 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
57643 0 : std::cout << " not valid " << std::endl;
57644 : }
57645 : }
57646 :
57647 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
57648 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
57649 : {
57650 0 : if ( (*i_qualifiedNameList) != NULL )
57651 : {
57652 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57653 : {
57654 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
57655 : {
57656 0 : std::cout << "SgElseDirectiveStatement :: ";
57657 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
57658 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
57659 : }
57660 : }
57661 : else
57662 : {
57663 0 : std::cout << "SgElseDirectiveStatement :: " << std::flush;
57664 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
57665 0 : std::cout << " entry not valid " << std::endl;
57666 : }
57667 : }
57668 : else
57669 : {
57670 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
57671 : }
57672 : }
57673 :
57674 0 : if ( p_declarationScope != NULL )
57675 : {
57676 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57677 : {
57678 0 : if ( p_declarationScope->isInMemoryPool() == false )
57679 : {
57680 0 : std::cout << "SgElseDirectiveStatement :: ";
57681 0 : std::cout << " p_declarationScope is not in memory pool of ";
57682 0 : std::cout << p_declarationScope->class_name() << std::endl;
57683 : }
57684 : }
57685 : else
57686 : {
57687 0 : std::cout << "SgElseDirectiveStatement :: " << std::flush;
57688 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
57689 0 : std::cout << " not valid " << std::endl;
57690 : }
57691 : }
57692 :
57693 0 : if ( p_numeric_label != NULL )
57694 : {
57695 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57696 : {
57697 0 : if ( p_numeric_label->isInMemoryPool() == false )
57698 : {
57699 0 : std::cout << "SgElseDirectiveStatement :: ";
57700 0 : std::cout << " p_numeric_label is not in memory pool of ";
57701 0 : std::cout << p_numeric_label->class_name() << std::endl;
57702 : }
57703 : }
57704 : else
57705 : {
57706 0 : std::cout << "SgElseDirectiveStatement :: " << std::flush;
57707 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
57708 0 : std::cout << " not valid " << std::endl;
57709 : }
57710 : }
57711 :
57712 0 : if ( p_startOfConstruct != NULL )
57713 : {
57714 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57715 : {
57716 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
57717 : {
57718 0 : std::cout << "SgElseDirectiveStatement :: ";
57719 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
57720 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
57721 : }
57722 : }
57723 : else
57724 : {
57725 0 : std::cout << "SgElseDirectiveStatement :: " << std::flush;
57726 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
57727 0 : std::cout << " not valid " << std::endl;
57728 : }
57729 : }
57730 :
57731 0 : if ( p_endOfConstruct != NULL )
57732 : {
57733 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57734 : {
57735 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
57736 : {
57737 0 : std::cout << "SgElseDirectiveStatement :: ";
57738 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
57739 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
57740 : }
57741 : }
57742 : else
57743 : {
57744 0 : std::cout << "SgElseDirectiveStatement :: " << std::flush;
57745 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
57746 0 : std::cout << " not valid " << std::endl;
57747 : }
57748 : }
57749 :
57750 0 : if ( p_parent != NULL )
57751 : {
57752 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57753 : {
57754 0 : if ( p_parent->isInMemoryPool() == false )
57755 : {
57756 0 : std::cout << "SgElseDirectiveStatement :: ";
57757 0 : std::cout << " p_parent is not in memory pool of ";
57758 0 : std::cout << p_parent->class_name() << std::endl;
57759 : }
57760 : }
57761 : else
57762 : {
57763 0 : std::cout << "SgElseDirectiveStatement :: " << std::flush;
57764 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
57765 0 : std::cout << " not valid " << std::endl;
57766 : }
57767 : }
57768 :
57769 :
57770 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
57771 :
57772 0 : }
57773 :
57774 :
57775 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
57776 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
57777 : bool
57778 0 : SgElseDirectiveStatement::isInMemoryPool ()
57779 : {
57780 0 : typedef unsigned char* TestType;
57781 :
57782 0 : bool found = false;
57783 :
57784 0 : ROSE_ASSERT(this != NULL);
57785 :
57786 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
57787 :
57788 0 : TestType tested = (TestType) ( this ) ;
57789 :
57790 0 : std::vector < unsigned char* > :: const_iterator block = SgElseDirectiveStatement::pools.begin();
57791 :
57792 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
57793 : // while (found == false && block < Memory_Block_List.end())
57794 0 : while ( (found == false) && (block != SgElseDirectiveStatement::pools.end()) )
57795 : {
57796 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgElseDirectiveStatement::pool_size * sizeof(SgElseDirectiveStatement) ) ) ;
57797 0 : ++block;
57798 : }
57799 :
57800 : // Special handling for static data
57801 :
57802 :
57803 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
57804 0 : ROSE_ASSERT(found == true);
57805 :
57806 0 : return found;
57807 : }
57808 : /* #line 57809 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
57809 :
57810 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
57811 :
57812 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
57813 :
57814 : /* #line 57815 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
57815 :
57816 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
57817 :
57818 : void
57819 0 : SgElseifDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
57820 : {
57821 : // ------------ checking pointers of SgElseifDirectiveStatement -------------------
57822 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
57823 :
57824 0 : if ( p_definingDeclaration != NULL )
57825 : {
57826 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57827 : {
57828 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
57829 : {
57830 0 : std::cout << "SgElseifDirectiveStatement :: ";
57831 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
57832 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
57833 : }
57834 : }
57835 : else
57836 : {
57837 0 : std::cout << "SgElseifDirectiveStatement :: " << std::flush;
57838 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
57839 0 : std::cout << " not valid " << std::endl;
57840 : }
57841 : }
57842 :
57843 0 : if ( p_firstNondefiningDeclaration != NULL )
57844 : {
57845 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57846 : {
57847 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
57848 : {
57849 0 : std::cout << "SgElseifDirectiveStatement :: ";
57850 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
57851 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
57852 : }
57853 : }
57854 : else
57855 : {
57856 0 : std::cout << "SgElseifDirectiveStatement :: " << std::flush;
57857 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
57858 0 : std::cout << " not valid " << std::endl;
57859 : }
57860 : }
57861 :
57862 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
57863 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
57864 : {
57865 0 : if ( (*i_qualifiedNameList) != NULL )
57866 : {
57867 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57868 : {
57869 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
57870 : {
57871 0 : std::cout << "SgElseifDirectiveStatement :: ";
57872 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
57873 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
57874 : }
57875 : }
57876 : else
57877 : {
57878 0 : std::cout << "SgElseifDirectiveStatement :: " << std::flush;
57879 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
57880 0 : std::cout << " entry not valid " << std::endl;
57881 : }
57882 : }
57883 : else
57884 : {
57885 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
57886 : }
57887 : }
57888 :
57889 0 : if ( p_declarationScope != NULL )
57890 : {
57891 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57892 : {
57893 0 : if ( p_declarationScope->isInMemoryPool() == false )
57894 : {
57895 0 : std::cout << "SgElseifDirectiveStatement :: ";
57896 0 : std::cout << " p_declarationScope is not in memory pool of ";
57897 0 : std::cout << p_declarationScope->class_name() << std::endl;
57898 : }
57899 : }
57900 : else
57901 : {
57902 0 : std::cout << "SgElseifDirectiveStatement :: " << std::flush;
57903 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
57904 0 : std::cout << " not valid " << std::endl;
57905 : }
57906 : }
57907 :
57908 0 : if ( p_numeric_label != NULL )
57909 : {
57910 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57911 : {
57912 0 : if ( p_numeric_label->isInMemoryPool() == false )
57913 : {
57914 0 : std::cout << "SgElseifDirectiveStatement :: ";
57915 0 : std::cout << " p_numeric_label is not in memory pool of ";
57916 0 : std::cout << p_numeric_label->class_name() << std::endl;
57917 : }
57918 : }
57919 : else
57920 : {
57921 0 : std::cout << "SgElseifDirectiveStatement :: " << std::flush;
57922 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
57923 0 : std::cout << " not valid " << std::endl;
57924 : }
57925 : }
57926 :
57927 0 : if ( p_startOfConstruct != NULL )
57928 : {
57929 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57930 : {
57931 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
57932 : {
57933 0 : std::cout << "SgElseifDirectiveStatement :: ";
57934 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
57935 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
57936 : }
57937 : }
57938 : else
57939 : {
57940 0 : std::cout << "SgElseifDirectiveStatement :: " << std::flush;
57941 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
57942 0 : std::cout << " not valid " << std::endl;
57943 : }
57944 : }
57945 :
57946 0 : if ( p_endOfConstruct != NULL )
57947 : {
57948 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57949 : {
57950 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
57951 : {
57952 0 : std::cout << "SgElseifDirectiveStatement :: ";
57953 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
57954 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
57955 : }
57956 : }
57957 : else
57958 : {
57959 0 : std::cout << "SgElseifDirectiveStatement :: " << std::flush;
57960 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
57961 0 : std::cout << " not valid " << std::endl;
57962 : }
57963 : }
57964 :
57965 0 : if ( p_parent != NULL )
57966 : {
57967 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
57968 : {
57969 0 : if ( p_parent->isInMemoryPool() == false )
57970 : {
57971 0 : std::cout << "SgElseifDirectiveStatement :: ";
57972 0 : std::cout << " p_parent is not in memory pool of ";
57973 0 : std::cout << p_parent->class_name() << std::endl;
57974 : }
57975 : }
57976 : else
57977 : {
57978 0 : std::cout << "SgElseifDirectiveStatement :: " << std::flush;
57979 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
57980 0 : std::cout << " not valid " << std::endl;
57981 : }
57982 : }
57983 :
57984 :
57985 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
57986 :
57987 0 : }
57988 :
57989 :
57990 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
57991 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
57992 : bool
57993 0 : SgElseifDirectiveStatement::isInMemoryPool ()
57994 : {
57995 0 : typedef unsigned char* TestType;
57996 :
57997 0 : bool found = false;
57998 :
57999 0 : ROSE_ASSERT(this != NULL);
58000 :
58001 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
58002 :
58003 0 : TestType tested = (TestType) ( this ) ;
58004 :
58005 0 : std::vector < unsigned char* > :: const_iterator block = SgElseifDirectiveStatement::pools.begin();
58006 :
58007 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
58008 : // while (found == false && block < Memory_Block_List.end())
58009 0 : while ( (found == false) && (block != SgElseifDirectiveStatement::pools.end()) )
58010 : {
58011 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgElseifDirectiveStatement::pool_size * sizeof(SgElseifDirectiveStatement) ) ) ;
58012 0 : ++block;
58013 : }
58014 :
58015 : // Special handling for static data
58016 :
58017 :
58018 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
58019 0 : ROSE_ASSERT(found == true);
58020 :
58021 0 : return found;
58022 : }
58023 : /* #line 58024 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
58024 :
58025 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
58026 :
58027 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
58028 :
58029 : /* #line 58030 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
58030 :
58031 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
58032 :
58033 : void
58034 0 : SgEndifDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
58035 : {
58036 : // ------------ checking pointers of SgEndifDirectiveStatement -------------------
58037 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
58038 :
58039 0 : if ( p_definingDeclaration != NULL )
58040 : {
58041 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58042 : {
58043 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
58044 : {
58045 0 : std::cout << "SgEndifDirectiveStatement :: ";
58046 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
58047 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
58048 : }
58049 : }
58050 : else
58051 : {
58052 0 : std::cout << "SgEndifDirectiveStatement :: " << std::flush;
58053 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
58054 0 : std::cout << " not valid " << std::endl;
58055 : }
58056 : }
58057 :
58058 0 : if ( p_firstNondefiningDeclaration != NULL )
58059 : {
58060 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58061 : {
58062 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
58063 : {
58064 0 : std::cout << "SgEndifDirectiveStatement :: ";
58065 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
58066 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
58067 : }
58068 : }
58069 : else
58070 : {
58071 0 : std::cout << "SgEndifDirectiveStatement :: " << std::flush;
58072 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
58073 0 : std::cout << " not valid " << std::endl;
58074 : }
58075 : }
58076 :
58077 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
58078 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
58079 : {
58080 0 : if ( (*i_qualifiedNameList) != NULL )
58081 : {
58082 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58083 : {
58084 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
58085 : {
58086 0 : std::cout << "SgEndifDirectiveStatement :: ";
58087 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
58088 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
58089 : }
58090 : }
58091 : else
58092 : {
58093 0 : std::cout << "SgEndifDirectiveStatement :: " << std::flush;
58094 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
58095 0 : std::cout << " entry not valid " << std::endl;
58096 : }
58097 : }
58098 : else
58099 : {
58100 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
58101 : }
58102 : }
58103 :
58104 0 : if ( p_declarationScope != NULL )
58105 : {
58106 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58107 : {
58108 0 : if ( p_declarationScope->isInMemoryPool() == false )
58109 : {
58110 0 : std::cout << "SgEndifDirectiveStatement :: ";
58111 0 : std::cout << " p_declarationScope is not in memory pool of ";
58112 0 : std::cout << p_declarationScope->class_name() << std::endl;
58113 : }
58114 : }
58115 : else
58116 : {
58117 0 : std::cout << "SgEndifDirectiveStatement :: " << std::flush;
58118 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
58119 0 : std::cout << " not valid " << std::endl;
58120 : }
58121 : }
58122 :
58123 0 : if ( p_numeric_label != NULL )
58124 : {
58125 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58126 : {
58127 0 : if ( p_numeric_label->isInMemoryPool() == false )
58128 : {
58129 0 : std::cout << "SgEndifDirectiveStatement :: ";
58130 0 : std::cout << " p_numeric_label is not in memory pool of ";
58131 0 : std::cout << p_numeric_label->class_name() << std::endl;
58132 : }
58133 : }
58134 : else
58135 : {
58136 0 : std::cout << "SgEndifDirectiveStatement :: " << std::flush;
58137 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
58138 0 : std::cout << " not valid " << std::endl;
58139 : }
58140 : }
58141 :
58142 0 : if ( p_startOfConstruct != NULL )
58143 : {
58144 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58145 : {
58146 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
58147 : {
58148 0 : std::cout << "SgEndifDirectiveStatement :: ";
58149 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
58150 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
58151 : }
58152 : }
58153 : else
58154 : {
58155 0 : std::cout << "SgEndifDirectiveStatement :: " << std::flush;
58156 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
58157 0 : std::cout << " not valid " << std::endl;
58158 : }
58159 : }
58160 :
58161 0 : if ( p_endOfConstruct != NULL )
58162 : {
58163 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58164 : {
58165 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
58166 : {
58167 0 : std::cout << "SgEndifDirectiveStatement :: ";
58168 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
58169 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
58170 : }
58171 : }
58172 : else
58173 : {
58174 0 : std::cout << "SgEndifDirectiveStatement :: " << std::flush;
58175 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
58176 0 : std::cout << " not valid " << std::endl;
58177 : }
58178 : }
58179 :
58180 0 : if ( p_parent != NULL )
58181 : {
58182 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58183 : {
58184 0 : if ( p_parent->isInMemoryPool() == false )
58185 : {
58186 0 : std::cout << "SgEndifDirectiveStatement :: ";
58187 0 : std::cout << " p_parent is not in memory pool of ";
58188 0 : std::cout << p_parent->class_name() << std::endl;
58189 : }
58190 : }
58191 : else
58192 : {
58193 0 : std::cout << "SgEndifDirectiveStatement :: " << std::flush;
58194 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
58195 0 : std::cout << " not valid " << std::endl;
58196 : }
58197 : }
58198 :
58199 :
58200 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
58201 :
58202 0 : }
58203 :
58204 :
58205 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
58206 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
58207 : bool
58208 0 : SgEndifDirectiveStatement::isInMemoryPool ()
58209 : {
58210 0 : typedef unsigned char* TestType;
58211 :
58212 0 : bool found = false;
58213 :
58214 0 : ROSE_ASSERT(this != NULL);
58215 :
58216 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
58217 :
58218 0 : TestType tested = (TestType) ( this ) ;
58219 :
58220 0 : std::vector < unsigned char* > :: const_iterator block = SgEndifDirectiveStatement::pools.begin();
58221 :
58222 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
58223 : // while (found == false && block < Memory_Block_List.end())
58224 0 : while ( (found == false) && (block != SgEndifDirectiveStatement::pools.end()) )
58225 : {
58226 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgEndifDirectiveStatement::pool_size * sizeof(SgEndifDirectiveStatement) ) ) ;
58227 0 : ++block;
58228 : }
58229 :
58230 : // Special handling for static data
58231 :
58232 :
58233 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
58234 0 : ROSE_ASSERT(found == true);
58235 :
58236 0 : return found;
58237 : }
58238 : /* #line 58239 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
58239 :
58240 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
58241 :
58242 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
58243 :
58244 : /* #line 58245 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
58245 :
58246 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
58247 :
58248 : void
58249 0 : SgLineDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
58250 : {
58251 : // ------------ checking pointers of SgLineDirectiveStatement -------------------
58252 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
58253 :
58254 0 : if ( p_definingDeclaration != NULL )
58255 : {
58256 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58257 : {
58258 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
58259 : {
58260 0 : std::cout << "SgLineDirectiveStatement :: ";
58261 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
58262 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
58263 : }
58264 : }
58265 : else
58266 : {
58267 0 : std::cout << "SgLineDirectiveStatement :: " << std::flush;
58268 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
58269 0 : std::cout << " not valid " << std::endl;
58270 : }
58271 : }
58272 :
58273 0 : if ( p_firstNondefiningDeclaration != NULL )
58274 : {
58275 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58276 : {
58277 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
58278 : {
58279 0 : std::cout << "SgLineDirectiveStatement :: ";
58280 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
58281 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
58282 : }
58283 : }
58284 : else
58285 : {
58286 0 : std::cout << "SgLineDirectiveStatement :: " << std::flush;
58287 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
58288 0 : std::cout << " not valid " << std::endl;
58289 : }
58290 : }
58291 :
58292 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
58293 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
58294 : {
58295 0 : if ( (*i_qualifiedNameList) != NULL )
58296 : {
58297 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58298 : {
58299 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
58300 : {
58301 0 : std::cout << "SgLineDirectiveStatement :: ";
58302 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
58303 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
58304 : }
58305 : }
58306 : else
58307 : {
58308 0 : std::cout << "SgLineDirectiveStatement :: " << std::flush;
58309 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
58310 0 : std::cout << " entry not valid " << std::endl;
58311 : }
58312 : }
58313 : else
58314 : {
58315 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
58316 : }
58317 : }
58318 :
58319 0 : if ( p_declarationScope != NULL )
58320 : {
58321 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58322 : {
58323 0 : if ( p_declarationScope->isInMemoryPool() == false )
58324 : {
58325 0 : std::cout << "SgLineDirectiveStatement :: ";
58326 0 : std::cout << " p_declarationScope is not in memory pool of ";
58327 0 : std::cout << p_declarationScope->class_name() << std::endl;
58328 : }
58329 : }
58330 : else
58331 : {
58332 0 : std::cout << "SgLineDirectiveStatement :: " << std::flush;
58333 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
58334 0 : std::cout << " not valid " << std::endl;
58335 : }
58336 : }
58337 :
58338 0 : if ( p_numeric_label != NULL )
58339 : {
58340 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58341 : {
58342 0 : if ( p_numeric_label->isInMemoryPool() == false )
58343 : {
58344 0 : std::cout << "SgLineDirectiveStatement :: ";
58345 0 : std::cout << " p_numeric_label is not in memory pool of ";
58346 0 : std::cout << p_numeric_label->class_name() << std::endl;
58347 : }
58348 : }
58349 : else
58350 : {
58351 0 : std::cout << "SgLineDirectiveStatement :: " << std::flush;
58352 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
58353 0 : std::cout << " not valid " << std::endl;
58354 : }
58355 : }
58356 :
58357 0 : if ( p_startOfConstruct != NULL )
58358 : {
58359 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58360 : {
58361 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
58362 : {
58363 0 : std::cout << "SgLineDirectiveStatement :: ";
58364 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
58365 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
58366 : }
58367 : }
58368 : else
58369 : {
58370 0 : std::cout << "SgLineDirectiveStatement :: " << std::flush;
58371 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
58372 0 : std::cout << " not valid " << std::endl;
58373 : }
58374 : }
58375 :
58376 0 : if ( p_endOfConstruct != NULL )
58377 : {
58378 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58379 : {
58380 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
58381 : {
58382 0 : std::cout << "SgLineDirectiveStatement :: ";
58383 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
58384 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
58385 : }
58386 : }
58387 : else
58388 : {
58389 0 : std::cout << "SgLineDirectiveStatement :: " << std::flush;
58390 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
58391 0 : std::cout << " not valid " << std::endl;
58392 : }
58393 : }
58394 :
58395 0 : if ( p_parent != NULL )
58396 : {
58397 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58398 : {
58399 0 : if ( p_parent->isInMemoryPool() == false )
58400 : {
58401 0 : std::cout << "SgLineDirectiveStatement :: ";
58402 0 : std::cout << " p_parent is not in memory pool of ";
58403 0 : std::cout << p_parent->class_name() << std::endl;
58404 : }
58405 : }
58406 : else
58407 : {
58408 0 : std::cout << "SgLineDirectiveStatement :: " << std::flush;
58409 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
58410 0 : std::cout << " not valid " << std::endl;
58411 : }
58412 : }
58413 :
58414 :
58415 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
58416 :
58417 0 : }
58418 :
58419 :
58420 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
58421 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
58422 : bool
58423 0 : SgLineDirectiveStatement::isInMemoryPool ()
58424 : {
58425 0 : typedef unsigned char* TestType;
58426 :
58427 0 : bool found = false;
58428 :
58429 0 : ROSE_ASSERT(this != NULL);
58430 :
58431 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
58432 :
58433 0 : TestType tested = (TestType) ( this ) ;
58434 :
58435 0 : std::vector < unsigned char* > :: const_iterator block = SgLineDirectiveStatement::pools.begin();
58436 :
58437 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
58438 : // while (found == false && block < Memory_Block_List.end())
58439 0 : while ( (found == false) && (block != SgLineDirectiveStatement::pools.end()) )
58440 : {
58441 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLineDirectiveStatement::pool_size * sizeof(SgLineDirectiveStatement) ) ) ;
58442 0 : ++block;
58443 : }
58444 :
58445 : // Special handling for static data
58446 :
58447 :
58448 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
58449 0 : ROSE_ASSERT(found == true);
58450 :
58451 0 : return found;
58452 : }
58453 : /* #line 58454 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
58454 :
58455 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
58456 :
58457 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
58458 :
58459 : /* #line 58460 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
58460 :
58461 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
58462 :
58463 : void
58464 0 : SgWarningDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
58465 : {
58466 : // ------------ checking pointers of SgWarningDirectiveStatement -------------------
58467 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
58468 :
58469 0 : if ( p_definingDeclaration != NULL )
58470 : {
58471 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58472 : {
58473 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
58474 : {
58475 0 : std::cout << "SgWarningDirectiveStatement :: ";
58476 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
58477 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
58478 : }
58479 : }
58480 : else
58481 : {
58482 0 : std::cout << "SgWarningDirectiveStatement :: " << std::flush;
58483 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
58484 0 : std::cout << " not valid " << std::endl;
58485 : }
58486 : }
58487 :
58488 0 : if ( p_firstNondefiningDeclaration != NULL )
58489 : {
58490 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58491 : {
58492 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
58493 : {
58494 0 : std::cout << "SgWarningDirectiveStatement :: ";
58495 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
58496 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
58497 : }
58498 : }
58499 : else
58500 : {
58501 0 : std::cout << "SgWarningDirectiveStatement :: " << std::flush;
58502 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
58503 0 : std::cout << " not valid " << std::endl;
58504 : }
58505 : }
58506 :
58507 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
58508 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
58509 : {
58510 0 : if ( (*i_qualifiedNameList) != NULL )
58511 : {
58512 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58513 : {
58514 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
58515 : {
58516 0 : std::cout << "SgWarningDirectiveStatement :: ";
58517 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
58518 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
58519 : }
58520 : }
58521 : else
58522 : {
58523 0 : std::cout << "SgWarningDirectiveStatement :: " << std::flush;
58524 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
58525 0 : std::cout << " entry not valid " << std::endl;
58526 : }
58527 : }
58528 : else
58529 : {
58530 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
58531 : }
58532 : }
58533 :
58534 0 : if ( p_declarationScope != NULL )
58535 : {
58536 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58537 : {
58538 0 : if ( p_declarationScope->isInMemoryPool() == false )
58539 : {
58540 0 : std::cout << "SgWarningDirectiveStatement :: ";
58541 0 : std::cout << " p_declarationScope is not in memory pool of ";
58542 0 : std::cout << p_declarationScope->class_name() << std::endl;
58543 : }
58544 : }
58545 : else
58546 : {
58547 0 : std::cout << "SgWarningDirectiveStatement :: " << std::flush;
58548 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
58549 0 : std::cout << " not valid " << std::endl;
58550 : }
58551 : }
58552 :
58553 0 : if ( p_numeric_label != NULL )
58554 : {
58555 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58556 : {
58557 0 : if ( p_numeric_label->isInMemoryPool() == false )
58558 : {
58559 0 : std::cout << "SgWarningDirectiveStatement :: ";
58560 0 : std::cout << " p_numeric_label is not in memory pool of ";
58561 0 : std::cout << p_numeric_label->class_name() << std::endl;
58562 : }
58563 : }
58564 : else
58565 : {
58566 0 : std::cout << "SgWarningDirectiveStatement :: " << std::flush;
58567 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
58568 0 : std::cout << " not valid " << std::endl;
58569 : }
58570 : }
58571 :
58572 0 : if ( p_startOfConstruct != NULL )
58573 : {
58574 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58575 : {
58576 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
58577 : {
58578 0 : std::cout << "SgWarningDirectiveStatement :: ";
58579 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
58580 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
58581 : }
58582 : }
58583 : else
58584 : {
58585 0 : std::cout << "SgWarningDirectiveStatement :: " << std::flush;
58586 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
58587 0 : std::cout << " not valid " << std::endl;
58588 : }
58589 : }
58590 :
58591 0 : if ( p_endOfConstruct != NULL )
58592 : {
58593 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58594 : {
58595 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
58596 : {
58597 0 : std::cout << "SgWarningDirectiveStatement :: ";
58598 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
58599 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
58600 : }
58601 : }
58602 : else
58603 : {
58604 0 : std::cout << "SgWarningDirectiveStatement :: " << std::flush;
58605 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
58606 0 : std::cout << " not valid " << std::endl;
58607 : }
58608 : }
58609 :
58610 0 : if ( p_parent != NULL )
58611 : {
58612 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58613 : {
58614 0 : if ( p_parent->isInMemoryPool() == false )
58615 : {
58616 0 : std::cout << "SgWarningDirectiveStatement :: ";
58617 0 : std::cout << " p_parent is not in memory pool of ";
58618 0 : std::cout << p_parent->class_name() << std::endl;
58619 : }
58620 : }
58621 : else
58622 : {
58623 0 : std::cout << "SgWarningDirectiveStatement :: " << std::flush;
58624 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
58625 0 : std::cout << " not valid " << std::endl;
58626 : }
58627 : }
58628 :
58629 :
58630 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
58631 :
58632 0 : }
58633 :
58634 :
58635 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
58636 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
58637 : bool
58638 0 : SgWarningDirectiveStatement::isInMemoryPool ()
58639 : {
58640 0 : typedef unsigned char* TestType;
58641 :
58642 0 : bool found = false;
58643 :
58644 0 : ROSE_ASSERT(this != NULL);
58645 :
58646 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
58647 :
58648 0 : TestType tested = (TestType) ( this ) ;
58649 :
58650 0 : std::vector < unsigned char* > :: const_iterator block = SgWarningDirectiveStatement::pools.begin();
58651 :
58652 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
58653 : // while (found == false && block < Memory_Block_List.end())
58654 0 : while ( (found == false) && (block != SgWarningDirectiveStatement::pools.end()) )
58655 : {
58656 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgWarningDirectiveStatement::pool_size * sizeof(SgWarningDirectiveStatement) ) ) ;
58657 0 : ++block;
58658 : }
58659 :
58660 : // Special handling for static data
58661 :
58662 :
58663 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
58664 0 : ROSE_ASSERT(found == true);
58665 :
58666 0 : return found;
58667 : }
58668 : /* #line 58669 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
58669 :
58670 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
58671 :
58672 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
58673 :
58674 : /* #line 58675 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
58675 :
58676 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
58677 :
58678 : void
58679 0 : SgErrorDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
58680 : {
58681 : // ------------ checking pointers of SgErrorDirectiveStatement -------------------
58682 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
58683 :
58684 0 : if ( p_definingDeclaration != NULL )
58685 : {
58686 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58687 : {
58688 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
58689 : {
58690 0 : std::cout << "SgErrorDirectiveStatement :: ";
58691 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
58692 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
58693 : }
58694 : }
58695 : else
58696 : {
58697 0 : std::cout << "SgErrorDirectiveStatement :: " << std::flush;
58698 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
58699 0 : std::cout << " not valid " << std::endl;
58700 : }
58701 : }
58702 :
58703 0 : if ( p_firstNondefiningDeclaration != NULL )
58704 : {
58705 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58706 : {
58707 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
58708 : {
58709 0 : std::cout << "SgErrorDirectiveStatement :: ";
58710 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
58711 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
58712 : }
58713 : }
58714 : else
58715 : {
58716 0 : std::cout << "SgErrorDirectiveStatement :: " << std::flush;
58717 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
58718 0 : std::cout << " not valid " << std::endl;
58719 : }
58720 : }
58721 :
58722 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
58723 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
58724 : {
58725 0 : if ( (*i_qualifiedNameList) != NULL )
58726 : {
58727 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58728 : {
58729 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
58730 : {
58731 0 : std::cout << "SgErrorDirectiveStatement :: ";
58732 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
58733 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
58734 : }
58735 : }
58736 : else
58737 : {
58738 0 : std::cout << "SgErrorDirectiveStatement :: " << std::flush;
58739 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
58740 0 : std::cout << " entry not valid " << std::endl;
58741 : }
58742 : }
58743 : else
58744 : {
58745 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
58746 : }
58747 : }
58748 :
58749 0 : if ( p_declarationScope != NULL )
58750 : {
58751 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58752 : {
58753 0 : if ( p_declarationScope->isInMemoryPool() == false )
58754 : {
58755 0 : std::cout << "SgErrorDirectiveStatement :: ";
58756 0 : std::cout << " p_declarationScope is not in memory pool of ";
58757 0 : std::cout << p_declarationScope->class_name() << std::endl;
58758 : }
58759 : }
58760 : else
58761 : {
58762 0 : std::cout << "SgErrorDirectiveStatement :: " << std::flush;
58763 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
58764 0 : std::cout << " not valid " << std::endl;
58765 : }
58766 : }
58767 :
58768 0 : if ( p_numeric_label != NULL )
58769 : {
58770 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58771 : {
58772 0 : if ( p_numeric_label->isInMemoryPool() == false )
58773 : {
58774 0 : std::cout << "SgErrorDirectiveStatement :: ";
58775 0 : std::cout << " p_numeric_label is not in memory pool of ";
58776 0 : std::cout << p_numeric_label->class_name() << std::endl;
58777 : }
58778 : }
58779 : else
58780 : {
58781 0 : std::cout << "SgErrorDirectiveStatement :: " << std::flush;
58782 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
58783 0 : std::cout << " not valid " << std::endl;
58784 : }
58785 : }
58786 :
58787 0 : if ( p_startOfConstruct != NULL )
58788 : {
58789 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58790 : {
58791 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
58792 : {
58793 0 : std::cout << "SgErrorDirectiveStatement :: ";
58794 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
58795 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
58796 : }
58797 : }
58798 : else
58799 : {
58800 0 : std::cout << "SgErrorDirectiveStatement :: " << std::flush;
58801 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
58802 0 : std::cout << " not valid " << std::endl;
58803 : }
58804 : }
58805 :
58806 0 : if ( p_endOfConstruct != NULL )
58807 : {
58808 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58809 : {
58810 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
58811 : {
58812 0 : std::cout << "SgErrorDirectiveStatement :: ";
58813 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
58814 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
58815 : }
58816 : }
58817 : else
58818 : {
58819 0 : std::cout << "SgErrorDirectiveStatement :: " << std::flush;
58820 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
58821 0 : std::cout << " not valid " << std::endl;
58822 : }
58823 : }
58824 :
58825 0 : if ( p_parent != NULL )
58826 : {
58827 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58828 : {
58829 0 : if ( p_parent->isInMemoryPool() == false )
58830 : {
58831 0 : std::cout << "SgErrorDirectiveStatement :: ";
58832 0 : std::cout << " p_parent is not in memory pool of ";
58833 0 : std::cout << p_parent->class_name() << std::endl;
58834 : }
58835 : }
58836 : else
58837 : {
58838 0 : std::cout << "SgErrorDirectiveStatement :: " << std::flush;
58839 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
58840 0 : std::cout << " not valid " << std::endl;
58841 : }
58842 : }
58843 :
58844 :
58845 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
58846 :
58847 0 : }
58848 :
58849 :
58850 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
58851 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
58852 : bool
58853 0 : SgErrorDirectiveStatement::isInMemoryPool ()
58854 : {
58855 0 : typedef unsigned char* TestType;
58856 :
58857 0 : bool found = false;
58858 :
58859 0 : ROSE_ASSERT(this != NULL);
58860 :
58861 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
58862 :
58863 0 : TestType tested = (TestType) ( this ) ;
58864 :
58865 0 : std::vector < unsigned char* > :: const_iterator block = SgErrorDirectiveStatement::pools.begin();
58866 :
58867 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
58868 : // while (found == false && block < Memory_Block_List.end())
58869 0 : while ( (found == false) && (block != SgErrorDirectiveStatement::pools.end()) )
58870 : {
58871 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgErrorDirectiveStatement::pool_size * sizeof(SgErrorDirectiveStatement) ) ) ;
58872 0 : ++block;
58873 : }
58874 :
58875 : // Special handling for static data
58876 :
58877 :
58878 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
58879 0 : ROSE_ASSERT(found == true);
58880 :
58881 0 : return found;
58882 : }
58883 : /* #line 58884 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
58884 :
58885 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
58886 :
58887 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
58888 :
58889 : /* #line 58890 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
58890 :
58891 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
58892 :
58893 : void
58894 0 : SgEmptyDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
58895 : {
58896 : // ------------ checking pointers of SgEmptyDirectiveStatement -------------------
58897 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
58898 :
58899 0 : if ( p_definingDeclaration != NULL )
58900 : {
58901 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58902 : {
58903 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
58904 : {
58905 0 : std::cout << "SgEmptyDirectiveStatement :: ";
58906 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
58907 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
58908 : }
58909 : }
58910 : else
58911 : {
58912 0 : std::cout << "SgEmptyDirectiveStatement :: " << std::flush;
58913 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
58914 0 : std::cout << " not valid " << std::endl;
58915 : }
58916 : }
58917 :
58918 0 : if ( p_firstNondefiningDeclaration != NULL )
58919 : {
58920 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58921 : {
58922 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
58923 : {
58924 0 : std::cout << "SgEmptyDirectiveStatement :: ";
58925 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
58926 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
58927 : }
58928 : }
58929 : else
58930 : {
58931 0 : std::cout << "SgEmptyDirectiveStatement :: " << std::flush;
58932 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
58933 0 : std::cout << " not valid " << std::endl;
58934 : }
58935 : }
58936 :
58937 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
58938 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
58939 : {
58940 0 : if ( (*i_qualifiedNameList) != NULL )
58941 : {
58942 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58943 : {
58944 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
58945 : {
58946 0 : std::cout << "SgEmptyDirectiveStatement :: ";
58947 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
58948 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
58949 : }
58950 : }
58951 : else
58952 : {
58953 0 : std::cout << "SgEmptyDirectiveStatement :: " << std::flush;
58954 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
58955 0 : std::cout << " entry not valid " << std::endl;
58956 : }
58957 : }
58958 : else
58959 : {
58960 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
58961 : }
58962 : }
58963 :
58964 0 : if ( p_declarationScope != NULL )
58965 : {
58966 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58967 : {
58968 0 : if ( p_declarationScope->isInMemoryPool() == false )
58969 : {
58970 0 : std::cout << "SgEmptyDirectiveStatement :: ";
58971 0 : std::cout << " p_declarationScope is not in memory pool of ";
58972 0 : std::cout << p_declarationScope->class_name() << std::endl;
58973 : }
58974 : }
58975 : else
58976 : {
58977 0 : std::cout << "SgEmptyDirectiveStatement :: " << std::flush;
58978 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
58979 0 : std::cout << " not valid " << std::endl;
58980 : }
58981 : }
58982 :
58983 0 : if ( p_numeric_label != NULL )
58984 : {
58985 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
58986 : {
58987 0 : if ( p_numeric_label->isInMemoryPool() == false )
58988 : {
58989 0 : std::cout << "SgEmptyDirectiveStatement :: ";
58990 0 : std::cout << " p_numeric_label is not in memory pool of ";
58991 0 : std::cout << p_numeric_label->class_name() << std::endl;
58992 : }
58993 : }
58994 : else
58995 : {
58996 0 : std::cout << "SgEmptyDirectiveStatement :: " << std::flush;
58997 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
58998 0 : std::cout << " not valid " << std::endl;
58999 : }
59000 : }
59001 :
59002 0 : if ( p_startOfConstruct != NULL )
59003 : {
59004 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59005 : {
59006 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
59007 : {
59008 0 : std::cout << "SgEmptyDirectiveStatement :: ";
59009 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
59010 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
59011 : }
59012 : }
59013 : else
59014 : {
59015 0 : std::cout << "SgEmptyDirectiveStatement :: " << std::flush;
59016 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
59017 0 : std::cout << " not valid " << std::endl;
59018 : }
59019 : }
59020 :
59021 0 : if ( p_endOfConstruct != NULL )
59022 : {
59023 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59024 : {
59025 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
59026 : {
59027 0 : std::cout << "SgEmptyDirectiveStatement :: ";
59028 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
59029 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
59030 : }
59031 : }
59032 : else
59033 : {
59034 0 : std::cout << "SgEmptyDirectiveStatement :: " << std::flush;
59035 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
59036 0 : std::cout << " not valid " << std::endl;
59037 : }
59038 : }
59039 :
59040 0 : if ( p_parent != NULL )
59041 : {
59042 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59043 : {
59044 0 : if ( p_parent->isInMemoryPool() == false )
59045 : {
59046 0 : std::cout << "SgEmptyDirectiveStatement :: ";
59047 0 : std::cout << " p_parent is not in memory pool of ";
59048 0 : std::cout << p_parent->class_name() << std::endl;
59049 : }
59050 : }
59051 : else
59052 : {
59053 0 : std::cout << "SgEmptyDirectiveStatement :: " << std::flush;
59054 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
59055 0 : std::cout << " not valid " << std::endl;
59056 : }
59057 : }
59058 :
59059 :
59060 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
59061 :
59062 0 : }
59063 :
59064 :
59065 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
59066 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
59067 : bool
59068 0 : SgEmptyDirectiveStatement::isInMemoryPool ()
59069 : {
59070 0 : typedef unsigned char* TestType;
59071 :
59072 0 : bool found = false;
59073 :
59074 0 : ROSE_ASSERT(this != NULL);
59075 :
59076 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
59077 :
59078 0 : TestType tested = (TestType) ( this ) ;
59079 :
59080 0 : std::vector < unsigned char* > :: const_iterator block = SgEmptyDirectiveStatement::pools.begin();
59081 :
59082 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
59083 : // while (found == false && block < Memory_Block_List.end())
59084 0 : while ( (found == false) && (block != SgEmptyDirectiveStatement::pools.end()) )
59085 : {
59086 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgEmptyDirectiveStatement::pool_size * sizeof(SgEmptyDirectiveStatement) ) ) ;
59087 0 : ++block;
59088 : }
59089 :
59090 : // Special handling for static data
59091 :
59092 :
59093 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
59094 0 : ROSE_ASSERT(found == true);
59095 :
59096 0 : return found;
59097 : }
59098 : /* #line 59099 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
59099 :
59100 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
59101 :
59102 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
59103 :
59104 : /* #line 59105 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
59105 :
59106 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
59107 :
59108 : void
59109 0 : SgIncludeNextDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
59110 : {
59111 : // ------------ checking pointers of SgIncludeNextDirectiveStatement -------------------
59112 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
59113 :
59114 0 : if ( p_definingDeclaration != NULL )
59115 : {
59116 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59117 : {
59118 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
59119 : {
59120 0 : std::cout << "SgIncludeNextDirectiveStatement :: ";
59121 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
59122 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
59123 : }
59124 : }
59125 : else
59126 : {
59127 0 : std::cout << "SgIncludeNextDirectiveStatement :: " << std::flush;
59128 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
59129 0 : std::cout << " not valid " << std::endl;
59130 : }
59131 : }
59132 :
59133 0 : if ( p_firstNondefiningDeclaration != NULL )
59134 : {
59135 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59136 : {
59137 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
59138 : {
59139 0 : std::cout << "SgIncludeNextDirectiveStatement :: ";
59140 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
59141 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
59142 : }
59143 : }
59144 : else
59145 : {
59146 0 : std::cout << "SgIncludeNextDirectiveStatement :: " << std::flush;
59147 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
59148 0 : std::cout << " not valid " << std::endl;
59149 : }
59150 : }
59151 :
59152 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
59153 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
59154 : {
59155 0 : if ( (*i_qualifiedNameList) != NULL )
59156 : {
59157 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59158 : {
59159 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
59160 : {
59161 0 : std::cout << "SgIncludeNextDirectiveStatement :: ";
59162 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
59163 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
59164 : }
59165 : }
59166 : else
59167 : {
59168 0 : std::cout << "SgIncludeNextDirectiveStatement :: " << std::flush;
59169 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
59170 0 : std::cout << " entry not valid " << std::endl;
59171 : }
59172 : }
59173 : else
59174 : {
59175 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
59176 : }
59177 : }
59178 :
59179 0 : if ( p_declarationScope != NULL )
59180 : {
59181 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59182 : {
59183 0 : if ( p_declarationScope->isInMemoryPool() == false )
59184 : {
59185 0 : std::cout << "SgIncludeNextDirectiveStatement :: ";
59186 0 : std::cout << " p_declarationScope is not in memory pool of ";
59187 0 : std::cout << p_declarationScope->class_name() << std::endl;
59188 : }
59189 : }
59190 : else
59191 : {
59192 0 : std::cout << "SgIncludeNextDirectiveStatement :: " << std::flush;
59193 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
59194 0 : std::cout << " not valid " << std::endl;
59195 : }
59196 : }
59197 :
59198 0 : if ( p_numeric_label != NULL )
59199 : {
59200 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59201 : {
59202 0 : if ( p_numeric_label->isInMemoryPool() == false )
59203 : {
59204 0 : std::cout << "SgIncludeNextDirectiveStatement :: ";
59205 0 : std::cout << " p_numeric_label is not in memory pool of ";
59206 0 : std::cout << p_numeric_label->class_name() << std::endl;
59207 : }
59208 : }
59209 : else
59210 : {
59211 0 : std::cout << "SgIncludeNextDirectiveStatement :: " << std::flush;
59212 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
59213 0 : std::cout << " not valid " << std::endl;
59214 : }
59215 : }
59216 :
59217 0 : if ( p_startOfConstruct != NULL )
59218 : {
59219 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59220 : {
59221 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
59222 : {
59223 0 : std::cout << "SgIncludeNextDirectiveStatement :: ";
59224 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
59225 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
59226 : }
59227 : }
59228 : else
59229 : {
59230 0 : std::cout << "SgIncludeNextDirectiveStatement :: " << std::flush;
59231 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
59232 0 : std::cout << " not valid " << std::endl;
59233 : }
59234 : }
59235 :
59236 0 : if ( p_endOfConstruct != NULL )
59237 : {
59238 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59239 : {
59240 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
59241 : {
59242 0 : std::cout << "SgIncludeNextDirectiveStatement :: ";
59243 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
59244 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
59245 : }
59246 : }
59247 : else
59248 : {
59249 0 : std::cout << "SgIncludeNextDirectiveStatement :: " << std::flush;
59250 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
59251 0 : std::cout << " not valid " << std::endl;
59252 : }
59253 : }
59254 :
59255 0 : if ( p_parent != NULL )
59256 : {
59257 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59258 : {
59259 0 : if ( p_parent->isInMemoryPool() == false )
59260 : {
59261 0 : std::cout << "SgIncludeNextDirectiveStatement :: ";
59262 0 : std::cout << " p_parent is not in memory pool of ";
59263 0 : std::cout << p_parent->class_name() << std::endl;
59264 : }
59265 : }
59266 : else
59267 : {
59268 0 : std::cout << "SgIncludeNextDirectiveStatement :: " << std::flush;
59269 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
59270 0 : std::cout << " not valid " << std::endl;
59271 : }
59272 : }
59273 :
59274 :
59275 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
59276 :
59277 0 : }
59278 :
59279 :
59280 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
59281 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
59282 : bool
59283 0 : SgIncludeNextDirectiveStatement::isInMemoryPool ()
59284 : {
59285 0 : typedef unsigned char* TestType;
59286 :
59287 0 : bool found = false;
59288 :
59289 0 : ROSE_ASSERT(this != NULL);
59290 :
59291 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
59292 :
59293 0 : TestType tested = (TestType) ( this ) ;
59294 :
59295 0 : std::vector < unsigned char* > :: const_iterator block = SgIncludeNextDirectiveStatement::pools.begin();
59296 :
59297 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
59298 : // while (found == false && block < Memory_Block_List.end())
59299 0 : while ( (found == false) && (block != SgIncludeNextDirectiveStatement::pools.end()) )
59300 : {
59301 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIncludeNextDirectiveStatement::pool_size * sizeof(SgIncludeNextDirectiveStatement) ) ) ;
59302 0 : ++block;
59303 : }
59304 :
59305 : // Special handling for static data
59306 :
59307 :
59308 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
59309 0 : ROSE_ASSERT(found == true);
59310 :
59311 0 : return found;
59312 : }
59313 : /* #line 59314 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
59314 :
59315 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
59316 :
59317 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
59318 :
59319 : /* #line 59320 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
59320 :
59321 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
59322 :
59323 : void
59324 0 : SgIdentDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
59325 : {
59326 : // ------------ checking pointers of SgIdentDirectiveStatement -------------------
59327 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
59328 :
59329 0 : if ( p_definingDeclaration != NULL )
59330 : {
59331 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59332 : {
59333 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
59334 : {
59335 0 : std::cout << "SgIdentDirectiveStatement :: ";
59336 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
59337 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
59338 : }
59339 : }
59340 : else
59341 : {
59342 0 : std::cout << "SgIdentDirectiveStatement :: " << std::flush;
59343 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
59344 0 : std::cout << " not valid " << std::endl;
59345 : }
59346 : }
59347 :
59348 0 : if ( p_firstNondefiningDeclaration != NULL )
59349 : {
59350 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59351 : {
59352 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
59353 : {
59354 0 : std::cout << "SgIdentDirectiveStatement :: ";
59355 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
59356 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
59357 : }
59358 : }
59359 : else
59360 : {
59361 0 : std::cout << "SgIdentDirectiveStatement :: " << std::flush;
59362 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
59363 0 : std::cout << " not valid " << std::endl;
59364 : }
59365 : }
59366 :
59367 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
59368 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
59369 : {
59370 0 : if ( (*i_qualifiedNameList) != NULL )
59371 : {
59372 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59373 : {
59374 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
59375 : {
59376 0 : std::cout << "SgIdentDirectiveStatement :: ";
59377 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
59378 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
59379 : }
59380 : }
59381 : else
59382 : {
59383 0 : std::cout << "SgIdentDirectiveStatement :: " << std::flush;
59384 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
59385 0 : std::cout << " entry not valid " << std::endl;
59386 : }
59387 : }
59388 : else
59389 : {
59390 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
59391 : }
59392 : }
59393 :
59394 0 : if ( p_declarationScope != NULL )
59395 : {
59396 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59397 : {
59398 0 : if ( p_declarationScope->isInMemoryPool() == false )
59399 : {
59400 0 : std::cout << "SgIdentDirectiveStatement :: ";
59401 0 : std::cout << " p_declarationScope is not in memory pool of ";
59402 0 : std::cout << p_declarationScope->class_name() << std::endl;
59403 : }
59404 : }
59405 : else
59406 : {
59407 0 : std::cout << "SgIdentDirectiveStatement :: " << std::flush;
59408 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
59409 0 : std::cout << " not valid " << std::endl;
59410 : }
59411 : }
59412 :
59413 0 : if ( p_numeric_label != NULL )
59414 : {
59415 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59416 : {
59417 0 : if ( p_numeric_label->isInMemoryPool() == false )
59418 : {
59419 0 : std::cout << "SgIdentDirectiveStatement :: ";
59420 0 : std::cout << " p_numeric_label is not in memory pool of ";
59421 0 : std::cout << p_numeric_label->class_name() << std::endl;
59422 : }
59423 : }
59424 : else
59425 : {
59426 0 : std::cout << "SgIdentDirectiveStatement :: " << std::flush;
59427 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
59428 0 : std::cout << " not valid " << std::endl;
59429 : }
59430 : }
59431 :
59432 0 : if ( p_startOfConstruct != NULL )
59433 : {
59434 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59435 : {
59436 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
59437 : {
59438 0 : std::cout << "SgIdentDirectiveStatement :: ";
59439 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
59440 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
59441 : }
59442 : }
59443 : else
59444 : {
59445 0 : std::cout << "SgIdentDirectiveStatement :: " << std::flush;
59446 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
59447 0 : std::cout << " not valid " << std::endl;
59448 : }
59449 : }
59450 :
59451 0 : if ( p_endOfConstruct != NULL )
59452 : {
59453 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59454 : {
59455 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
59456 : {
59457 0 : std::cout << "SgIdentDirectiveStatement :: ";
59458 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
59459 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
59460 : }
59461 : }
59462 : else
59463 : {
59464 0 : std::cout << "SgIdentDirectiveStatement :: " << std::flush;
59465 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
59466 0 : std::cout << " not valid " << std::endl;
59467 : }
59468 : }
59469 :
59470 0 : if ( p_parent != NULL )
59471 : {
59472 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59473 : {
59474 0 : if ( p_parent->isInMemoryPool() == false )
59475 : {
59476 0 : std::cout << "SgIdentDirectiveStatement :: ";
59477 0 : std::cout << " p_parent is not in memory pool of ";
59478 0 : std::cout << p_parent->class_name() << std::endl;
59479 : }
59480 : }
59481 : else
59482 : {
59483 0 : std::cout << "SgIdentDirectiveStatement :: " << std::flush;
59484 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
59485 0 : std::cout << " not valid " << std::endl;
59486 : }
59487 : }
59488 :
59489 :
59490 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
59491 :
59492 0 : }
59493 :
59494 :
59495 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
59496 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
59497 : bool
59498 0 : SgIdentDirectiveStatement::isInMemoryPool ()
59499 : {
59500 0 : typedef unsigned char* TestType;
59501 :
59502 0 : bool found = false;
59503 :
59504 0 : ROSE_ASSERT(this != NULL);
59505 :
59506 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
59507 :
59508 0 : TestType tested = (TestType) ( this ) ;
59509 :
59510 0 : std::vector < unsigned char* > :: const_iterator block = SgIdentDirectiveStatement::pools.begin();
59511 :
59512 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
59513 : // while (found == false && block < Memory_Block_List.end())
59514 0 : while ( (found == false) && (block != SgIdentDirectiveStatement::pools.end()) )
59515 : {
59516 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIdentDirectiveStatement::pool_size * sizeof(SgIdentDirectiveStatement) ) ) ;
59517 0 : ++block;
59518 : }
59519 :
59520 : // Special handling for static data
59521 :
59522 :
59523 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
59524 0 : ROSE_ASSERT(found == true);
59525 :
59526 0 : return found;
59527 : }
59528 : /* #line 59529 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
59529 :
59530 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
59531 :
59532 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
59533 :
59534 : /* #line 59535 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
59535 :
59536 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
59537 :
59538 : void
59539 0 : SgLinemarkerDirectiveStatement::checkDataMemberPointersIfInMemoryPool()
59540 : {
59541 : // ------------ checking pointers of SgLinemarkerDirectiveStatement -------------------
59542 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
59543 :
59544 0 : if ( p_definingDeclaration != NULL )
59545 : {
59546 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59547 : {
59548 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
59549 : {
59550 0 : std::cout << "SgLinemarkerDirectiveStatement :: ";
59551 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
59552 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
59553 : }
59554 : }
59555 : else
59556 : {
59557 0 : std::cout << "SgLinemarkerDirectiveStatement :: " << std::flush;
59558 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
59559 0 : std::cout << " not valid " << std::endl;
59560 : }
59561 : }
59562 :
59563 0 : if ( p_firstNondefiningDeclaration != NULL )
59564 : {
59565 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59566 : {
59567 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
59568 : {
59569 0 : std::cout << "SgLinemarkerDirectiveStatement :: ";
59570 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
59571 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
59572 : }
59573 : }
59574 : else
59575 : {
59576 0 : std::cout << "SgLinemarkerDirectiveStatement :: " << std::flush;
59577 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
59578 0 : std::cout << " not valid " << std::endl;
59579 : }
59580 : }
59581 :
59582 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
59583 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
59584 : {
59585 0 : if ( (*i_qualifiedNameList) != NULL )
59586 : {
59587 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59588 : {
59589 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
59590 : {
59591 0 : std::cout << "SgLinemarkerDirectiveStatement :: ";
59592 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
59593 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
59594 : }
59595 : }
59596 : else
59597 : {
59598 0 : std::cout << "SgLinemarkerDirectiveStatement :: " << std::flush;
59599 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
59600 0 : std::cout << " entry not valid " << std::endl;
59601 : }
59602 : }
59603 : else
59604 : {
59605 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
59606 : }
59607 : }
59608 :
59609 0 : if ( p_declarationScope != NULL )
59610 : {
59611 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59612 : {
59613 0 : if ( p_declarationScope->isInMemoryPool() == false )
59614 : {
59615 0 : std::cout << "SgLinemarkerDirectiveStatement :: ";
59616 0 : std::cout << " p_declarationScope is not in memory pool of ";
59617 0 : std::cout << p_declarationScope->class_name() << std::endl;
59618 : }
59619 : }
59620 : else
59621 : {
59622 0 : std::cout << "SgLinemarkerDirectiveStatement :: " << std::flush;
59623 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
59624 0 : std::cout << " not valid " << std::endl;
59625 : }
59626 : }
59627 :
59628 0 : if ( p_numeric_label != NULL )
59629 : {
59630 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59631 : {
59632 0 : if ( p_numeric_label->isInMemoryPool() == false )
59633 : {
59634 0 : std::cout << "SgLinemarkerDirectiveStatement :: ";
59635 0 : std::cout << " p_numeric_label is not in memory pool of ";
59636 0 : std::cout << p_numeric_label->class_name() << std::endl;
59637 : }
59638 : }
59639 : else
59640 : {
59641 0 : std::cout << "SgLinemarkerDirectiveStatement :: " << std::flush;
59642 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
59643 0 : std::cout << " not valid " << std::endl;
59644 : }
59645 : }
59646 :
59647 0 : if ( p_startOfConstruct != NULL )
59648 : {
59649 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59650 : {
59651 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
59652 : {
59653 0 : std::cout << "SgLinemarkerDirectiveStatement :: ";
59654 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
59655 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
59656 : }
59657 : }
59658 : else
59659 : {
59660 0 : std::cout << "SgLinemarkerDirectiveStatement :: " << std::flush;
59661 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
59662 0 : std::cout << " not valid " << std::endl;
59663 : }
59664 : }
59665 :
59666 0 : if ( p_endOfConstruct != NULL )
59667 : {
59668 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59669 : {
59670 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
59671 : {
59672 0 : std::cout << "SgLinemarkerDirectiveStatement :: ";
59673 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
59674 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
59675 : }
59676 : }
59677 : else
59678 : {
59679 0 : std::cout << "SgLinemarkerDirectiveStatement :: " << std::flush;
59680 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
59681 0 : std::cout << " not valid " << std::endl;
59682 : }
59683 : }
59684 :
59685 0 : if ( p_parent != NULL )
59686 : {
59687 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59688 : {
59689 0 : if ( p_parent->isInMemoryPool() == false )
59690 : {
59691 0 : std::cout << "SgLinemarkerDirectiveStatement :: ";
59692 0 : std::cout << " p_parent is not in memory pool of ";
59693 0 : std::cout << p_parent->class_name() << std::endl;
59694 : }
59695 : }
59696 : else
59697 : {
59698 0 : std::cout << "SgLinemarkerDirectiveStatement :: " << std::flush;
59699 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
59700 0 : std::cout << " not valid " << std::endl;
59701 : }
59702 : }
59703 :
59704 :
59705 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
59706 :
59707 0 : }
59708 :
59709 :
59710 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
59711 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
59712 : bool
59713 0 : SgLinemarkerDirectiveStatement::isInMemoryPool ()
59714 : {
59715 0 : typedef unsigned char* TestType;
59716 :
59717 0 : bool found = false;
59718 :
59719 0 : ROSE_ASSERT(this != NULL);
59720 :
59721 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
59722 :
59723 0 : TestType tested = (TestType) ( this ) ;
59724 :
59725 0 : std::vector < unsigned char* > :: const_iterator block = SgLinemarkerDirectiveStatement::pools.begin();
59726 :
59727 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
59728 : // while (found == false && block < Memory_Block_List.end())
59729 0 : while ( (found == false) && (block != SgLinemarkerDirectiveStatement::pools.end()) )
59730 : {
59731 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLinemarkerDirectiveStatement::pool_size * sizeof(SgLinemarkerDirectiveStatement) ) ) ;
59732 0 : ++block;
59733 : }
59734 :
59735 : // Special handling for static data
59736 :
59737 :
59738 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
59739 0 : ROSE_ASSERT(found == true);
59740 :
59741 0 : return found;
59742 : }
59743 : /* #line 59744 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
59744 :
59745 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
59746 :
59747 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
59748 :
59749 : /* #line 59750 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
59750 :
59751 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
59752 :
59753 : void
59754 0 : SgOmpThreadprivateStatement::checkDataMemberPointersIfInMemoryPool()
59755 : {
59756 : // ------------ checking pointers of SgOmpThreadprivateStatement -------------------
59757 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
59758 :
59759 0 : SgVarRefExpPtrList::iterator i_variables = p_variables.begin() ;
59760 0 : for ( ; i_variables != p_variables.end(); ++i_variables )
59761 : {
59762 0 : if ( (*i_variables) != NULL )
59763 : {
59764 0 : if ( (*i_variables)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59765 : {
59766 0 : if ( (*i_variables)->isInMemoryPool() == false )
59767 : {
59768 0 : std::cout << "SgOmpThreadprivateStatement :: ";
59769 0 : std::cout << " p_variables ( list of poitners to IR nodes ), entry is not in memory pool of ";
59770 0 : std::cout << (*i_variables)->class_name() << std::endl;
59771 : }
59772 : }
59773 : else
59774 : {
59775 0 : std::cout << "SgOmpThreadprivateStatement :: " << std::flush;
59776 0 : std::cout << "SgVarRefExpPtrList p_variables --> " << std::flush;
59777 0 : std::cout << " entry not valid " << std::endl;
59778 : }
59779 : }
59780 : else
59781 : {
59782 0 : std::cout << "SgVarRefExpPtrList p_variables --> NULL " << std::endl;
59783 : }
59784 : }
59785 :
59786 0 : if ( p_definingDeclaration != NULL )
59787 : {
59788 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59789 : {
59790 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
59791 : {
59792 0 : std::cout << "SgOmpThreadprivateStatement :: ";
59793 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
59794 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
59795 : }
59796 : }
59797 : else
59798 : {
59799 0 : std::cout << "SgOmpThreadprivateStatement :: " << std::flush;
59800 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
59801 0 : std::cout << " not valid " << std::endl;
59802 : }
59803 : }
59804 :
59805 0 : if ( p_firstNondefiningDeclaration != NULL )
59806 : {
59807 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59808 : {
59809 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
59810 : {
59811 0 : std::cout << "SgOmpThreadprivateStatement :: ";
59812 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
59813 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
59814 : }
59815 : }
59816 : else
59817 : {
59818 0 : std::cout << "SgOmpThreadprivateStatement :: " << std::flush;
59819 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
59820 0 : std::cout << " not valid " << std::endl;
59821 : }
59822 : }
59823 :
59824 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
59825 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
59826 : {
59827 0 : if ( (*i_qualifiedNameList) != NULL )
59828 : {
59829 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59830 : {
59831 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
59832 : {
59833 0 : std::cout << "SgOmpThreadprivateStatement :: ";
59834 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
59835 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
59836 : }
59837 : }
59838 : else
59839 : {
59840 0 : std::cout << "SgOmpThreadprivateStatement :: " << std::flush;
59841 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
59842 0 : std::cout << " entry not valid " << std::endl;
59843 : }
59844 : }
59845 : else
59846 : {
59847 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
59848 : }
59849 : }
59850 :
59851 0 : if ( p_declarationScope != NULL )
59852 : {
59853 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59854 : {
59855 0 : if ( p_declarationScope->isInMemoryPool() == false )
59856 : {
59857 0 : std::cout << "SgOmpThreadprivateStatement :: ";
59858 0 : std::cout << " p_declarationScope is not in memory pool of ";
59859 0 : std::cout << p_declarationScope->class_name() << std::endl;
59860 : }
59861 : }
59862 : else
59863 : {
59864 0 : std::cout << "SgOmpThreadprivateStatement :: " << std::flush;
59865 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
59866 0 : std::cout << " not valid " << std::endl;
59867 : }
59868 : }
59869 :
59870 0 : if ( p_numeric_label != NULL )
59871 : {
59872 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59873 : {
59874 0 : if ( p_numeric_label->isInMemoryPool() == false )
59875 : {
59876 0 : std::cout << "SgOmpThreadprivateStatement :: ";
59877 0 : std::cout << " p_numeric_label is not in memory pool of ";
59878 0 : std::cout << p_numeric_label->class_name() << std::endl;
59879 : }
59880 : }
59881 : else
59882 : {
59883 0 : std::cout << "SgOmpThreadprivateStatement :: " << std::flush;
59884 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
59885 0 : std::cout << " not valid " << std::endl;
59886 : }
59887 : }
59888 :
59889 0 : if ( p_startOfConstruct != NULL )
59890 : {
59891 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59892 : {
59893 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
59894 : {
59895 0 : std::cout << "SgOmpThreadprivateStatement :: ";
59896 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
59897 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
59898 : }
59899 : }
59900 : else
59901 : {
59902 0 : std::cout << "SgOmpThreadprivateStatement :: " << std::flush;
59903 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
59904 0 : std::cout << " not valid " << std::endl;
59905 : }
59906 : }
59907 :
59908 0 : if ( p_endOfConstruct != NULL )
59909 : {
59910 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59911 : {
59912 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
59913 : {
59914 0 : std::cout << "SgOmpThreadprivateStatement :: ";
59915 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
59916 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
59917 : }
59918 : }
59919 : else
59920 : {
59921 0 : std::cout << "SgOmpThreadprivateStatement :: " << std::flush;
59922 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
59923 0 : std::cout << " not valid " << std::endl;
59924 : }
59925 : }
59926 :
59927 0 : if ( p_parent != NULL )
59928 : {
59929 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
59930 : {
59931 0 : if ( p_parent->isInMemoryPool() == false )
59932 : {
59933 0 : std::cout << "SgOmpThreadprivateStatement :: ";
59934 0 : std::cout << " p_parent is not in memory pool of ";
59935 0 : std::cout << p_parent->class_name() << std::endl;
59936 : }
59937 : }
59938 : else
59939 : {
59940 0 : std::cout << "SgOmpThreadprivateStatement :: " << std::flush;
59941 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
59942 0 : std::cout << " not valid " << std::endl;
59943 : }
59944 : }
59945 :
59946 :
59947 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
59948 :
59949 0 : }
59950 :
59951 :
59952 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
59953 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
59954 : bool
59955 0 : SgOmpThreadprivateStatement::isInMemoryPool ()
59956 : {
59957 0 : typedef unsigned char* TestType;
59958 :
59959 0 : bool found = false;
59960 :
59961 0 : ROSE_ASSERT(this != NULL);
59962 :
59963 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
59964 :
59965 0 : TestType tested = (TestType) ( this ) ;
59966 :
59967 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpThreadprivateStatement::pools.begin();
59968 :
59969 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
59970 : // while (found == false && block < Memory_Block_List.end())
59971 0 : while ( (found == false) && (block != SgOmpThreadprivateStatement::pools.end()) )
59972 : {
59973 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpThreadprivateStatement::pool_size * sizeof(SgOmpThreadprivateStatement) ) ) ;
59974 0 : ++block;
59975 : }
59976 :
59977 : // Special handling for static data
59978 :
59979 :
59980 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
59981 0 : ROSE_ASSERT(found == true);
59982 :
59983 0 : return found;
59984 : }
59985 : /* #line 59986 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
59986 :
59987 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
59988 :
59989 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
59990 :
59991 : /* #line 59992 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
59992 :
59993 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
59994 :
59995 : void
59996 0 : SgOmpRequiresStatement::checkDataMemberPointersIfInMemoryPool()
59997 : {
59998 : // ------------ checking pointers of SgOmpRequiresStatement -------------------
59999 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
60000 :
60001 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
60002 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
60003 : {
60004 0 : if ( (*i_clauses) != NULL )
60005 : {
60006 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60007 : {
60008 0 : if ( (*i_clauses)->isInMemoryPool() == false )
60009 : {
60010 0 : std::cout << "SgOmpRequiresStatement :: ";
60011 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
60012 0 : std::cout << (*i_clauses)->class_name() << std::endl;
60013 : }
60014 : }
60015 : else
60016 : {
60017 0 : std::cout << "SgOmpRequiresStatement :: " << std::flush;
60018 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
60019 0 : std::cout << " entry not valid " << std::endl;
60020 : }
60021 : }
60022 : else
60023 : {
60024 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
60025 : }
60026 : }
60027 :
60028 0 : if ( p_definingDeclaration != NULL )
60029 : {
60030 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60031 : {
60032 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
60033 : {
60034 0 : std::cout << "SgOmpRequiresStatement :: ";
60035 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
60036 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
60037 : }
60038 : }
60039 : else
60040 : {
60041 0 : std::cout << "SgOmpRequiresStatement :: " << std::flush;
60042 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
60043 0 : std::cout << " not valid " << std::endl;
60044 : }
60045 : }
60046 :
60047 0 : if ( p_firstNondefiningDeclaration != NULL )
60048 : {
60049 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60050 : {
60051 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
60052 : {
60053 0 : std::cout << "SgOmpRequiresStatement :: ";
60054 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
60055 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
60056 : }
60057 : }
60058 : else
60059 : {
60060 0 : std::cout << "SgOmpRequiresStatement :: " << std::flush;
60061 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
60062 0 : std::cout << " not valid " << std::endl;
60063 : }
60064 : }
60065 :
60066 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
60067 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
60068 : {
60069 0 : if ( (*i_qualifiedNameList) != NULL )
60070 : {
60071 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60072 : {
60073 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
60074 : {
60075 0 : std::cout << "SgOmpRequiresStatement :: ";
60076 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
60077 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
60078 : }
60079 : }
60080 : else
60081 : {
60082 0 : std::cout << "SgOmpRequiresStatement :: " << std::flush;
60083 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
60084 0 : std::cout << " entry not valid " << std::endl;
60085 : }
60086 : }
60087 : else
60088 : {
60089 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
60090 : }
60091 : }
60092 :
60093 0 : if ( p_declarationScope != NULL )
60094 : {
60095 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60096 : {
60097 0 : if ( p_declarationScope->isInMemoryPool() == false )
60098 : {
60099 0 : std::cout << "SgOmpRequiresStatement :: ";
60100 0 : std::cout << " p_declarationScope is not in memory pool of ";
60101 0 : std::cout << p_declarationScope->class_name() << std::endl;
60102 : }
60103 : }
60104 : else
60105 : {
60106 0 : std::cout << "SgOmpRequiresStatement :: " << std::flush;
60107 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
60108 0 : std::cout << " not valid " << std::endl;
60109 : }
60110 : }
60111 :
60112 0 : if ( p_numeric_label != NULL )
60113 : {
60114 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60115 : {
60116 0 : if ( p_numeric_label->isInMemoryPool() == false )
60117 : {
60118 0 : std::cout << "SgOmpRequiresStatement :: ";
60119 0 : std::cout << " p_numeric_label is not in memory pool of ";
60120 0 : std::cout << p_numeric_label->class_name() << std::endl;
60121 : }
60122 : }
60123 : else
60124 : {
60125 0 : std::cout << "SgOmpRequiresStatement :: " << std::flush;
60126 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
60127 0 : std::cout << " not valid " << std::endl;
60128 : }
60129 : }
60130 :
60131 0 : if ( p_startOfConstruct != NULL )
60132 : {
60133 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60134 : {
60135 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
60136 : {
60137 0 : std::cout << "SgOmpRequiresStatement :: ";
60138 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
60139 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
60140 : }
60141 : }
60142 : else
60143 : {
60144 0 : std::cout << "SgOmpRequiresStatement :: " << std::flush;
60145 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
60146 0 : std::cout << " not valid " << std::endl;
60147 : }
60148 : }
60149 :
60150 0 : if ( p_endOfConstruct != NULL )
60151 : {
60152 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60153 : {
60154 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
60155 : {
60156 0 : std::cout << "SgOmpRequiresStatement :: ";
60157 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
60158 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
60159 : }
60160 : }
60161 : else
60162 : {
60163 0 : std::cout << "SgOmpRequiresStatement :: " << std::flush;
60164 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
60165 0 : std::cout << " not valid " << std::endl;
60166 : }
60167 : }
60168 :
60169 0 : if ( p_parent != NULL )
60170 : {
60171 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60172 : {
60173 0 : if ( p_parent->isInMemoryPool() == false )
60174 : {
60175 0 : std::cout << "SgOmpRequiresStatement :: ";
60176 0 : std::cout << " p_parent is not in memory pool of ";
60177 0 : std::cout << p_parent->class_name() << std::endl;
60178 : }
60179 : }
60180 : else
60181 : {
60182 0 : std::cout << "SgOmpRequiresStatement :: " << std::flush;
60183 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
60184 0 : std::cout << " not valid " << std::endl;
60185 : }
60186 : }
60187 :
60188 :
60189 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
60190 :
60191 0 : }
60192 :
60193 :
60194 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
60195 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
60196 : bool
60197 0 : SgOmpRequiresStatement::isInMemoryPool ()
60198 : {
60199 0 : typedef unsigned char* TestType;
60200 :
60201 0 : bool found = false;
60202 :
60203 0 : ROSE_ASSERT(this != NULL);
60204 :
60205 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
60206 :
60207 0 : TestType tested = (TestType) ( this ) ;
60208 :
60209 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpRequiresStatement::pools.begin();
60210 :
60211 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
60212 : // while (found == false && block < Memory_Block_List.end())
60213 0 : while ( (found == false) && (block != SgOmpRequiresStatement::pools.end()) )
60214 : {
60215 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpRequiresStatement::pool_size * sizeof(SgOmpRequiresStatement) ) ) ;
60216 0 : ++block;
60217 : }
60218 :
60219 : // Special handling for static data
60220 :
60221 :
60222 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
60223 0 : ROSE_ASSERT(found == true);
60224 :
60225 0 : return found;
60226 : }
60227 : /* #line 60228 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
60228 :
60229 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
60230 :
60231 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
60232 :
60233 : /* #line 60234 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
60234 :
60235 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
60236 :
60237 : void
60238 0 : SgFortranIncludeLine::checkDataMemberPointersIfInMemoryPool()
60239 : {
60240 : // ------------ checking pointers of SgFortranIncludeLine -------------------
60241 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
60242 :
60243 0 : if ( p_definingDeclaration != NULL )
60244 : {
60245 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60246 : {
60247 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
60248 : {
60249 0 : std::cout << "SgFortranIncludeLine :: ";
60250 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
60251 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
60252 : }
60253 : }
60254 : else
60255 : {
60256 0 : std::cout << "SgFortranIncludeLine :: " << std::flush;
60257 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
60258 0 : std::cout << " not valid " << std::endl;
60259 : }
60260 : }
60261 :
60262 0 : if ( p_firstNondefiningDeclaration != NULL )
60263 : {
60264 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60265 : {
60266 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
60267 : {
60268 0 : std::cout << "SgFortranIncludeLine :: ";
60269 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
60270 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
60271 : }
60272 : }
60273 : else
60274 : {
60275 0 : std::cout << "SgFortranIncludeLine :: " << std::flush;
60276 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
60277 0 : std::cout << " not valid " << std::endl;
60278 : }
60279 : }
60280 :
60281 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
60282 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
60283 : {
60284 0 : if ( (*i_qualifiedNameList) != NULL )
60285 : {
60286 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60287 : {
60288 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
60289 : {
60290 0 : std::cout << "SgFortranIncludeLine :: ";
60291 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
60292 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
60293 : }
60294 : }
60295 : else
60296 : {
60297 0 : std::cout << "SgFortranIncludeLine :: " << std::flush;
60298 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
60299 0 : std::cout << " entry not valid " << std::endl;
60300 : }
60301 : }
60302 : else
60303 : {
60304 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
60305 : }
60306 : }
60307 :
60308 0 : if ( p_declarationScope != NULL )
60309 : {
60310 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60311 : {
60312 0 : if ( p_declarationScope->isInMemoryPool() == false )
60313 : {
60314 0 : std::cout << "SgFortranIncludeLine :: ";
60315 0 : std::cout << " p_declarationScope is not in memory pool of ";
60316 0 : std::cout << p_declarationScope->class_name() << std::endl;
60317 : }
60318 : }
60319 : else
60320 : {
60321 0 : std::cout << "SgFortranIncludeLine :: " << std::flush;
60322 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
60323 0 : std::cout << " not valid " << std::endl;
60324 : }
60325 : }
60326 :
60327 0 : if ( p_numeric_label != NULL )
60328 : {
60329 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60330 : {
60331 0 : if ( p_numeric_label->isInMemoryPool() == false )
60332 : {
60333 0 : std::cout << "SgFortranIncludeLine :: ";
60334 0 : std::cout << " p_numeric_label is not in memory pool of ";
60335 0 : std::cout << p_numeric_label->class_name() << std::endl;
60336 : }
60337 : }
60338 : else
60339 : {
60340 0 : std::cout << "SgFortranIncludeLine :: " << std::flush;
60341 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
60342 0 : std::cout << " not valid " << std::endl;
60343 : }
60344 : }
60345 :
60346 0 : if ( p_startOfConstruct != NULL )
60347 : {
60348 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60349 : {
60350 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
60351 : {
60352 0 : std::cout << "SgFortranIncludeLine :: ";
60353 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
60354 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
60355 : }
60356 : }
60357 : else
60358 : {
60359 0 : std::cout << "SgFortranIncludeLine :: " << std::flush;
60360 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
60361 0 : std::cout << " not valid " << std::endl;
60362 : }
60363 : }
60364 :
60365 0 : if ( p_endOfConstruct != NULL )
60366 : {
60367 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60368 : {
60369 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
60370 : {
60371 0 : std::cout << "SgFortranIncludeLine :: ";
60372 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
60373 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
60374 : }
60375 : }
60376 : else
60377 : {
60378 0 : std::cout << "SgFortranIncludeLine :: " << std::flush;
60379 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
60380 0 : std::cout << " not valid " << std::endl;
60381 : }
60382 : }
60383 :
60384 0 : if ( p_parent != NULL )
60385 : {
60386 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60387 : {
60388 0 : if ( p_parent->isInMemoryPool() == false )
60389 : {
60390 0 : std::cout << "SgFortranIncludeLine :: ";
60391 0 : std::cout << " p_parent is not in memory pool of ";
60392 0 : std::cout << p_parent->class_name() << std::endl;
60393 : }
60394 : }
60395 : else
60396 : {
60397 0 : std::cout << "SgFortranIncludeLine :: " << std::flush;
60398 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
60399 0 : std::cout << " not valid " << std::endl;
60400 : }
60401 : }
60402 :
60403 :
60404 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
60405 :
60406 0 : }
60407 :
60408 :
60409 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
60410 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
60411 : bool
60412 0 : SgFortranIncludeLine::isInMemoryPool ()
60413 : {
60414 0 : typedef unsigned char* TestType;
60415 :
60416 0 : bool found = false;
60417 :
60418 0 : ROSE_ASSERT(this != NULL);
60419 :
60420 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
60421 :
60422 0 : TestType tested = (TestType) ( this ) ;
60423 :
60424 0 : std::vector < unsigned char* > :: const_iterator block = SgFortranIncludeLine::pools.begin();
60425 :
60426 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
60427 : // while (found == false && block < Memory_Block_List.end())
60428 0 : while ( (found == false) && (block != SgFortranIncludeLine::pools.end()) )
60429 : {
60430 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFortranIncludeLine::pool_size * sizeof(SgFortranIncludeLine) ) ) ;
60431 0 : ++block;
60432 : }
60433 :
60434 : // Special handling for static data
60435 :
60436 :
60437 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
60438 0 : ROSE_ASSERT(found == true);
60439 :
60440 0 : return found;
60441 : }
60442 : /* #line 60443 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
60443 :
60444 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
60445 :
60446 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
60447 :
60448 : /* #line 60449 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
60449 :
60450 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
60451 :
60452 : void
60453 0 : SgOmpTaskwaitStatement::checkDataMemberPointersIfInMemoryPool()
60454 : {
60455 : // ------------ checking pointers of SgOmpTaskwaitStatement -------------------
60456 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
60457 :
60458 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
60459 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
60460 : {
60461 0 : if ( (*i_clauses) != NULL )
60462 : {
60463 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60464 : {
60465 0 : if ( (*i_clauses)->isInMemoryPool() == false )
60466 : {
60467 0 : std::cout << "SgOmpTaskwaitStatement :: ";
60468 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
60469 0 : std::cout << (*i_clauses)->class_name() << std::endl;
60470 : }
60471 : }
60472 : else
60473 : {
60474 0 : std::cout << "SgOmpTaskwaitStatement :: " << std::flush;
60475 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
60476 0 : std::cout << " entry not valid " << std::endl;
60477 : }
60478 : }
60479 : else
60480 : {
60481 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
60482 : }
60483 : }
60484 :
60485 0 : if ( p_definingDeclaration != NULL )
60486 : {
60487 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60488 : {
60489 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
60490 : {
60491 0 : std::cout << "SgOmpTaskwaitStatement :: ";
60492 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
60493 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
60494 : }
60495 : }
60496 : else
60497 : {
60498 0 : std::cout << "SgOmpTaskwaitStatement :: " << std::flush;
60499 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
60500 0 : std::cout << " not valid " << std::endl;
60501 : }
60502 : }
60503 :
60504 0 : if ( p_firstNondefiningDeclaration != NULL )
60505 : {
60506 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60507 : {
60508 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
60509 : {
60510 0 : std::cout << "SgOmpTaskwaitStatement :: ";
60511 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
60512 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
60513 : }
60514 : }
60515 : else
60516 : {
60517 0 : std::cout << "SgOmpTaskwaitStatement :: " << std::flush;
60518 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
60519 0 : std::cout << " not valid " << std::endl;
60520 : }
60521 : }
60522 :
60523 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
60524 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
60525 : {
60526 0 : if ( (*i_qualifiedNameList) != NULL )
60527 : {
60528 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60529 : {
60530 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
60531 : {
60532 0 : std::cout << "SgOmpTaskwaitStatement :: ";
60533 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
60534 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
60535 : }
60536 : }
60537 : else
60538 : {
60539 0 : std::cout << "SgOmpTaskwaitStatement :: " << std::flush;
60540 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
60541 0 : std::cout << " entry not valid " << std::endl;
60542 : }
60543 : }
60544 : else
60545 : {
60546 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
60547 : }
60548 : }
60549 :
60550 0 : if ( p_declarationScope != NULL )
60551 : {
60552 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60553 : {
60554 0 : if ( p_declarationScope->isInMemoryPool() == false )
60555 : {
60556 0 : std::cout << "SgOmpTaskwaitStatement :: ";
60557 0 : std::cout << " p_declarationScope is not in memory pool of ";
60558 0 : std::cout << p_declarationScope->class_name() << std::endl;
60559 : }
60560 : }
60561 : else
60562 : {
60563 0 : std::cout << "SgOmpTaskwaitStatement :: " << std::flush;
60564 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
60565 0 : std::cout << " not valid " << std::endl;
60566 : }
60567 : }
60568 :
60569 0 : if ( p_numeric_label != NULL )
60570 : {
60571 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60572 : {
60573 0 : if ( p_numeric_label->isInMemoryPool() == false )
60574 : {
60575 0 : std::cout << "SgOmpTaskwaitStatement :: ";
60576 0 : std::cout << " p_numeric_label is not in memory pool of ";
60577 0 : std::cout << p_numeric_label->class_name() << std::endl;
60578 : }
60579 : }
60580 : else
60581 : {
60582 0 : std::cout << "SgOmpTaskwaitStatement :: " << std::flush;
60583 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
60584 0 : std::cout << " not valid " << std::endl;
60585 : }
60586 : }
60587 :
60588 0 : if ( p_startOfConstruct != NULL )
60589 : {
60590 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60591 : {
60592 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
60593 : {
60594 0 : std::cout << "SgOmpTaskwaitStatement :: ";
60595 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
60596 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
60597 : }
60598 : }
60599 : else
60600 : {
60601 0 : std::cout << "SgOmpTaskwaitStatement :: " << std::flush;
60602 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
60603 0 : std::cout << " not valid " << std::endl;
60604 : }
60605 : }
60606 :
60607 0 : if ( p_endOfConstruct != NULL )
60608 : {
60609 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60610 : {
60611 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
60612 : {
60613 0 : std::cout << "SgOmpTaskwaitStatement :: ";
60614 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
60615 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
60616 : }
60617 : }
60618 : else
60619 : {
60620 0 : std::cout << "SgOmpTaskwaitStatement :: " << std::flush;
60621 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
60622 0 : std::cout << " not valid " << std::endl;
60623 : }
60624 : }
60625 :
60626 0 : if ( p_parent != NULL )
60627 : {
60628 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60629 : {
60630 0 : if ( p_parent->isInMemoryPool() == false )
60631 : {
60632 0 : std::cout << "SgOmpTaskwaitStatement :: ";
60633 0 : std::cout << " p_parent is not in memory pool of ";
60634 0 : std::cout << p_parent->class_name() << std::endl;
60635 : }
60636 : }
60637 : else
60638 : {
60639 0 : std::cout << "SgOmpTaskwaitStatement :: " << std::flush;
60640 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
60641 0 : std::cout << " not valid " << std::endl;
60642 : }
60643 : }
60644 :
60645 :
60646 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
60647 :
60648 0 : }
60649 :
60650 :
60651 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
60652 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
60653 : bool
60654 0 : SgOmpTaskwaitStatement::isInMemoryPool ()
60655 : {
60656 0 : typedef unsigned char* TestType;
60657 :
60658 0 : bool found = false;
60659 :
60660 0 : ROSE_ASSERT(this != NULL);
60661 :
60662 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
60663 :
60664 0 : TestType tested = (TestType) ( this ) ;
60665 :
60666 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTaskwaitStatement::pools.begin();
60667 :
60668 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
60669 : // while (found == false && block < Memory_Block_List.end())
60670 0 : while ( (found == false) && (block != SgOmpTaskwaitStatement::pools.end()) )
60671 : {
60672 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTaskwaitStatement::pool_size * sizeof(SgOmpTaskwaitStatement) ) ) ;
60673 0 : ++block;
60674 : }
60675 :
60676 : // Special handling for static data
60677 :
60678 :
60679 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
60680 0 : ROSE_ASSERT(found == true);
60681 :
60682 0 : return found;
60683 : }
60684 : /* #line 60685 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
60685 :
60686 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
60687 :
60688 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
60689 :
60690 : /* #line 60691 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
60691 :
60692 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
60693 :
60694 : void
60695 0 : SgStmtDeclarationStatement::checkDataMemberPointersIfInMemoryPool()
60696 : {
60697 : // ------------ checking pointers of SgStmtDeclarationStatement -------------------
60698 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
60699 :
60700 0 : if ( p_statement != NULL )
60701 : {
60702 0 : if ( p_statement->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60703 : {
60704 0 : if ( p_statement->isInMemoryPool() == false )
60705 : {
60706 0 : std::cout << "SgStmtDeclarationStatement :: ";
60707 0 : std::cout << " p_statement is not in memory pool of ";
60708 0 : std::cout << p_statement->class_name() << std::endl;
60709 : }
60710 : }
60711 : else
60712 : {
60713 0 : std::cout << "SgStmtDeclarationStatement :: " << std::flush;
60714 0 : std::cout << "SgStatement* p_statement = " << p_statement << " --> " << std::flush;
60715 0 : std::cout << " not valid " << std::endl;
60716 : }
60717 : }
60718 :
60719 0 : if ( p_definingDeclaration != NULL )
60720 : {
60721 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60722 : {
60723 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
60724 : {
60725 0 : std::cout << "SgStmtDeclarationStatement :: ";
60726 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
60727 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
60728 : }
60729 : }
60730 : else
60731 : {
60732 0 : std::cout << "SgStmtDeclarationStatement :: " << std::flush;
60733 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
60734 0 : std::cout << " not valid " << std::endl;
60735 : }
60736 : }
60737 :
60738 0 : if ( p_firstNondefiningDeclaration != NULL )
60739 : {
60740 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60741 : {
60742 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
60743 : {
60744 0 : std::cout << "SgStmtDeclarationStatement :: ";
60745 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
60746 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
60747 : }
60748 : }
60749 : else
60750 : {
60751 0 : std::cout << "SgStmtDeclarationStatement :: " << std::flush;
60752 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
60753 0 : std::cout << " not valid " << std::endl;
60754 : }
60755 : }
60756 :
60757 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
60758 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
60759 : {
60760 0 : if ( (*i_qualifiedNameList) != NULL )
60761 : {
60762 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60763 : {
60764 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
60765 : {
60766 0 : std::cout << "SgStmtDeclarationStatement :: ";
60767 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
60768 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
60769 : }
60770 : }
60771 : else
60772 : {
60773 0 : std::cout << "SgStmtDeclarationStatement :: " << std::flush;
60774 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
60775 0 : std::cout << " entry not valid " << std::endl;
60776 : }
60777 : }
60778 : else
60779 : {
60780 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
60781 : }
60782 : }
60783 :
60784 0 : if ( p_declarationScope != NULL )
60785 : {
60786 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60787 : {
60788 0 : if ( p_declarationScope->isInMemoryPool() == false )
60789 : {
60790 0 : std::cout << "SgStmtDeclarationStatement :: ";
60791 0 : std::cout << " p_declarationScope is not in memory pool of ";
60792 0 : std::cout << p_declarationScope->class_name() << std::endl;
60793 : }
60794 : }
60795 : else
60796 : {
60797 0 : std::cout << "SgStmtDeclarationStatement :: " << std::flush;
60798 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
60799 0 : std::cout << " not valid " << std::endl;
60800 : }
60801 : }
60802 :
60803 0 : if ( p_numeric_label != NULL )
60804 : {
60805 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60806 : {
60807 0 : if ( p_numeric_label->isInMemoryPool() == false )
60808 : {
60809 0 : std::cout << "SgStmtDeclarationStatement :: ";
60810 0 : std::cout << " p_numeric_label is not in memory pool of ";
60811 0 : std::cout << p_numeric_label->class_name() << std::endl;
60812 : }
60813 : }
60814 : else
60815 : {
60816 0 : std::cout << "SgStmtDeclarationStatement :: " << std::flush;
60817 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
60818 0 : std::cout << " not valid " << std::endl;
60819 : }
60820 : }
60821 :
60822 0 : if ( p_startOfConstruct != NULL )
60823 : {
60824 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60825 : {
60826 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
60827 : {
60828 0 : std::cout << "SgStmtDeclarationStatement :: ";
60829 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
60830 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
60831 : }
60832 : }
60833 : else
60834 : {
60835 0 : std::cout << "SgStmtDeclarationStatement :: " << std::flush;
60836 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
60837 0 : std::cout << " not valid " << std::endl;
60838 : }
60839 : }
60840 :
60841 0 : if ( p_endOfConstruct != NULL )
60842 : {
60843 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60844 : {
60845 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
60846 : {
60847 0 : std::cout << "SgStmtDeclarationStatement :: ";
60848 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
60849 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
60850 : }
60851 : }
60852 : else
60853 : {
60854 0 : std::cout << "SgStmtDeclarationStatement :: " << std::flush;
60855 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
60856 0 : std::cout << " not valid " << std::endl;
60857 : }
60858 : }
60859 :
60860 0 : if ( p_parent != NULL )
60861 : {
60862 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60863 : {
60864 0 : if ( p_parent->isInMemoryPool() == false )
60865 : {
60866 0 : std::cout << "SgStmtDeclarationStatement :: ";
60867 0 : std::cout << " p_parent is not in memory pool of ";
60868 0 : std::cout << p_parent->class_name() << std::endl;
60869 : }
60870 : }
60871 : else
60872 : {
60873 0 : std::cout << "SgStmtDeclarationStatement :: " << std::flush;
60874 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
60875 0 : std::cout << " not valid " << std::endl;
60876 : }
60877 : }
60878 :
60879 :
60880 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
60881 :
60882 0 : }
60883 :
60884 :
60885 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
60886 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
60887 : bool
60888 0 : SgStmtDeclarationStatement::isInMemoryPool ()
60889 : {
60890 0 : typedef unsigned char* TestType;
60891 :
60892 0 : bool found = false;
60893 :
60894 0 : ROSE_ASSERT(this != NULL);
60895 :
60896 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
60897 :
60898 0 : TestType tested = (TestType) ( this ) ;
60899 :
60900 0 : std::vector < unsigned char* > :: const_iterator block = SgStmtDeclarationStatement::pools.begin();
60901 :
60902 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
60903 : // while (found == false && block < Memory_Block_List.end())
60904 0 : while ( (found == false) && (block != SgStmtDeclarationStatement::pools.end()) )
60905 : {
60906 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgStmtDeclarationStatement::pool_size * sizeof(SgStmtDeclarationStatement) ) ) ;
60907 0 : ++block;
60908 : }
60909 :
60910 : // Special handling for static data
60911 :
60912 :
60913 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
60914 0 : ROSE_ASSERT(found == true);
60915 :
60916 0 : return found;
60917 : }
60918 : /* #line 60919 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
60919 :
60920 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
60921 :
60922 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
60923 :
60924 : /* #line 60925 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
60925 :
60926 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
60927 :
60928 : void
60929 0 : SgStaticAssertionDeclaration::checkDataMemberPointersIfInMemoryPool()
60930 : {
60931 : // ------------ checking pointers of SgStaticAssertionDeclaration -------------------
60932 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
60933 :
60934 0 : if ( p_condition != NULL )
60935 : {
60936 0 : if ( p_condition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60937 : {
60938 0 : if ( p_condition->isInMemoryPool() == false )
60939 : {
60940 0 : std::cout << "SgStaticAssertionDeclaration :: ";
60941 0 : std::cout << " p_condition is not in memory pool of ";
60942 0 : std::cout << p_condition->class_name() << std::endl;
60943 : }
60944 : }
60945 : else
60946 : {
60947 0 : std::cout << "SgStaticAssertionDeclaration :: " << std::flush;
60948 0 : std::cout << "SgExpression* p_condition = " << p_condition << " --> " << std::flush;
60949 0 : std::cout << " not valid " << std::endl;
60950 : }
60951 : }
60952 :
60953 0 : if ( p_definingDeclaration != NULL )
60954 : {
60955 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60956 : {
60957 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
60958 : {
60959 0 : std::cout << "SgStaticAssertionDeclaration :: ";
60960 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
60961 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
60962 : }
60963 : }
60964 : else
60965 : {
60966 0 : std::cout << "SgStaticAssertionDeclaration :: " << std::flush;
60967 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
60968 0 : std::cout << " not valid " << std::endl;
60969 : }
60970 : }
60971 :
60972 0 : if ( p_firstNondefiningDeclaration != NULL )
60973 : {
60974 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60975 : {
60976 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
60977 : {
60978 0 : std::cout << "SgStaticAssertionDeclaration :: ";
60979 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
60980 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
60981 : }
60982 : }
60983 : else
60984 : {
60985 0 : std::cout << "SgStaticAssertionDeclaration :: " << std::flush;
60986 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
60987 0 : std::cout << " not valid " << std::endl;
60988 : }
60989 : }
60990 :
60991 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
60992 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
60993 : {
60994 0 : if ( (*i_qualifiedNameList) != NULL )
60995 : {
60996 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
60997 : {
60998 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
60999 : {
61000 0 : std::cout << "SgStaticAssertionDeclaration :: ";
61001 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
61002 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
61003 : }
61004 : }
61005 : else
61006 : {
61007 0 : std::cout << "SgStaticAssertionDeclaration :: " << std::flush;
61008 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
61009 0 : std::cout << " entry not valid " << std::endl;
61010 : }
61011 : }
61012 : else
61013 : {
61014 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
61015 : }
61016 : }
61017 :
61018 0 : if ( p_declarationScope != NULL )
61019 : {
61020 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61021 : {
61022 0 : if ( p_declarationScope->isInMemoryPool() == false )
61023 : {
61024 0 : std::cout << "SgStaticAssertionDeclaration :: ";
61025 0 : std::cout << " p_declarationScope is not in memory pool of ";
61026 0 : std::cout << p_declarationScope->class_name() << std::endl;
61027 : }
61028 : }
61029 : else
61030 : {
61031 0 : std::cout << "SgStaticAssertionDeclaration :: " << std::flush;
61032 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
61033 0 : std::cout << " not valid " << std::endl;
61034 : }
61035 : }
61036 :
61037 0 : if ( p_numeric_label != NULL )
61038 : {
61039 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61040 : {
61041 0 : if ( p_numeric_label->isInMemoryPool() == false )
61042 : {
61043 0 : std::cout << "SgStaticAssertionDeclaration :: ";
61044 0 : std::cout << " p_numeric_label is not in memory pool of ";
61045 0 : std::cout << p_numeric_label->class_name() << std::endl;
61046 : }
61047 : }
61048 : else
61049 : {
61050 0 : std::cout << "SgStaticAssertionDeclaration :: " << std::flush;
61051 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
61052 0 : std::cout << " not valid " << std::endl;
61053 : }
61054 : }
61055 :
61056 0 : if ( p_startOfConstruct != NULL )
61057 : {
61058 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61059 : {
61060 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
61061 : {
61062 0 : std::cout << "SgStaticAssertionDeclaration :: ";
61063 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
61064 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
61065 : }
61066 : }
61067 : else
61068 : {
61069 0 : std::cout << "SgStaticAssertionDeclaration :: " << std::flush;
61070 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
61071 0 : std::cout << " not valid " << std::endl;
61072 : }
61073 : }
61074 :
61075 0 : if ( p_endOfConstruct != NULL )
61076 : {
61077 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61078 : {
61079 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
61080 : {
61081 0 : std::cout << "SgStaticAssertionDeclaration :: ";
61082 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
61083 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
61084 : }
61085 : }
61086 : else
61087 : {
61088 0 : std::cout << "SgStaticAssertionDeclaration :: " << std::flush;
61089 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
61090 0 : std::cout << " not valid " << std::endl;
61091 : }
61092 : }
61093 :
61094 0 : if ( p_parent != NULL )
61095 : {
61096 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61097 : {
61098 0 : if ( p_parent->isInMemoryPool() == false )
61099 : {
61100 0 : std::cout << "SgStaticAssertionDeclaration :: ";
61101 0 : std::cout << " p_parent is not in memory pool of ";
61102 0 : std::cout << p_parent->class_name() << std::endl;
61103 : }
61104 : }
61105 : else
61106 : {
61107 0 : std::cout << "SgStaticAssertionDeclaration :: " << std::flush;
61108 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
61109 0 : std::cout << " not valid " << std::endl;
61110 : }
61111 : }
61112 :
61113 :
61114 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
61115 :
61116 0 : }
61117 :
61118 :
61119 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
61120 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
61121 : bool
61122 0 : SgStaticAssertionDeclaration::isInMemoryPool ()
61123 : {
61124 0 : typedef unsigned char* TestType;
61125 :
61126 0 : bool found = false;
61127 :
61128 0 : ROSE_ASSERT(this != NULL);
61129 :
61130 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
61131 :
61132 0 : TestType tested = (TestType) ( this ) ;
61133 :
61134 0 : std::vector < unsigned char* > :: const_iterator block = SgStaticAssertionDeclaration::pools.begin();
61135 :
61136 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
61137 : // while (found == false && block < Memory_Block_List.end())
61138 0 : while ( (found == false) && (block != SgStaticAssertionDeclaration::pools.end()) )
61139 : {
61140 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgStaticAssertionDeclaration::pool_size * sizeof(SgStaticAssertionDeclaration) ) ) ;
61141 0 : ++block;
61142 : }
61143 :
61144 : // Special handling for static data
61145 :
61146 :
61147 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
61148 0 : ROSE_ASSERT(found == true);
61149 :
61150 0 : return found;
61151 : }
61152 : /* #line 61153 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
61153 :
61154 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
61155 :
61156 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
61157 :
61158 : /* #line 61159 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
61159 :
61160 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
61161 :
61162 : void
61163 0 : SgOmpDeclareSimdStatement::checkDataMemberPointersIfInMemoryPool()
61164 : {
61165 : // ------------ checking pointers of SgOmpDeclareSimdStatement -------------------
61166 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
61167 :
61168 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
61169 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
61170 : {
61171 0 : if ( (*i_clauses) != NULL )
61172 : {
61173 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61174 : {
61175 0 : if ( (*i_clauses)->isInMemoryPool() == false )
61176 : {
61177 0 : std::cout << "SgOmpDeclareSimdStatement :: ";
61178 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
61179 0 : std::cout << (*i_clauses)->class_name() << std::endl;
61180 : }
61181 : }
61182 : else
61183 : {
61184 0 : std::cout << "SgOmpDeclareSimdStatement :: " << std::flush;
61185 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
61186 0 : std::cout << " entry not valid " << std::endl;
61187 : }
61188 : }
61189 : else
61190 : {
61191 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
61192 : }
61193 : }
61194 :
61195 0 : if ( p_definingDeclaration != NULL )
61196 : {
61197 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61198 : {
61199 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
61200 : {
61201 0 : std::cout << "SgOmpDeclareSimdStatement :: ";
61202 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
61203 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
61204 : }
61205 : }
61206 : else
61207 : {
61208 0 : std::cout << "SgOmpDeclareSimdStatement :: " << std::flush;
61209 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
61210 0 : std::cout << " not valid " << std::endl;
61211 : }
61212 : }
61213 :
61214 0 : if ( p_firstNondefiningDeclaration != NULL )
61215 : {
61216 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61217 : {
61218 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
61219 : {
61220 0 : std::cout << "SgOmpDeclareSimdStatement :: ";
61221 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
61222 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
61223 : }
61224 : }
61225 : else
61226 : {
61227 0 : std::cout << "SgOmpDeclareSimdStatement :: " << std::flush;
61228 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
61229 0 : std::cout << " not valid " << std::endl;
61230 : }
61231 : }
61232 :
61233 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
61234 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
61235 : {
61236 0 : if ( (*i_qualifiedNameList) != NULL )
61237 : {
61238 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61239 : {
61240 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
61241 : {
61242 0 : std::cout << "SgOmpDeclareSimdStatement :: ";
61243 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
61244 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
61245 : }
61246 : }
61247 : else
61248 : {
61249 0 : std::cout << "SgOmpDeclareSimdStatement :: " << std::flush;
61250 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
61251 0 : std::cout << " entry not valid " << std::endl;
61252 : }
61253 : }
61254 : else
61255 : {
61256 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
61257 : }
61258 : }
61259 :
61260 0 : if ( p_declarationScope != NULL )
61261 : {
61262 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61263 : {
61264 0 : if ( p_declarationScope->isInMemoryPool() == false )
61265 : {
61266 0 : std::cout << "SgOmpDeclareSimdStatement :: ";
61267 0 : std::cout << " p_declarationScope is not in memory pool of ";
61268 0 : std::cout << p_declarationScope->class_name() << std::endl;
61269 : }
61270 : }
61271 : else
61272 : {
61273 0 : std::cout << "SgOmpDeclareSimdStatement :: " << std::flush;
61274 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
61275 0 : std::cout << " not valid " << std::endl;
61276 : }
61277 : }
61278 :
61279 0 : if ( p_numeric_label != NULL )
61280 : {
61281 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61282 : {
61283 0 : if ( p_numeric_label->isInMemoryPool() == false )
61284 : {
61285 0 : std::cout << "SgOmpDeclareSimdStatement :: ";
61286 0 : std::cout << " p_numeric_label is not in memory pool of ";
61287 0 : std::cout << p_numeric_label->class_name() << std::endl;
61288 : }
61289 : }
61290 : else
61291 : {
61292 0 : std::cout << "SgOmpDeclareSimdStatement :: " << std::flush;
61293 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
61294 0 : std::cout << " not valid " << std::endl;
61295 : }
61296 : }
61297 :
61298 0 : if ( p_startOfConstruct != NULL )
61299 : {
61300 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61301 : {
61302 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
61303 : {
61304 0 : std::cout << "SgOmpDeclareSimdStatement :: ";
61305 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
61306 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
61307 : }
61308 : }
61309 : else
61310 : {
61311 0 : std::cout << "SgOmpDeclareSimdStatement :: " << std::flush;
61312 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
61313 0 : std::cout << " not valid " << std::endl;
61314 : }
61315 : }
61316 :
61317 0 : if ( p_endOfConstruct != NULL )
61318 : {
61319 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61320 : {
61321 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
61322 : {
61323 0 : std::cout << "SgOmpDeclareSimdStatement :: ";
61324 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
61325 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
61326 : }
61327 : }
61328 : else
61329 : {
61330 0 : std::cout << "SgOmpDeclareSimdStatement :: " << std::flush;
61331 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
61332 0 : std::cout << " not valid " << std::endl;
61333 : }
61334 : }
61335 :
61336 0 : if ( p_parent != NULL )
61337 : {
61338 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61339 : {
61340 0 : if ( p_parent->isInMemoryPool() == false )
61341 : {
61342 0 : std::cout << "SgOmpDeclareSimdStatement :: ";
61343 0 : std::cout << " p_parent is not in memory pool of ";
61344 0 : std::cout << p_parent->class_name() << std::endl;
61345 : }
61346 : }
61347 : else
61348 : {
61349 0 : std::cout << "SgOmpDeclareSimdStatement :: " << std::flush;
61350 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
61351 0 : std::cout << " not valid " << std::endl;
61352 : }
61353 : }
61354 :
61355 :
61356 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
61357 :
61358 0 : }
61359 :
61360 :
61361 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
61362 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
61363 : bool
61364 0 : SgOmpDeclareSimdStatement::isInMemoryPool ()
61365 : {
61366 0 : typedef unsigned char* TestType;
61367 :
61368 0 : bool found = false;
61369 :
61370 0 : ROSE_ASSERT(this != NULL);
61371 :
61372 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
61373 :
61374 0 : TestType tested = (TestType) ( this ) ;
61375 :
61376 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDeclareSimdStatement::pools.begin();
61377 :
61378 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
61379 : // while (found == false && block < Memory_Block_List.end())
61380 0 : while ( (found == false) && (block != SgOmpDeclareSimdStatement::pools.end()) )
61381 : {
61382 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDeclareSimdStatement::pool_size * sizeof(SgOmpDeclareSimdStatement) ) ) ;
61383 0 : ++block;
61384 : }
61385 :
61386 : // Special handling for static data
61387 :
61388 :
61389 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
61390 0 : ROSE_ASSERT(found == true);
61391 :
61392 0 : return found;
61393 : }
61394 : /* #line 61395 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
61395 :
61396 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
61397 :
61398 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
61399 :
61400 : /* #line 61401 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
61401 :
61402 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
61403 :
61404 : void
61405 0 : SgMicrosoftAttributeDeclaration::checkDataMemberPointersIfInMemoryPool()
61406 : {
61407 : // ------------ checking pointers of SgMicrosoftAttributeDeclaration -------------------
61408 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
61409 :
61410 0 : if ( p_definingDeclaration != NULL )
61411 : {
61412 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61413 : {
61414 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
61415 : {
61416 0 : std::cout << "SgMicrosoftAttributeDeclaration :: ";
61417 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
61418 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
61419 : }
61420 : }
61421 : else
61422 : {
61423 0 : std::cout << "SgMicrosoftAttributeDeclaration :: " << std::flush;
61424 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
61425 0 : std::cout << " not valid " << std::endl;
61426 : }
61427 : }
61428 :
61429 0 : if ( p_firstNondefiningDeclaration != NULL )
61430 : {
61431 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61432 : {
61433 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
61434 : {
61435 0 : std::cout << "SgMicrosoftAttributeDeclaration :: ";
61436 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
61437 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
61438 : }
61439 : }
61440 : else
61441 : {
61442 0 : std::cout << "SgMicrosoftAttributeDeclaration :: " << std::flush;
61443 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
61444 0 : std::cout << " not valid " << std::endl;
61445 : }
61446 : }
61447 :
61448 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
61449 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
61450 : {
61451 0 : if ( (*i_qualifiedNameList) != NULL )
61452 : {
61453 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61454 : {
61455 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
61456 : {
61457 0 : std::cout << "SgMicrosoftAttributeDeclaration :: ";
61458 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
61459 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
61460 : }
61461 : }
61462 : else
61463 : {
61464 0 : std::cout << "SgMicrosoftAttributeDeclaration :: " << std::flush;
61465 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
61466 0 : std::cout << " entry not valid " << std::endl;
61467 : }
61468 : }
61469 : else
61470 : {
61471 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
61472 : }
61473 : }
61474 :
61475 0 : if ( p_declarationScope != NULL )
61476 : {
61477 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61478 : {
61479 0 : if ( p_declarationScope->isInMemoryPool() == false )
61480 : {
61481 0 : std::cout << "SgMicrosoftAttributeDeclaration :: ";
61482 0 : std::cout << " p_declarationScope is not in memory pool of ";
61483 0 : std::cout << p_declarationScope->class_name() << std::endl;
61484 : }
61485 : }
61486 : else
61487 : {
61488 0 : std::cout << "SgMicrosoftAttributeDeclaration :: " << std::flush;
61489 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
61490 0 : std::cout << " not valid " << std::endl;
61491 : }
61492 : }
61493 :
61494 0 : if ( p_numeric_label != NULL )
61495 : {
61496 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61497 : {
61498 0 : if ( p_numeric_label->isInMemoryPool() == false )
61499 : {
61500 0 : std::cout << "SgMicrosoftAttributeDeclaration :: ";
61501 0 : std::cout << " p_numeric_label is not in memory pool of ";
61502 0 : std::cout << p_numeric_label->class_name() << std::endl;
61503 : }
61504 : }
61505 : else
61506 : {
61507 0 : std::cout << "SgMicrosoftAttributeDeclaration :: " << std::flush;
61508 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
61509 0 : std::cout << " not valid " << std::endl;
61510 : }
61511 : }
61512 :
61513 0 : if ( p_startOfConstruct != NULL )
61514 : {
61515 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61516 : {
61517 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
61518 : {
61519 0 : std::cout << "SgMicrosoftAttributeDeclaration :: ";
61520 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
61521 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
61522 : }
61523 : }
61524 : else
61525 : {
61526 0 : std::cout << "SgMicrosoftAttributeDeclaration :: " << std::flush;
61527 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
61528 0 : std::cout << " not valid " << std::endl;
61529 : }
61530 : }
61531 :
61532 0 : if ( p_endOfConstruct != NULL )
61533 : {
61534 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61535 : {
61536 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
61537 : {
61538 0 : std::cout << "SgMicrosoftAttributeDeclaration :: ";
61539 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
61540 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
61541 : }
61542 : }
61543 : else
61544 : {
61545 0 : std::cout << "SgMicrosoftAttributeDeclaration :: " << std::flush;
61546 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
61547 0 : std::cout << " not valid " << std::endl;
61548 : }
61549 : }
61550 :
61551 0 : if ( p_parent != NULL )
61552 : {
61553 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61554 : {
61555 0 : if ( p_parent->isInMemoryPool() == false )
61556 : {
61557 0 : std::cout << "SgMicrosoftAttributeDeclaration :: ";
61558 0 : std::cout << " p_parent is not in memory pool of ";
61559 0 : std::cout << p_parent->class_name() << std::endl;
61560 : }
61561 : }
61562 : else
61563 : {
61564 0 : std::cout << "SgMicrosoftAttributeDeclaration :: " << std::flush;
61565 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
61566 0 : std::cout << " not valid " << std::endl;
61567 : }
61568 : }
61569 :
61570 :
61571 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
61572 :
61573 0 : }
61574 :
61575 :
61576 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
61577 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
61578 : bool
61579 0 : SgMicrosoftAttributeDeclaration::isInMemoryPool ()
61580 : {
61581 0 : typedef unsigned char* TestType;
61582 :
61583 0 : bool found = false;
61584 :
61585 0 : ROSE_ASSERT(this != NULL);
61586 :
61587 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
61588 :
61589 0 : TestType tested = (TestType) ( this ) ;
61590 :
61591 0 : std::vector < unsigned char* > :: const_iterator block = SgMicrosoftAttributeDeclaration::pools.begin();
61592 :
61593 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
61594 : // while (found == false && block < Memory_Block_List.end())
61595 0 : while ( (found == false) && (block != SgMicrosoftAttributeDeclaration::pools.end()) )
61596 : {
61597 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgMicrosoftAttributeDeclaration::pool_size * sizeof(SgMicrosoftAttributeDeclaration) ) ) ;
61598 0 : ++block;
61599 : }
61600 :
61601 : // Special handling for static data
61602 :
61603 :
61604 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
61605 0 : ROSE_ASSERT(found == true);
61606 :
61607 0 : return found;
61608 : }
61609 : /* #line 61610 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
61610 :
61611 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
61612 :
61613 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
61614 :
61615 : /* #line 61616 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
61616 :
61617 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
61618 :
61619 : void
61620 0 : SgNonrealDecl::checkDataMemberPointersIfInMemoryPool()
61621 : {
61622 : // ------------ checking pointers of SgNonrealDecl -------------------
61623 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
61624 :
61625 0 : if ( p_nonreal_decl_scope != NULL )
61626 : {
61627 0 : if ( p_nonreal_decl_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61628 : {
61629 0 : if ( p_nonreal_decl_scope->isInMemoryPool() == false )
61630 : {
61631 0 : std::cout << "SgNonrealDecl :: ";
61632 0 : std::cout << " p_nonreal_decl_scope is not in memory pool of ";
61633 0 : std::cout << p_nonreal_decl_scope->class_name() << std::endl;
61634 : }
61635 : }
61636 : else
61637 : {
61638 0 : std::cout << "SgNonrealDecl :: " << std::flush;
61639 0 : std::cout << "SgDeclarationScope* p_nonreal_decl_scope = " << p_nonreal_decl_scope << " --> " << std::flush;
61640 0 : std::cout << " not valid " << std::endl;
61641 : }
61642 : }
61643 :
61644 0 : if ( p_type != NULL )
61645 : {
61646 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61647 : {
61648 0 : if ( p_type->isInMemoryPool() == false )
61649 : {
61650 0 : std::cout << "SgNonrealDecl :: ";
61651 0 : std::cout << " p_type is not in memory pool of ";
61652 0 : std::cout << p_type->class_name() << std::endl;
61653 : }
61654 : }
61655 : else
61656 : {
61657 0 : std::cout << "SgNonrealDecl :: " << std::flush;
61658 0 : std::cout << "SgNonrealType* p_type = " << p_type << " --> " << std::flush;
61659 0 : std::cout << " not valid " << std::endl;
61660 : }
61661 : }
61662 :
61663 0 : if ( p_templateDeclaration != NULL )
61664 : {
61665 0 : if ( p_templateDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61666 : {
61667 0 : if ( p_templateDeclaration->isInMemoryPool() == false )
61668 : {
61669 0 : std::cout << "SgNonrealDecl :: ";
61670 0 : std::cout << " p_templateDeclaration is not in memory pool of ";
61671 0 : std::cout << p_templateDeclaration->class_name() << std::endl;
61672 : }
61673 : }
61674 : else
61675 : {
61676 0 : std::cout << "SgNonrealDecl :: " << std::flush;
61677 0 : std::cout << "SgDeclarationStatement* p_templateDeclaration = " << p_templateDeclaration << " --> " << std::flush;
61678 0 : std::cout << " not valid " << std::endl;
61679 : }
61680 : }
61681 :
61682 0 : SgTemplateArgumentPtrList::iterator i_tpl_args = p_tpl_args.begin() ;
61683 0 : for ( ; i_tpl_args != p_tpl_args.end(); ++i_tpl_args )
61684 : {
61685 0 : if ( (*i_tpl_args) != NULL )
61686 : {
61687 0 : if ( (*i_tpl_args)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61688 : {
61689 0 : if ( (*i_tpl_args)->isInMemoryPool() == false )
61690 : {
61691 0 : std::cout << "SgNonrealDecl :: ";
61692 0 : std::cout << " p_tpl_args ( list of poitners to IR nodes ), entry is not in memory pool of ";
61693 0 : std::cout << (*i_tpl_args)->class_name() << std::endl;
61694 : }
61695 : }
61696 : else
61697 : {
61698 0 : std::cout << "SgNonrealDecl :: " << std::flush;
61699 0 : std::cout << "SgTemplateArgumentPtrList p_tpl_args --> " << std::flush;
61700 0 : std::cout << " entry not valid " << std::endl;
61701 : }
61702 : }
61703 : else
61704 : {
61705 0 : std::cout << "SgTemplateArgumentPtrList p_tpl_args --> NULL " << std::endl;
61706 : }
61707 : }
61708 :
61709 0 : SgTemplateParameterPtrList::iterator i_tpl_params = p_tpl_params.begin() ;
61710 0 : for ( ; i_tpl_params != p_tpl_params.end(); ++i_tpl_params )
61711 : {
61712 0 : if ( (*i_tpl_params) != NULL )
61713 : {
61714 0 : if ( (*i_tpl_params)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61715 : {
61716 0 : if ( (*i_tpl_params)->isInMemoryPool() == false )
61717 : {
61718 0 : std::cout << "SgNonrealDecl :: ";
61719 0 : std::cout << " p_tpl_params ( list of poitners to IR nodes ), entry is not in memory pool of ";
61720 0 : std::cout << (*i_tpl_params)->class_name() << std::endl;
61721 : }
61722 : }
61723 : else
61724 : {
61725 0 : std::cout << "SgNonrealDecl :: " << std::flush;
61726 0 : std::cout << "SgTemplateParameterPtrList p_tpl_params --> " << std::flush;
61727 0 : std::cout << " entry not valid " << std::endl;
61728 : }
61729 : }
61730 : else
61731 : {
61732 0 : std::cout << "SgTemplateParameterPtrList p_tpl_params --> NULL " << std::endl;
61733 : }
61734 : }
61735 :
61736 0 : if ( p_definingDeclaration != NULL )
61737 : {
61738 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61739 : {
61740 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
61741 : {
61742 0 : std::cout << "SgNonrealDecl :: ";
61743 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
61744 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
61745 : }
61746 : }
61747 : else
61748 : {
61749 0 : std::cout << "SgNonrealDecl :: " << std::flush;
61750 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
61751 0 : std::cout << " not valid " << std::endl;
61752 : }
61753 : }
61754 :
61755 0 : if ( p_firstNondefiningDeclaration != NULL )
61756 : {
61757 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61758 : {
61759 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
61760 : {
61761 0 : std::cout << "SgNonrealDecl :: ";
61762 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
61763 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
61764 : }
61765 : }
61766 : else
61767 : {
61768 0 : std::cout << "SgNonrealDecl :: " << std::flush;
61769 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
61770 0 : std::cout << " not valid " << std::endl;
61771 : }
61772 : }
61773 :
61774 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
61775 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
61776 : {
61777 0 : if ( (*i_qualifiedNameList) != NULL )
61778 : {
61779 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61780 : {
61781 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
61782 : {
61783 0 : std::cout << "SgNonrealDecl :: ";
61784 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
61785 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
61786 : }
61787 : }
61788 : else
61789 : {
61790 0 : std::cout << "SgNonrealDecl :: " << std::flush;
61791 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
61792 0 : std::cout << " entry not valid " << std::endl;
61793 : }
61794 : }
61795 : else
61796 : {
61797 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
61798 : }
61799 : }
61800 :
61801 0 : if ( p_declarationScope != NULL )
61802 : {
61803 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61804 : {
61805 0 : if ( p_declarationScope->isInMemoryPool() == false )
61806 : {
61807 0 : std::cout << "SgNonrealDecl :: ";
61808 0 : std::cout << " p_declarationScope is not in memory pool of ";
61809 0 : std::cout << p_declarationScope->class_name() << std::endl;
61810 : }
61811 : }
61812 : else
61813 : {
61814 0 : std::cout << "SgNonrealDecl :: " << std::flush;
61815 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
61816 0 : std::cout << " not valid " << std::endl;
61817 : }
61818 : }
61819 :
61820 0 : if ( p_numeric_label != NULL )
61821 : {
61822 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61823 : {
61824 0 : if ( p_numeric_label->isInMemoryPool() == false )
61825 : {
61826 0 : std::cout << "SgNonrealDecl :: ";
61827 0 : std::cout << " p_numeric_label is not in memory pool of ";
61828 0 : std::cout << p_numeric_label->class_name() << std::endl;
61829 : }
61830 : }
61831 : else
61832 : {
61833 0 : std::cout << "SgNonrealDecl :: " << std::flush;
61834 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
61835 0 : std::cout << " not valid " << std::endl;
61836 : }
61837 : }
61838 :
61839 0 : if ( p_startOfConstruct != NULL )
61840 : {
61841 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61842 : {
61843 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
61844 : {
61845 0 : std::cout << "SgNonrealDecl :: ";
61846 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
61847 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
61848 : }
61849 : }
61850 : else
61851 : {
61852 0 : std::cout << "SgNonrealDecl :: " << std::flush;
61853 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
61854 0 : std::cout << " not valid " << std::endl;
61855 : }
61856 : }
61857 :
61858 0 : if ( p_endOfConstruct != NULL )
61859 : {
61860 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61861 : {
61862 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
61863 : {
61864 0 : std::cout << "SgNonrealDecl :: ";
61865 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
61866 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
61867 : }
61868 : }
61869 : else
61870 : {
61871 0 : std::cout << "SgNonrealDecl :: " << std::flush;
61872 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
61873 0 : std::cout << " not valid " << std::endl;
61874 : }
61875 : }
61876 :
61877 0 : if ( p_parent != NULL )
61878 : {
61879 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61880 : {
61881 0 : if ( p_parent->isInMemoryPool() == false )
61882 : {
61883 0 : std::cout << "SgNonrealDecl :: ";
61884 0 : std::cout << " p_parent is not in memory pool of ";
61885 0 : std::cout << p_parent->class_name() << std::endl;
61886 : }
61887 : }
61888 : else
61889 : {
61890 0 : std::cout << "SgNonrealDecl :: " << std::flush;
61891 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
61892 0 : std::cout << " not valid " << std::endl;
61893 : }
61894 : }
61895 :
61896 :
61897 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
61898 :
61899 0 : }
61900 :
61901 :
61902 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
61903 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
61904 : bool
61905 0 : SgNonrealDecl::isInMemoryPool ()
61906 : {
61907 0 : typedef unsigned char* TestType;
61908 :
61909 0 : bool found = false;
61910 :
61911 0 : ROSE_ASSERT(this != NULL);
61912 :
61913 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
61914 :
61915 0 : TestType tested = (TestType) ( this ) ;
61916 :
61917 0 : std::vector < unsigned char* > :: const_iterator block = SgNonrealDecl::pools.begin();
61918 :
61919 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
61920 : // while (found == false && block < Memory_Block_List.end())
61921 0 : while ( (found == false) && (block != SgNonrealDecl::pools.end()) )
61922 : {
61923 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNonrealDecl::pool_size * sizeof(SgNonrealDecl) ) ) ;
61924 0 : ++block;
61925 : }
61926 :
61927 : // Special handling for static data
61928 :
61929 :
61930 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
61931 0 : ROSE_ASSERT(found == true);
61932 :
61933 0 : return found;
61934 : }
61935 : /* #line 61936 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
61936 :
61937 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
61938 :
61939 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
61940 :
61941 : /* #line 61942 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
61942 :
61943 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
61944 :
61945 : void
61946 0 : SgEmptyDeclaration::checkDataMemberPointersIfInMemoryPool()
61947 : {
61948 : // ------------ checking pointers of SgEmptyDeclaration -------------------
61949 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
61950 :
61951 0 : if ( p_definingDeclaration != NULL )
61952 : {
61953 0 : if ( p_definingDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61954 : {
61955 0 : if ( p_definingDeclaration->isInMemoryPool() == false )
61956 : {
61957 0 : std::cout << "SgEmptyDeclaration :: ";
61958 0 : std::cout << " p_definingDeclaration is not in memory pool of ";
61959 0 : std::cout << p_definingDeclaration->class_name() << std::endl;
61960 : }
61961 : }
61962 : else
61963 : {
61964 0 : std::cout << "SgEmptyDeclaration :: " << std::flush;
61965 0 : std::cout << "SgDeclarationStatement* p_definingDeclaration = " << p_definingDeclaration << " --> " << std::flush;
61966 0 : std::cout << " not valid " << std::endl;
61967 : }
61968 : }
61969 :
61970 0 : if ( p_firstNondefiningDeclaration != NULL )
61971 : {
61972 0 : if ( p_firstNondefiningDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61973 : {
61974 0 : if ( p_firstNondefiningDeclaration->isInMemoryPool() == false )
61975 : {
61976 0 : std::cout << "SgEmptyDeclaration :: ";
61977 0 : std::cout << " p_firstNondefiningDeclaration is not in memory pool of ";
61978 0 : std::cout << p_firstNondefiningDeclaration->class_name() << std::endl;
61979 : }
61980 : }
61981 : else
61982 : {
61983 0 : std::cout << "SgEmptyDeclaration :: " << std::flush;
61984 0 : std::cout << "SgDeclarationStatement* p_firstNondefiningDeclaration = " << p_firstNondefiningDeclaration << " --> " << std::flush;
61985 0 : std::cout << " not valid " << std::endl;
61986 : }
61987 : }
61988 :
61989 0 : SgQualifiedNamePtrList::iterator i_qualifiedNameList = p_qualifiedNameList.begin() ;
61990 0 : for ( ; i_qualifiedNameList != p_qualifiedNameList.end(); ++i_qualifiedNameList )
61991 : {
61992 0 : if ( (*i_qualifiedNameList) != NULL )
61993 : {
61994 0 : if ( (*i_qualifiedNameList)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
61995 : {
61996 0 : if ( (*i_qualifiedNameList)->isInMemoryPool() == false )
61997 : {
61998 0 : std::cout << "SgEmptyDeclaration :: ";
61999 0 : std::cout << " p_qualifiedNameList ( list of poitners to IR nodes ), entry is not in memory pool of ";
62000 0 : std::cout << (*i_qualifiedNameList)->class_name() << std::endl;
62001 : }
62002 : }
62003 : else
62004 : {
62005 0 : std::cout << "SgEmptyDeclaration :: " << std::flush;
62006 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> " << std::flush;
62007 0 : std::cout << " entry not valid " << std::endl;
62008 : }
62009 : }
62010 : else
62011 : {
62012 0 : std::cout << "SgQualifiedNamePtrList p_qualifiedNameList --> NULL " << std::endl;
62013 : }
62014 : }
62015 :
62016 0 : if ( p_declarationScope != NULL )
62017 : {
62018 0 : if ( p_declarationScope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62019 : {
62020 0 : if ( p_declarationScope->isInMemoryPool() == false )
62021 : {
62022 0 : std::cout << "SgEmptyDeclaration :: ";
62023 0 : std::cout << " p_declarationScope is not in memory pool of ";
62024 0 : std::cout << p_declarationScope->class_name() << std::endl;
62025 : }
62026 : }
62027 : else
62028 : {
62029 0 : std::cout << "SgEmptyDeclaration :: " << std::flush;
62030 0 : std::cout << "SgDeclarationScope* p_declarationScope = " << p_declarationScope << " --> " << std::flush;
62031 0 : std::cout << " not valid " << std::endl;
62032 : }
62033 : }
62034 :
62035 0 : if ( p_numeric_label != NULL )
62036 : {
62037 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62038 : {
62039 0 : if ( p_numeric_label->isInMemoryPool() == false )
62040 : {
62041 0 : std::cout << "SgEmptyDeclaration :: ";
62042 0 : std::cout << " p_numeric_label is not in memory pool of ";
62043 0 : std::cout << p_numeric_label->class_name() << std::endl;
62044 : }
62045 : }
62046 : else
62047 : {
62048 0 : std::cout << "SgEmptyDeclaration :: " << std::flush;
62049 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
62050 0 : std::cout << " not valid " << std::endl;
62051 : }
62052 : }
62053 :
62054 0 : if ( p_startOfConstruct != NULL )
62055 : {
62056 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62057 : {
62058 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
62059 : {
62060 0 : std::cout << "SgEmptyDeclaration :: ";
62061 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
62062 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
62063 : }
62064 : }
62065 : else
62066 : {
62067 0 : std::cout << "SgEmptyDeclaration :: " << std::flush;
62068 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
62069 0 : std::cout << " not valid " << std::endl;
62070 : }
62071 : }
62072 :
62073 0 : if ( p_endOfConstruct != NULL )
62074 : {
62075 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62076 : {
62077 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
62078 : {
62079 0 : std::cout << "SgEmptyDeclaration :: ";
62080 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
62081 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
62082 : }
62083 : }
62084 : else
62085 : {
62086 0 : std::cout << "SgEmptyDeclaration :: " << std::flush;
62087 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
62088 0 : std::cout << " not valid " << std::endl;
62089 : }
62090 : }
62091 :
62092 0 : if ( p_parent != NULL )
62093 : {
62094 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62095 : {
62096 0 : if ( p_parent->isInMemoryPool() == false )
62097 : {
62098 0 : std::cout << "SgEmptyDeclaration :: ";
62099 0 : std::cout << " p_parent is not in memory pool of ";
62100 0 : std::cout << p_parent->class_name() << std::endl;
62101 : }
62102 : }
62103 : else
62104 : {
62105 0 : std::cout << "SgEmptyDeclaration :: " << std::flush;
62106 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
62107 0 : std::cout << " not valid " << std::endl;
62108 : }
62109 : }
62110 :
62111 :
62112 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
62113 :
62114 0 : }
62115 :
62116 :
62117 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
62118 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
62119 : bool
62120 0 : SgEmptyDeclaration::isInMemoryPool ()
62121 : {
62122 0 : typedef unsigned char* TestType;
62123 :
62124 0 : bool found = false;
62125 :
62126 0 : ROSE_ASSERT(this != NULL);
62127 :
62128 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
62129 :
62130 0 : TestType tested = (TestType) ( this ) ;
62131 :
62132 0 : std::vector < unsigned char* > :: const_iterator block = SgEmptyDeclaration::pools.begin();
62133 :
62134 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
62135 : // while (found == false && block < Memory_Block_List.end())
62136 0 : while ( (found == false) && (block != SgEmptyDeclaration::pools.end()) )
62137 : {
62138 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgEmptyDeclaration::pool_size * sizeof(SgEmptyDeclaration) ) ) ;
62139 0 : ++block;
62140 : }
62141 :
62142 : // Special handling for static data
62143 :
62144 :
62145 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
62146 0 : ROSE_ASSERT(found == true);
62147 :
62148 0 : return found;
62149 : }
62150 : /* #line 62151 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
62151 :
62152 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
62153 :
62154 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
62155 :
62156 : /* #line 62157 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
62157 :
62158 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
62159 :
62160 : void
62161 0 : SgExprStatement::checkDataMemberPointersIfInMemoryPool()
62162 : {
62163 : // ------------ checking pointers of SgExprStatement -------------------
62164 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
62165 :
62166 0 : if ( p_expression != NULL )
62167 : {
62168 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62169 : {
62170 0 : if ( p_expression->isInMemoryPool() == false )
62171 : {
62172 0 : std::cout << "SgExprStatement :: ";
62173 0 : std::cout << " p_expression is not in memory pool of ";
62174 0 : std::cout << p_expression->class_name() << std::endl;
62175 : }
62176 : }
62177 : else
62178 : {
62179 0 : std::cout << "SgExprStatement :: " << std::flush;
62180 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
62181 0 : std::cout << " not valid " << std::endl;
62182 : }
62183 : }
62184 :
62185 0 : if ( p_numeric_label != NULL )
62186 : {
62187 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62188 : {
62189 0 : if ( p_numeric_label->isInMemoryPool() == false )
62190 : {
62191 0 : std::cout << "SgExprStatement :: ";
62192 0 : std::cout << " p_numeric_label is not in memory pool of ";
62193 0 : std::cout << p_numeric_label->class_name() << std::endl;
62194 : }
62195 : }
62196 : else
62197 : {
62198 0 : std::cout << "SgExprStatement :: " << std::flush;
62199 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
62200 0 : std::cout << " not valid " << std::endl;
62201 : }
62202 : }
62203 :
62204 0 : if ( p_startOfConstruct != NULL )
62205 : {
62206 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62207 : {
62208 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
62209 : {
62210 0 : std::cout << "SgExprStatement :: ";
62211 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
62212 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
62213 : }
62214 : }
62215 : else
62216 : {
62217 0 : std::cout << "SgExprStatement :: " << std::flush;
62218 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
62219 0 : std::cout << " not valid " << std::endl;
62220 : }
62221 : }
62222 :
62223 0 : if ( p_endOfConstruct != NULL )
62224 : {
62225 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62226 : {
62227 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
62228 : {
62229 0 : std::cout << "SgExprStatement :: ";
62230 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
62231 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
62232 : }
62233 : }
62234 : else
62235 : {
62236 0 : std::cout << "SgExprStatement :: " << std::flush;
62237 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
62238 0 : std::cout << " not valid " << std::endl;
62239 : }
62240 : }
62241 :
62242 0 : if ( p_parent != NULL )
62243 : {
62244 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62245 : {
62246 0 : if ( p_parent->isInMemoryPool() == false )
62247 : {
62248 0 : std::cout << "SgExprStatement :: ";
62249 0 : std::cout << " p_parent is not in memory pool of ";
62250 0 : std::cout << p_parent->class_name() << std::endl;
62251 : }
62252 : }
62253 : else
62254 : {
62255 0 : std::cout << "SgExprStatement :: " << std::flush;
62256 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
62257 0 : std::cout << " not valid " << std::endl;
62258 : }
62259 : }
62260 :
62261 :
62262 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
62263 :
62264 0 : }
62265 :
62266 :
62267 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
62268 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
62269 : bool
62270 0 : SgExprStatement::isInMemoryPool ()
62271 : {
62272 0 : typedef unsigned char* TestType;
62273 :
62274 0 : bool found = false;
62275 :
62276 0 : ROSE_ASSERT(this != NULL);
62277 :
62278 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
62279 :
62280 0 : TestType tested = (TestType) ( this ) ;
62281 :
62282 0 : std::vector < unsigned char* > :: const_iterator block = SgExprStatement::pools.begin();
62283 :
62284 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
62285 : // while (found == false && block < Memory_Block_List.end())
62286 0 : while ( (found == false) && (block != SgExprStatement::pools.end()) )
62287 : {
62288 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgExprStatement::pool_size * sizeof(SgExprStatement) ) ) ;
62289 0 : ++block;
62290 : }
62291 :
62292 : // Special handling for static data
62293 :
62294 :
62295 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
62296 0 : ROSE_ASSERT(found == true);
62297 :
62298 0 : return found;
62299 : }
62300 : /* #line 62301 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
62301 :
62302 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
62303 :
62304 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
62305 :
62306 : /* #line 62307 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
62307 :
62308 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
62309 :
62310 : void
62311 0 : SgLabelStatement::checkDataMemberPointersIfInMemoryPool()
62312 : {
62313 : // ------------ checking pointers of SgLabelStatement -------------------
62314 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
62315 :
62316 0 : if ( p_scope != NULL )
62317 : {
62318 0 : if ( p_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62319 : {
62320 0 : if ( p_scope->isInMemoryPool() == false )
62321 : {
62322 0 : std::cout << "SgLabelStatement :: ";
62323 0 : std::cout << " p_scope is not in memory pool of ";
62324 0 : std::cout << p_scope->class_name() << std::endl;
62325 : }
62326 : }
62327 : else
62328 : {
62329 0 : std::cout << "SgLabelStatement :: " << std::flush;
62330 0 : std::cout << "SgScopeStatement* p_scope = " << p_scope << " --> " << std::flush;
62331 0 : std::cout << " not valid " << std::endl;
62332 : }
62333 : }
62334 :
62335 0 : if ( p_statement != NULL )
62336 : {
62337 0 : if ( p_statement->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62338 : {
62339 0 : if ( p_statement->isInMemoryPool() == false )
62340 : {
62341 0 : std::cout << "SgLabelStatement :: ";
62342 0 : std::cout << " p_statement is not in memory pool of ";
62343 0 : std::cout << p_statement->class_name() << std::endl;
62344 : }
62345 : }
62346 : else
62347 : {
62348 0 : std::cout << "SgLabelStatement :: " << std::flush;
62349 0 : std::cout << "SgStatement* p_statement = " << p_statement << " --> " << std::flush;
62350 0 : std::cout << " not valid " << std::endl;
62351 : }
62352 : }
62353 :
62354 0 : if ( p_numeric_label != NULL )
62355 : {
62356 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62357 : {
62358 0 : if ( p_numeric_label->isInMemoryPool() == false )
62359 : {
62360 0 : std::cout << "SgLabelStatement :: ";
62361 0 : std::cout << " p_numeric_label is not in memory pool of ";
62362 0 : std::cout << p_numeric_label->class_name() << std::endl;
62363 : }
62364 : }
62365 : else
62366 : {
62367 0 : std::cout << "SgLabelStatement :: " << std::flush;
62368 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
62369 0 : std::cout << " not valid " << std::endl;
62370 : }
62371 : }
62372 :
62373 0 : if ( p_startOfConstruct != NULL )
62374 : {
62375 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62376 : {
62377 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
62378 : {
62379 0 : std::cout << "SgLabelStatement :: ";
62380 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
62381 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
62382 : }
62383 : }
62384 : else
62385 : {
62386 0 : std::cout << "SgLabelStatement :: " << std::flush;
62387 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
62388 0 : std::cout << " not valid " << std::endl;
62389 : }
62390 : }
62391 :
62392 0 : if ( p_endOfConstruct != NULL )
62393 : {
62394 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62395 : {
62396 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
62397 : {
62398 0 : std::cout << "SgLabelStatement :: ";
62399 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
62400 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
62401 : }
62402 : }
62403 : else
62404 : {
62405 0 : std::cout << "SgLabelStatement :: " << std::flush;
62406 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
62407 0 : std::cout << " not valid " << std::endl;
62408 : }
62409 : }
62410 :
62411 0 : if ( p_parent != NULL )
62412 : {
62413 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62414 : {
62415 0 : if ( p_parent->isInMemoryPool() == false )
62416 : {
62417 0 : std::cout << "SgLabelStatement :: ";
62418 0 : std::cout << " p_parent is not in memory pool of ";
62419 0 : std::cout << p_parent->class_name() << std::endl;
62420 : }
62421 : }
62422 : else
62423 : {
62424 0 : std::cout << "SgLabelStatement :: " << std::flush;
62425 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
62426 0 : std::cout << " not valid " << std::endl;
62427 : }
62428 : }
62429 :
62430 :
62431 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
62432 :
62433 0 : }
62434 :
62435 :
62436 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
62437 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
62438 : bool
62439 0 : SgLabelStatement::isInMemoryPool ()
62440 : {
62441 0 : typedef unsigned char* TestType;
62442 :
62443 0 : bool found = false;
62444 :
62445 0 : ROSE_ASSERT(this != NULL);
62446 :
62447 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
62448 :
62449 0 : TestType tested = (TestType) ( this ) ;
62450 :
62451 0 : std::vector < unsigned char* > :: const_iterator block = SgLabelStatement::pools.begin();
62452 :
62453 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
62454 : // while (found == false && block < Memory_Block_List.end())
62455 0 : while ( (found == false) && (block != SgLabelStatement::pools.end()) )
62456 : {
62457 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLabelStatement::pool_size * sizeof(SgLabelStatement) ) ) ;
62458 0 : ++block;
62459 : }
62460 :
62461 : // Special handling for static data
62462 :
62463 :
62464 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
62465 0 : ROSE_ASSERT(found == true);
62466 :
62467 0 : return found;
62468 : }
62469 : /* #line 62470 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
62470 :
62471 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
62472 :
62473 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
62474 :
62475 : /* #line 62476 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
62476 :
62477 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
62478 :
62479 : void
62480 0 : SgCaseOptionStmt::checkDataMemberPointersIfInMemoryPool()
62481 : {
62482 : // ------------ checking pointers of SgCaseOptionStmt -------------------
62483 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
62484 :
62485 0 : if ( p_key != NULL )
62486 : {
62487 0 : if ( p_key->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62488 : {
62489 0 : if ( p_key->isInMemoryPool() == false )
62490 : {
62491 0 : std::cout << "SgCaseOptionStmt :: ";
62492 0 : std::cout << " p_key is not in memory pool of ";
62493 0 : std::cout << p_key->class_name() << std::endl;
62494 : }
62495 : }
62496 : else
62497 : {
62498 0 : std::cout << "SgCaseOptionStmt :: " << std::flush;
62499 0 : std::cout << "SgExpression* p_key = " << p_key << " --> " << std::flush;
62500 0 : std::cout << " not valid " << std::endl;
62501 : }
62502 : }
62503 :
62504 0 : if ( p_body != NULL )
62505 : {
62506 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62507 : {
62508 0 : if ( p_body->isInMemoryPool() == false )
62509 : {
62510 0 : std::cout << "SgCaseOptionStmt :: ";
62511 0 : std::cout << " p_body is not in memory pool of ";
62512 0 : std::cout << p_body->class_name() << std::endl;
62513 : }
62514 : }
62515 : else
62516 : {
62517 0 : std::cout << "SgCaseOptionStmt :: " << std::flush;
62518 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
62519 0 : std::cout << " not valid " << std::endl;
62520 : }
62521 : }
62522 :
62523 0 : if ( p_key_range_end != NULL )
62524 : {
62525 0 : if ( p_key_range_end->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62526 : {
62527 0 : if ( p_key_range_end->isInMemoryPool() == false )
62528 : {
62529 0 : std::cout << "SgCaseOptionStmt :: ";
62530 0 : std::cout << " p_key_range_end is not in memory pool of ";
62531 0 : std::cout << p_key_range_end->class_name() << std::endl;
62532 : }
62533 : }
62534 : else
62535 : {
62536 0 : std::cout << "SgCaseOptionStmt :: " << std::flush;
62537 0 : std::cout << "SgExpression* p_key_range_end = " << p_key_range_end << " --> " << std::flush;
62538 0 : std::cout << " not valid " << std::endl;
62539 : }
62540 : }
62541 :
62542 0 : if ( p_numeric_label != NULL )
62543 : {
62544 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62545 : {
62546 0 : if ( p_numeric_label->isInMemoryPool() == false )
62547 : {
62548 0 : std::cout << "SgCaseOptionStmt :: ";
62549 0 : std::cout << " p_numeric_label is not in memory pool of ";
62550 0 : std::cout << p_numeric_label->class_name() << std::endl;
62551 : }
62552 : }
62553 : else
62554 : {
62555 0 : std::cout << "SgCaseOptionStmt :: " << std::flush;
62556 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
62557 0 : std::cout << " not valid " << std::endl;
62558 : }
62559 : }
62560 :
62561 0 : if ( p_startOfConstruct != NULL )
62562 : {
62563 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62564 : {
62565 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
62566 : {
62567 0 : std::cout << "SgCaseOptionStmt :: ";
62568 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
62569 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
62570 : }
62571 : }
62572 : else
62573 : {
62574 0 : std::cout << "SgCaseOptionStmt :: " << std::flush;
62575 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
62576 0 : std::cout << " not valid " << std::endl;
62577 : }
62578 : }
62579 :
62580 0 : if ( p_endOfConstruct != NULL )
62581 : {
62582 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62583 : {
62584 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
62585 : {
62586 0 : std::cout << "SgCaseOptionStmt :: ";
62587 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
62588 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
62589 : }
62590 : }
62591 : else
62592 : {
62593 0 : std::cout << "SgCaseOptionStmt :: " << std::flush;
62594 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
62595 0 : std::cout << " not valid " << std::endl;
62596 : }
62597 : }
62598 :
62599 0 : if ( p_parent != NULL )
62600 : {
62601 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62602 : {
62603 0 : if ( p_parent->isInMemoryPool() == false )
62604 : {
62605 0 : std::cout << "SgCaseOptionStmt :: ";
62606 0 : std::cout << " p_parent is not in memory pool of ";
62607 0 : std::cout << p_parent->class_name() << std::endl;
62608 : }
62609 : }
62610 : else
62611 : {
62612 0 : std::cout << "SgCaseOptionStmt :: " << std::flush;
62613 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
62614 0 : std::cout << " not valid " << std::endl;
62615 : }
62616 : }
62617 :
62618 :
62619 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
62620 :
62621 0 : }
62622 :
62623 :
62624 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
62625 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
62626 : bool
62627 0 : SgCaseOptionStmt::isInMemoryPool ()
62628 : {
62629 0 : typedef unsigned char* TestType;
62630 :
62631 0 : bool found = false;
62632 :
62633 0 : ROSE_ASSERT(this != NULL);
62634 :
62635 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
62636 :
62637 0 : TestType tested = (TestType) ( this ) ;
62638 :
62639 0 : std::vector < unsigned char* > :: const_iterator block = SgCaseOptionStmt::pools.begin();
62640 :
62641 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
62642 : // while (found == false && block < Memory_Block_List.end())
62643 0 : while ( (found == false) && (block != SgCaseOptionStmt::pools.end()) )
62644 : {
62645 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCaseOptionStmt::pool_size * sizeof(SgCaseOptionStmt) ) ) ;
62646 0 : ++block;
62647 : }
62648 :
62649 : // Special handling for static data
62650 :
62651 :
62652 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
62653 0 : ROSE_ASSERT(found == true);
62654 :
62655 0 : return found;
62656 : }
62657 : /* #line 62658 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
62658 :
62659 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
62660 :
62661 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
62662 :
62663 : /* #line 62664 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
62664 :
62665 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
62666 :
62667 : void
62668 0 : SgTryStmt::checkDataMemberPointersIfInMemoryPool()
62669 : {
62670 : // ------------ checking pointers of SgTryStmt -------------------
62671 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
62672 :
62673 0 : if ( p_body != NULL )
62674 : {
62675 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62676 : {
62677 0 : if ( p_body->isInMemoryPool() == false )
62678 : {
62679 0 : std::cout << "SgTryStmt :: ";
62680 0 : std::cout << " p_body is not in memory pool of ";
62681 0 : std::cout << p_body->class_name() << std::endl;
62682 : }
62683 : }
62684 : else
62685 : {
62686 0 : std::cout << "SgTryStmt :: " << std::flush;
62687 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
62688 0 : std::cout << " not valid " << std::endl;
62689 : }
62690 : }
62691 :
62692 0 : if ( p_catch_statement_seq_root != NULL )
62693 : {
62694 0 : if ( p_catch_statement_seq_root->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62695 : {
62696 0 : if ( p_catch_statement_seq_root->isInMemoryPool() == false )
62697 : {
62698 0 : std::cout << "SgTryStmt :: ";
62699 0 : std::cout << " p_catch_statement_seq_root is not in memory pool of ";
62700 0 : std::cout << p_catch_statement_seq_root->class_name() << std::endl;
62701 : }
62702 : }
62703 : else
62704 : {
62705 0 : std::cout << "SgTryStmt :: " << std::flush;
62706 0 : std::cout << "SgCatchStatementSeq* p_catch_statement_seq_root = " << p_catch_statement_seq_root << " --> " << std::flush;
62707 0 : std::cout << " not valid " << std::endl;
62708 : }
62709 : }
62710 :
62711 0 : if ( p_else_body != NULL )
62712 : {
62713 0 : if ( p_else_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62714 : {
62715 0 : if ( p_else_body->isInMemoryPool() == false )
62716 : {
62717 0 : std::cout << "SgTryStmt :: ";
62718 0 : std::cout << " p_else_body is not in memory pool of ";
62719 0 : std::cout << p_else_body->class_name() << std::endl;
62720 : }
62721 : }
62722 : else
62723 : {
62724 0 : std::cout << "SgTryStmt :: " << std::flush;
62725 0 : std::cout << "SgStatement* p_else_body = " << p_else_body << " --> " << std::flush;
62726 0 : std::cout << " not valid " << std::endl;
62727 : }
62728 : }
62729 :
62730 0 : if ( p_finally_body != NULL )
62731 : {
62732 0 : if ( p_finally_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62733 : {
62734 0 : if ( p_finally_body->isInMemoryPool() == false )
62735 : {
62736 0 : std::cout << "SgTryStmt :: ";
62737 0 : std::cout << " p_finally_body is not in memory pool of ";
62738 0 : std::cout << p_finally_body->class_name() << std::endl;
62739 : }
62740 : }
62741 : else
62742 : {
62743 0 : std::cout << "SgTryStmt :: " << std::flush;
62744 0 : std::cout << "SgStatement* p_finally_body = " << p_finally_body << " --> " << std::flush;
62745 0 : std::cout << " not valid " << std::endl;
62746 : }
62747 : }
62748 :
62749 0 : if ( p_numeric_label != NULL )
62750 : {
62751 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62752 : {
62753 0 : if ( p_numeric_label->isInMemoryPool() == false )
62754 : {
62755 0 : std::cout << "SgTryStmt :: ";
62756 0 : std::cout << " p_numeric_label is not in memory pool of ";
62757 0 : std::cout << p_numeric_label->class_name() << std::endl;
62758 : }
62759 : }
62760 : else
62761 : {
62762 0 : std::cout << "SgTryStmt :: " << std::flush;
62763 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
62764 0 : std::cout << " not valid " << std::endl;
62765 : }
62766 : }
62767 :
62768 0 : if ( p_startOfConstruct != NULL )
62769 : {
62770 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62771 : {
62772 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
62773 : {
62774 0 : std::cout << "SgTryStmt :: ";
62775 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
62776 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
62777 : }
62778 : }
62779 : else
62780 : {
62781 0 : std::cout << "SgTryStmt :: " << std::flush;
62782 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
62783 0 : std::cout << " not valid " << std::endl;
62784 : }
62785 : }
62786 :
62787 0 : if ( p_endOfConstruct != NULL )
62788 : {
62789 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62790 : {
62791 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
62792 : {
62793 0 : std::cout << "SgTryStmt :: ";
62794 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
62795 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
62796 : }
62797 : }
62798 : else
62799 : {
62800 0 : std::cout << "SgTryStmt :: " << std::flush;
62801 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
62802 0 : std::cout << " not valid " << std::endl;
62803 : }
62804 : }
62805 :
62806 0 : if ( p_parent != NULL )
62807 : {
62808 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62809 : {
62810 0 : if ( p_parent->isInMemoryPool() == false )
62811 : {
62812 0 : std::cout << "SgTryStmt :: ";
62813 0 : std::cout << " p_parent is not in memory pool of ";
62814 0 : std::cout << p_parent->class_name() << std::endl;
62815 : }
62816 : }
62817 : else
62818 : {
62819 0 : std::cout << "SgTryStmt :: " << std::flush;
62820 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
62821 0 : std::cout << " not valid " << std::endl;
62822 : }
62823 : }
62824 :
62825 :
62826 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
62827 :
62828 0 : }
62829 :
62830 :
62831 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
62832 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
62833 : bool
62834 0 : SgTryStmt::isInMemoryPool ()
62835 : {
62836 0 : typedef unsigned char* TestType;
62837 :
62838 0 : bool found = false;
62839 :
62840 0 : ROSE_ASSERT(this != NULL);
62841 :
62842 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
62843 :
62844 0 : TestType tested = (TestType) ( this ) ;
62845 :
62846 0 : std::vector < unsigned char* > :: const_iterator block = SgTryStmt::pools.begin();
62847 :
62848 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
62849 : // while (found == false && block < Memory_Block_List.end())
62850 0 : while ( (found == false) && (block != SgTryStmt::pools.end()) )
62851 : {
62852 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTryStmt::pool_size * sizeof(SgTryStmt) ) ) ;
62853 0 : ++block;
62854 : }
62855 :
62856 : // Special handling for static data
62857 :
62858 :
62859 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
62860 0 : ROSE_ASSERT(found == true);
62861 :
62862 0 : return found;
62863 : }
62864 : /* #line 62865 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
62865 :
62866 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
62867 :
62868 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
62869 :
62870 : /* #line 62871 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
62871 :
62872 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
62873 :
62874 : void
62875 0 : SgDefaultOptionStmt::checkDataMemberPointersIfInMemoryPool()
62876 : {
62877 : // ------------ checking pointers of SgDefaultOptionStmt -------------------
62878 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
62879 :
62880 0 : if ( p_body != NULL )
62881 : {
62882 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62883 : {
62884 0 : if ( p_body->isInMemoryPool() == false )
62885 : {
62886 0 : std::cout << "SgDefaultOptionStmt :: ";
62887 0 : std::cout << " p_body is not in memory pool of ";
62888 0 : std::cout << p_body->class_name() << std::endl;
62889 : }
62890 : }
62891 : else
62892 : {
62893 0 : std::cout << "SgDefaultOptionStmt :: " << std::flush;
62894 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
62895 0 : std::cout << " not valid " << std::endl;
62896 : }
62897 : }
62898 :
62899 0 : if ( p_numeric_label != NULL )
62900 : {
62901 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62902 : {
62903 0 : if ( p_numeric_label->isInMemoryPool() == false )
62904 : {
62905 0 : std::cout << "SgDefaultOptionStmt :: ";
62906 0 : std::cout << " p_numeric_label is not in memory pool of ";
62907 0 : std::cout << p_numeric_label->class_name() << std::endl;
62908 : }
62909 : }
62910 : else
62911 : {
62912 0 : std::cout << "SgDefaultOptionStmt :: " << std::flush;
62913 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
62914 0 : std::cout << " not valid " << std::endl;
62915 : }
62916 : }
62917 :
62918 0 : if ( p_startOfConstruct != NULL )
62919 : {
62920 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62921 : {
62922 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
62923 : {
62924 0 : std::cout << "SgDefaultOptionStmt :: ";
62925 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
62926 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
62927 : }
62928 : }
62929 : else
62930 : {
62931 0 : std::cout << "SgDefaultOptionStmt :: " << std::flush;
62932 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
62933 0 : std::cout << " not valid " << std::endl;
62934 : }
62935 : }
62936 :
62937 0 : if ( p_endOfConstruct != NULL )
62938 : {
62939 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62940 : {
62941 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
62942 : {
62943 0 : std::cout << "SgDefaultOptionStmt :: ";
62944 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
62945 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
62946 : }
62947 : }
62948 : else
62949 : {
62950 0 : std::cout << "SgDefaultOptionStmt :: " << std::flush;
62951 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
62952 0 : std::cout << " not valid " << std::endl;
62953 : }
62954 : }
62955 :
62956 0 : if ( p_parent != NULL )
62957 : {
62958 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
62959 : {
62960 0 : if ( p_parent->isInMemoryPool() == false )
62961 : {
62962 0 : std::cout << "SgDefaultOptionStmt :: ";
62963 0 : std::cout << " p_parent is not in memory pool of ";
62964 0 : std::cout << p_parent->class_name() << std::endl;
62965 : }
62966 : }
62967 : else
62968 : {
62969 0 : std::cout << "SgDefaultOptionStmt :: " << std::flush;
62970 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
62971 0 : std::cout << " not valid " << std::endl;
62972 : }
62973 : }
62974 :
62975 :
62976 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
62977 :
62978 0 : }
62979 :
62980 :
62981 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
62982 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
62983 : bool
62984 0 : SgDefaultOptionStmt::isInMemoryPool ()
62985 : {
62986 0 : typedef unsigned char* TestType;
62987 :
62988 0 : bool found = false;
62989 :
62990 0 : ROSE_ASSERT(this != NULL);
62991 :
62992 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
62993 :
62994 0 : TestType tested = (TestType) ( this ) ;
62995 :
62996 0 : std::vector < unsigned char* > :: const_iterator block = SgDefaultOptionStmt::pools.begin();
62997 :
62998 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
62999 : // while (found == false && block < Memory_Block_List.end())
63000 0 : while ( (found == false) && (block != SgDefaultOptionStmt::pools.end()) )
63001 : {
63002 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDefaultOptionStmt::pool_size * sizeof(SgDefaultOptionStmt) ) ) ;
63003 0 : ++block;
63004 : }
63005 :
63006 : // Special handling for static data
63007 :
63008 :
63009 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
63010 0 : ROSE_ASSERT(found == true);
63011 :
63012 0 : return found;
63013 : }
63014 : /* #line 63015 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
63015 :
63016 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
63017 :
63018 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63019 :
63020 : /* #line 63021 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
63021 :
63022 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63023 :
63024 : void
63025 0 : SgBreakStmt::checkDataMemberPointersIfInMemoryPool()
63026 : {
63027 : // ------------ checking pointers of SgBreakStmt -------------------
63028 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
63029 :
63030 0 : if ( p_numeric_label != NULL )
63031 : {
63032 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63033 : {
63034 0 : if ( p_numeric_label->isInMemoryPool() == false )
63035 : {
63036 0 : std::cout << "SgBreakStmt :: ";
63037 0 : std::cout << " p_numeric_label is not in memory pool of ";
63038 0 : std::cout << p_numeric_label->class_name() << std::endl;
63039 : }
63040 : }
63041 : else
63042 : {
63043 0 : std::cout << "SgBreakStmt :: " << std::flush;
63044 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
63045 0 : std::cout << " not valid " << std::endl;
63046 : }
63047 : }
63048 :
63049 0 : if ( p_startOfConstruct != NULL )
63050 : {
63051 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63052 : {
63053 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
63054 : {
63055 0 : std::cout << "SgBreakStmt :: ";
63056 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
63057 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
63058 : }
63059 : }
63060 : else
63061 : {
63062 0 : std::cout << "SgBreakStmt :: " << std::flush;
63063 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
63064 0 : std::cout << " not valid " << std::endl;
63065 : }
63066 : }
63067 :
63068 0 : if ( p_endOfConstruct != NULL )
63069 : {
63070 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63071 : {
63072 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
63073 : {
63074 0 : std::cout << "SgBreakStmt :: ";
63075 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
63076 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
63077 : }
63078 : }
63079 : else
63080 : {
63081 0 : std::cout << "SgBreakStmt :: " << std::flush;
63082 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
63083 0 : std::cout << " not valid " << std::endl;
63084 : }
63085 : }
63086 :
63087 0 : if ( p_parent != NULL )
63088 : {
63089 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63090 : {
63091 0 : if ( p_parent->isInMemoryPool() == false )
63092 : {
63093 0 : std::cout << "SgBreakStmt :: ";
63094 0 : std::cout << " p_parent is not in memory pool of ";
63095 0 : std::cout << p_parent->class_name() << std::endl;
63096 : }
63097 : }
63098 : else
63099 : {
63100 0 : std::cout << "SgBreakStmt :: " << std::flush;
63101 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
63102 0 : std::cout << " not valid " << std::endl;
63103 : }
63104 : }
63105 :
63106 :
63107 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63108 :
63109 0 : }
63110 :
63111 :
63112 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
63113 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
63114 : bool
63115 0 : SgBreakStmt::isInMemoryPool ()
63116 : {
63117 0 : typedef unsigned char* TestType;
63118 :
63119 0 : bool found = false;
63120 :
63121 0 : ROSE_ASSERT(this != NULL);
63122 :
63123 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
63124 :
63125 0 : TestType tested = (TestType) ( this ) ;
63126 :
63127 0 : std::vector < unsigned char* > :: const_iterator block = SgBreakStmt::pools.begin();
63128 :
63129 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
63130 : // while (found == false && block < Memory_Block_List.end())
63131 0 : while ( (found == false) && (block != SgBreakStmt::pools.end()) )
63132 : {
63133 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgBreakStmt::pool_size * sizeof(SgBreakStmt) ) ) ;
63134 0 : ++block;
63135 : }
63136 :
63137 : // Special handling for static data
63138 :
63139 :
63140 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
63141 0 : ROSE_ASSERT(found == true);
63142 :
63143 0 : return found;
63144 : }
63145 : /* #line 63146 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
63146 :
63147 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
63148 :
63149 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63150 :
63151 : /* #line 63152 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
63152 :
63153 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63154 :
63155 : void
63156 0 : SgContinueStmt::checkDataMemberPointersIfInMemoryPool()
63157 : {
63158 : // ------------ checking pointers of SgContinueStmt -------------------
63159 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
63160 :
63161 0 : if ( p_numeric_label != NULL )
63162 : {
63163 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63164 : {
63165 0 : if ( p_numeric_label->isInMemoryPool() == false )
63166 : {
63167 0 : std::cout << "SgContinueStmt :: ";
63168 0 : std::cout << " p_numeric_label is not in memory pool of ";
63169 0 : std::cout << p_numeric_label->class_name() << std::endl;
63170 : }
63171 : }
63172 : else
63173 : {
63174 0 : std::cout << "SgContinueStmt :: " << std::flush;
63175 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
63176 0 : std::cout << " not valid " << std::endl;
63177 : }
63178 : }
63179 :
63180 0 : if ( p_startOfConstruct != NULL )
63181 : {
63182 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63183 : {
63184 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
63185 : {
63186 0 : std::cout << "SgContinueStmt :: ";
63187 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
63188 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
63189 : }
63190 : }
63191 : else
63192 : {
63193 0 : std::cout << "SgContinueStmt :: " << std::flush;
63194 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
63195 0 : std::cout << " not valid " << std::endl;
63196 : }
63197 : }
63198 :
63199 0 : if ( p_endOfConstruct != NULL )
63200 : {
63201 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63202 : {
63203 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
63204 : {
63205 0 : std::cout << "SgContinueStmt :: ";
63206 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
63207 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
63208 : }
63209 : }
63210 : else
63211 : {
63212 0 : std::cout << "SgContinueStmt :: " << std::flush;
63213 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
63214 0 : std::cout << " not valid " << std::endl;
63215 : }
63216 : }
63217 :
63218 0 : if ( p_parent != NULL )
63219 : {
63220 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63221 : {
63222 0 : if ( p_parent->isInMemoryPool() == false )
63223 : {
63224 0 : std::cout << "SgContinueStmt :: ";
63225 0 : std::cout << " p_parent is not in memory pool of ";
63226 0 : std::cout << p_parent->class_name() << std::endl;
63227 : }
63228 : }
63229 : else
63230 : {
63231 0 : std::cout << "SgContinueStmt :: " << std::flush;
63232 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
63233 0 : std::cout << " not valid " << std::endl;
63234 : }
63235 : }
63236 :
63237 :
63238 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63239 :
63240 0 : }
63241 :
63242 :
63243 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
63244 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
63245 : bool
63246 0 : SgContinueStmt::isInMemoryPool ()
63247 : {
63248 0 : typedef unsigned char* TestType;
63249 :
63250 0 : bool found = false;
63251 :
63252 0 : ROSE_ASSERT(this != NULL);
63253 :
63254 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
63255 :
63256 0 : TestType tested = (TestType) ( this ) ;
63257 :
63258 0 : std::vector < unsigned char* > :: const_iterator block = SgContinueStmt::pools.begin();
63259 :
63260 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
63261 : // while (found == false && block < Memory_Block_List.end())
63262 0 : while ( (found == false) && (block != SgContinueStmt::pools.end()) )
63263 : {
63264 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgContinueStmt::pool_size * sizeof(SgContinueStmt) ) ) ;
63265 0 : ++block;
63266 : }
63267 :
63268 : // Special handling for static data
63269 :
63270 :
63271 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
63272 0 : ROSE_ASSERT(found == true);
63273 :
63274 0 : return found;
63275 : }
63276 : /* #line 63277 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
63277 :
63278 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
63279 :
63280 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63281 :
63282 : /* #line 63283 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
63283 :
63284 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63285 :
63286 : void
63287 0 : SgReturnStmt::checkDataMemberPointersIfInMemoryPool()
63288 : {
63289 : // ------------ checking pointers of SgReturnStmt -------------------
63290 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
63291 :
63292 0 : if ( p_expression != NULL )
63293 : {
63294 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63295 : {
63296 0 : if ( p_expression->isInMemoryPool() == false )
63297 : {
63298 0 : std::cout << "SgReturnStmt :: ";
63299 0 : std::cout << " p_expression is not in memory pool of ";
63300 0 : std::cout << p_expression->class_name() << std::endl;
63301 : }
63302 : }
63303 : else
63304 : {
63305 0 : std::cout << "SgReturnStmt :: " << std::flush;
63306 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
63307 0 : std::cout << " not valid " << std::endl;
63308 : }
63309 : }
63310 :
63311 0 : if ( p_numeric_label != NULL )
63312 : {
63313 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63314 : {
63315 0 : if ( p_numeric_label->isInMemoryPool() == false )
63316 : {
63317 0 : std::cout << "SgReturnStmt :: ";
63318 0 : std::cout << " p_numeric_label is not in memory pool of ";
63319 0 : std::cout << p_numeric_label->class_name() << std::endl;
63320 : }
63321 : }
63322 : else
63323 : {
63324 0 : std::cout << "SgReturnStmt :: " << std::flush;
63325 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
63326 0 : std::cout << " not valid " << std::endl;
63327 : }
63328 : }
63329 :
63330 0 : if ( p_startOfConstruct != NULL )
63331 : {
63332 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63333 : {
63334 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
63335 : {
63336 0 : std::cout << "SgReturnStmt :: ";
63337 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
63338 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
63339 : }
63340 : }
63341 : else
63342 : {
63343 0 : std::cout << "SgReturnStmt :: " << std::flush;
63344 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
63345 0 : std::cout << " not valid " << std::endl;
63346 : }
63347 : }
63348 :
63349 0 : if ( p_endOfConstruct != NULL )
63350 : {
63351 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63352 : {
63353 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
63354 : {
63355 0 : std::cout << "SgReturnStmt :: ";
63356 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
63357 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
63358 : }
63359 : }
63360 : else
63361 : {
63362 0 : std::cout << "SgReturnStmt :: " << std::flush;
63363 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
63364 0 : std::cout << " not valid " << std::endl;
63365 : }
63366 : }
63367 :
63368 0 : if ( p_parent != NULL )
63369 : {
63370 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63371 : {
63372 0 : if ( p_parent->isInMemoryPool() == false )
63373 : {
63374 0 : std::cout << "SgReturnStmt :: ";
63375 0 : std::cout << " p_parent is not in memory pool of ";
63376 0 : std::cout << p_parent->class_name() << std::endl;
63377 : }
63378 : }
63379 : else
63380 : {
63381 0 : std::cout << "SgReturnStmt :: " << std::flush;
63382 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
63383 0 : std::cout << " not valid " << std::endl;
63384 : }
63385 : }
63386 :
63387 :
63388 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63389 :
63390 0 : }
63391 :
63392 :
63393 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
63394 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
63395 : bool
63396 0 : SgReturnStmt::isInMemoryPool ()
63397 : {
63398 0 : typedef unsigned char* TestType;
63399 :
63400 0 : bool found = false;
63401 :
63402 0 : ROSE_ASSERT(this != NULL);
63403 :
63404 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
63405 :
63406 0 : TestType tested = (TestType) ( this ) ;
63407 :
63408 0 : std::vector < unsigned char* > :: const_iterator block = SgReturnStmt::pools.begin();
63409 :
63410 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
63411 : // while (found == false && block < Memory_Block_List.end())
63412 0 : while ( (found == false) && (block != SgReturnStmt::pools.end()) )
63413 : {
63414 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgReturnStmt::pool_size * sizeof(SgReturnStmt) ) ) ;
63415 0 : ++block;
63416 : }
63417 :
63418 : // Special handling for static data
63419 :
63420 :
63421 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
63422 0 : ROSE_ASSERT(found == true);
63423 :
63424 0 : return found;
63425 : }
63426 : /* #line 63427 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
63427 :
63428 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
63429 :
63430 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63431 :
63432 : /* #line 63433 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
63433 :
63434 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63435 :
63436 : void
63437 0 : SgGotoStatement::checkDataMemberPointersIfInMemoryPool()
63438 : {
63439 : // ------------ checking pointers of SgGotoStatement -------------------
63440 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
63441 :
63442 0 : if ( p_label != NULL )
63443 : {
63444 0 : if ( p_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63445 : {
63446 0 : if ( p_label->isInMemoryPool() == false )
63447 : {
63448 0 : std::cout << "SgGotoStatement :: ";
63449 0 : std::cout << " p_label is not in memory pool of ";
63450 0 : std::cout << p_label->class_name() << std::endl;
63451 : }
63452 : }
63453 : else
63454 : {
63455 0 : std::cout << "SgGotoStatement :: " << std::flush;
63456 0 : std::cout << "SgLabelStatement* p_label = " << p_label << " --> " << std::flush;
63457 0 : std::cout << " not valid " << std::endl;
63458 : }
63459 : }
63460 :
63461 0 : if ( p_label_expression != NULL )
63462 : {
63463 0 : if ( p_label_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63464 : {
63465 0 : if ( p_label_expression->isInMemoryPool() == false )
63466 : {
63467 0 : std::cout << "SgGotoStatement :: ";
63468 0 : std::cout << " p_label_expression is not in memory pool of ";
63469 0 : std::cout << p_label_expression->class_name() << std::endl;
63470 : }
63471 : }
63472 : else
63473 : {
63474 0 : std::cout << "SgGotoStatement :: " << std::flush;
63475 0 : std::cout << "SgLabelRefExp* p_label_expression = " << p_label_expression << " --> " << std::flush;
63476 0 : std::cout << " not valid " << std::endl;
63477 : }
63478 : }
63479 :
63480 0 : if ( p_selector_expression != NULL )
63481 : {
63482 0 : if ( p_selector_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63483 : {
63484 0 : if ( p_selector_expression->isInMemoryPool() == false )
63485 : {
63486 0 : std::cout << "SgGotoStatement :: ";
63487 0 : std::cout << " p_selector_expression is not in memory pool of ";
63488 0 : std::cout << p_selector_expression->class_name() << std::endl;
63489 : }
63490 : }
63491 : else
63492 : {
63493 0 : std::cout << "SgGotoStatement :: " << std::flush;
63494 0 : std::cout << "SgExpression* p_selector_expression = " << p_selector_expression << " --> " << std::flush;
63495 0 : std::cout << " not valid " << std::endl;
63496 : }
63497 : }
63498 :
63499 0 : if ( p_numeric_label != NULL )
63500 : {
63501 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63502 : {
63503 0 : if ( p_numeric_label->isInMemoryPool() == false )
63504 : {
63505 0 : std::cout << "SgGotoStatement :: ";
63506 0 : std::cout << " p_numeric_label is not in memory pool of ";
63507 0 : std::cout << p_numeric_label->class_name() << std::endl;
63508 : }
63509 : }
63510 : else
63511 : {
63512 0 : std::cout << "SgGotoStatement :: " << std::flush;
63513 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
63514 0 : std::cout << " not valid " << std::endl;
63515 : }
63516 : }
63517 :
63518 0 : if ( p_startOfConstruct != NULL )
63519 : {
63520 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63521 : {
63522 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
63523 : {
63524 0 : std::cout << "SgGotoStatement :: ";
63525 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
63526 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
63527 : }
63528 : }
63529 : else
63530 : {
63531 0 : std::cout << "SgGotoStatement :: " << std::flush;
63532 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
63533 0 : std::cout << " not valid " << std::endl;
63534 : }
63535 : }
63536 :
63537 0 : if ( p_endOfConstruct != NULL )
63538 : {
63539 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63540 : {
63541 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
63542 : {
63543 0 : std::cout << "SgGotoStatement :: ";
63544 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
63545 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
63546 : }
63547 : }
63548 : else
63549 : {
63550 0 : std::cout << "SgGotoStatement :: " << std::flush;
63551 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
63552 0 : std::cout << " not valid " << std::endl;
63553 : }
63554 : }
63555 :
63556 0 : if ( p_parent != NULL )
63557 : {
63558 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63559 : {
63560 0 : if ( p_parent->isInMemoryPool() == false )
63561 : {
63562 0 : std::cout << "SgGotoStatement :: ";
63563 0 : std::cout << " p_parent is not in memory pool of ";
63564 0 : std::cout << p_parent->class_name() << std::endl;
63565 : }
63566 : }
63567 : else
63568 : {
63569 0 : std::cout << "SgGotoStatement :: " << std::flush;
63570 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
63571 0 : std::cout << " not valid " << std::endl;
63572 : }
63573 : }
63574 :
63575 :
63576 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63577 :
63578 0 : }
63579 :
63580 :
63581 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
63582 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
63583 : bool
63584 0 : SgGotoStatement::isInMemoryPool ()
63585 : {
63586 0 : typedef unsigned char* TestType;
63587 :
63588 0 : bool found = false;
63589 :
63590 0 : ROSE_ASSERT(this != NULL);
63591 :
63592 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
63593 :
63594 0 : TestType tested = (TestType) ( this ) ;
63595 :
63596 0 : std::vector < unsigned char* > :: const_iterator block = SgGotoStatement::pools.begin();
63597 :
63598 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
63599 : // while (found == false && block < Memory_Block_List.end())
63600 0 : while ( (found == false) && (block != SgGotoStatement::pools.end()) )
63601 : {
63602 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgGotoStatement::pool_size * sizeof(SgGotoStatement) ) ) ;
63603 0 : ++block;
63604 : }
63605 :
63606 : // Special handling for static data
63607 :
63608 :
63609 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
63610 0 : ROSE_ASSERT(found == true);
63611 :
63612 0 : return found;
63613 : }
63614 : /* #line 63615 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
63615 :
63616 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
63617 :
63618 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63619 :
63620 : /* #line 63621 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
63621 :
63622 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63623 :
63624 : void
63625 0 : SgSpawnStmt::checkDataMemberPointersIfInMemoryPool()
63626 : {
63627 : // ------------ checking pointers of SgSpawnStmt -------------------
63628 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
63629 :
63630 0 : if ( p_the_func != NULL )
63631 : {
63632 0 : if ( p_the_func->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63633 : {
63634 0 : if ( p_the_func->isInMemoryPool() == false )
63635 : {
63636 0 : std::cout << "SgSpawnStmt :: ";
63637 0 : std::cout << " p_the_func is not in memory pool of ";
63638 0 : std::cout << p_the_func->class_name() << std::endl;
63639 : }
63640 : }
63641 : else
63642 : {
63643 0 : std::cout << "SgSpawnStmt :: " << std::flush;
63644 0 : std::cout << "SgFunctionCallExp* p_the_func = " << p_the_func << " --> " << std::flush;
63645 0 : std::cout << " not valid " << std::endl;
63646 : }
63647 : }
63648 :
63649 0 : if ( p_numeric_label != NULL )
63650 : {
63651 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63652 : {
63653 0 : if ( p_numeric_label->isInMemoryPool() == false )
63654 : {
63655 0 : std::cout << "SgSpawnStmt :: ";
63656 0 : std::cout << " p_numeric_label is not in memory pool of ";
63657 0 : std::cout << p_numeric_label->class_name() << std::endl;
63658 : }
63659 : }
63660 : else
63661 : {
63662 0 : std::cout << "SgSpawnStmt :: " << std::flush;
63663 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
63664 0 : std::cout << " not valid " << std::endl;
63665 : }
63666 : }
63667 :
63668 0 : if ( p_startOfConstruct != NULL )
63669 : {
63670 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63671 : {
63672 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
63673 : {
63674 0 : std::cout << "SgSpawnStmt :: ";
63675 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
63676 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
63677 : }
63678 : }
63679 : else
63680 : {
63681 0 : std::cout << "SgSpawnStmt :: " << std::flush;
63682 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
63683 0 : std::cout << " not valid " << std::endl;
63684 : }
63685 : }
63686 :
63687 0 : if ( p_endOfConstruct != NULL )
63688 : {
63689 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63690 : {
63691 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
63692 : {
63693 0 : std::cout << "SgSpawnStmt :: ";
63694 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
63695 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
63696 : }
63697 : }
63698 : else
63699 : {
63700 0 : std::cout << "SgSpawnStmt :: " << std::flush;
63701 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
63702 0 : std::cout << " not valid " << std::endl;
63703 : }
63704 : }
63705 :
63706 0 : if ( p_parent != NULL )
63707 : {
63708 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63709 : {
63710 0 : if ( p_parent->isInMemoryPool() == false )
63711 : {
63712 0 : std::cout << "SgSpawnStmt :: ";
63713 0 : std::cout << " p_parent is not in memory pool of ";
63714 0 : std::cout << p_parent->class_name() << std::endl;
63715 : }
63716 : }
63717 : else
63718 : {
63719 0 : std::cout << "SgSpawnStmt :: " << std::flush;
63720 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
63721 0 : std::cout << " not valid " << std::endl;
63722 : }
63723 : }
63724 :
63725 :
63726 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63727 :
63728 0 : }
63729 :
63730 :
63731 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
63732 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
63733 : bool
63734 0 : SgSpawnStmt::isInMemoryPool ()
63735 : {
63736 0 : typedef unsigned char* TestType;
63737 :
63738 0 : bool found = false;
63739 :
63740 0 : ROSE_ASSERT(this != NULL);
63741 :
63742 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
63743 :
63744 0 : TestType tested = (TestType) ( this ) ;
63745 :
63746 0 : std::vector < unsigned char* > :: const_iterator block = SgSpawnStmt::pools.begin();
63747 :
63748 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
63749 : // while (found == false && block < Memory_Block_List.end())
63750 0 : while ( (found == false) && (block != SgSpawnStmt::pools.end()) )
63751 : {
63752 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSpawnStmt::pool_size * sizeof(SgSpawnStmt) ) ) ;
63753 0 : ++block;
63754 : }
63755 :
63756 : // Special handling for static data
63757 :
63758 :
63759 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
63760 0 : ROSE_ASSERT(found == true);
63761 :
63762 0 : return found;
63763 : }
63764 : /* #line 63765 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
63765 :
63766 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
63767 :
63768 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63769 :
63770 : /* #line 63771 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
63771 :
63772 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63773 :
63774 : void
63775 0 : SgNullStatement::checkDataMemberPointersIfInMemoryPool()
63776 : {
63777 : // ------------ checking pointers of SgNullStatement -------------------
63778 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
63779 :
63780 0 : if ( p_numeric_label != NULL )
63781 : {
63782 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63783 : {
63784 0 : if ( p_numeric_label->isInMemoryPool() == false )
63785 : {
63786 0 : std::cout << "SgNullStatement :: ";
63787 0 : std::cout << " p_numeric_label is not in memory pool of ";
63788 0 : std::cout << p_numeric_label->class_name() << std::endl;
63789 : }
63790 : }
63791 : else
63792 : {
63793 0 : std::cout << "SgNullStatement :: " << std::flush;
63794 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
63795 0 : std::cout << " not valid " << std::endl;
63796 : }
63797 : }
63798 :
63799 0 : if ( p_startOfConstruct != NULL )
63800 : {
63801 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63802 : {
63803 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
63804 : {
63805 0 : std::cout << "SgNullStatement :: ";
63806 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
63807 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
63808 : }
63809 : }
63810 : else
63811 : {
63812 0 : std::cout << "SgNullStatement :: " << std::flush;
63813 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
63814 0 : std::cout << " not valid " << std::endl;
63815 : }
63816 : }
63817 :
63818 0 : if ( p_endOfConstruct != NULL )
63819 : {
63820 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63821 : {
63822 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
63823 : {
63824 0 : std::cout << "SgNullStatement :: ";
63825 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
63826 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
63827 : }
63828 : }
63829 : else
63830 : {
63831 0 : std::cout << "SgNullStatement :: " << std::flush;
63832 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
63833 0 : std::cout << " not valid " << std::endl;
63834 : }
63835 : }
63836 :
63837 0 : if ( p_parent != NULL )
63838 : {
63839 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63840 : {
63841 0 : if ( p_parent->isInMemoryPool() == false )
63842 : {
63843 0 : std::cout << "SgNullStatement :: ";
63844 0 : std::cout << " p_parent is not in memory pool of ";
63845 0 : std::cout << p_parent->class_name() << std::endl;
63846 : }
63847 : }
63848 : else
63849 : {
63850 0 : std::cout << "SgNullStatement :: " << std::flush;
63851 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
63852 0 : std::cout << " not valid " << std::endl;
63853 : }
63854 : }
63855 :
63856 :
63857 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63858 :
63859 0 : }
63860 :
63861 :
63862 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
63863 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
63864 : bool
63865 0 : SgNullStatement::isInMemoryPool ()
63866 : {
63867 0 : typedef unsigned char* TestType;
63868 :
63869 0 : bool found = false;
63870 :
63871 0 : ROSE_ASSERT(this != NULL);
63872 :
63873 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
63874 :
63875 0 : TestType tested = (TestType) ( this ) ;
63876 :
63877 0 : std::vector < unsigned char* > :: const_iterator block = SgNullStatement::pools.begin();
63878 :
63879 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
63880 : // while (found == false && block < Memory_Block_List.end())
63881 0 : while ( (found == false) && (block != SgNullStatement::pools.end()) )
63882 : {
63883 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNullStatement::pool_size * sizeof(SgNullStatement) ) ) ;
63884 0 : ++block;
63885 : }
63886 :
63887 : // Special handling for static data
63888 :
63889 :
63890 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
63891 0 : ROSE_ASSERT(found == true);
63892 :
63893 0 : return found;
63894 : }
63895 : /* #line 63896 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
63896 :
63897 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
63898 :
63899 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63900 :
63901 : /* #line 63902 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
63902 :
63903 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63904 :
63905 : void
63906 0 : SgVariantStatement::checkDataMemberPointersIfInMemoryPool()
63907 : {
63908 : // ------------ checking pointers of SgVariantStatement -------------------
63909 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
63910 :
63911 0 : if ( p_numeric_label != NULL )
63912 : {
63913 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63914 : {
63915 0 : if ( p_numeric_label->isInMemoryPool() == false )
63916 : {
63917 0 : std::cout << "SgVariantStatement :: ";
63918 0 : std::cout << " p_numeric_label is not in memory pool of ";
63919 0 : std::cout << p_numeric_label->class_name() << std::endl;
63920 : }
63921 : }
63922 : else
63923 : {
63924 0 : std::cout << "SgVariantStatement :: " << std::flush;
63925 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
63926 0 : std::cout << " not valid " << std::endl;
63927 : }
63928 : }
63929 :
63930 0 : if ( p_startOfConstruct != NULL )
63931 : {
63932 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63933 : {
63934 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
63935 : {
63936 0 : std::cout << "SgVariantStatement :: ";
63937 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
63938 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
63939 : }
63940 : }
63941 : else
63942 : {
63943 0 : std::cout << "SgVariantStatement :: " << std::flush;
63944 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
63945 0 : std::cout << " not valid " << std::endl;
63946 : }
63947 : }
63948 :
63949 0 : if ( p_endOfConstruct != NULL )
63950 : {
63951 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63952 : {
63953 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
63954 : {
63955 0 : std::cout << "SgVariantStatement :: ";
63956 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
63957 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
63958 : }
63959 : }
63960 : else
63961 : {
63962 0 : std::cout << "SgVariantStatement :: " << std::flush;
63963 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
63964 0 : std::cout << " not valid " << std::endl;
63965 : }
63966 : }
63967 :
63968 0 : if ( p_parent != NULL )
63969 : {
63970 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
63971 : {
63972 0 : if ( p_parent->isInMemoryPool() == false )
63973 : {
63974 0 : std::cout << "SgVariantStatement :: ";
63975 0 : std::cout << " p_parent is not in memory pool of ";
63976 0 : std::cout << p_parent->class_name() << std::endl;
63977 : }
63978 : }
63979 : else
63980 : {
63981 0 : std::cout << "SgVariantStatement :: " << std::flush;
63982 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
63983 0 : std::cout << " not valid " << std::endl;
63984 : }
63985 : }
63986 :
63987 :
63988 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
63989 :
63990 0 : }
63991 :
63992 :
63993 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
63994 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
63995 : bool
63996 0 : SgVariantStatement::isInMemoryPool ()
63997 : {
63998 0 : typedef unsigned char* TestType;
63999 :
64000 0 : bool found = false;
64001 :
64002 0 : ROSE_ASSERT(this != NULL);
64003 :
64004 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
64005 :
64006 0 : TestType tested = (TestType) ( this ) ;
64007 :
64008 0 : std::vector < unsigned char* > :: const_iterator block = SgVariantStatement::pools.begin();
64009 :
64010 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
64011 : // while (found == false && block < Memory_Block_List.end())
64012 0 : while ( (found == false) && (block != SgVariantStatement::pools.end()) )
64013 : {
64014 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgVariantStatement::pool_size * sizeof(SgVariantStatement) ) ) ;
64015 0 : ++block;
64016 : }
64017 :
64018 : // Special handling for static data
64019 :
64020 :
64021 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
64022 0 : ROSE_ASSERT(found == true);
64023 :
64024 0 : return found;
64025 : }
64026 : /* #line 64027 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
64027 :
64028 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
64029 :
64030 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64031 :
64032 : /* #line 64033 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
64033 :
64034 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64035 :
64036 : void
64037 0 : SgForInitStatement::checkDataMemberPointersIfInMemoryPool()
64038 : {
64039 : // ------------ checking pointers of SgForInitStatement -------------------
64040 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
64041 :
64042 0 : SgStatementPtrList::iterator i_init_stmt = p_init_stmt.begin() ;
64043 0 : for ( ; i_init_stmt != p_init_stmt.end(); ++i_init_stmt )
64044 : {
64045 0 : if ( (*i_init_stmt) != NULL )
64046 : {
64047 0 : if ( (*i_init_stmt)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64048 : {
64049 0 : if ( (*i_init_stmt)->isInMemoryPool() == false )
64050 : {
64051 0 : std::cout << "SgForInitStatement :: ";
64052 0 : std::cout << " p_init_stmt ( list of poitners to IR nodes ), entry is not in memory pool of ";
64053 0 : std::cout << (*i_init_stmt)->class_name() << std::endl;
64054 : }
64055 : }
64056 : else
64057 : {
64058 0 : std::cout << "SgForInitStatement :: " << std::flush;
64059 0 : std::cout << "SgStatementPtrList p_init_stmt --> " << std::flush;
64060 0 : std::cout << " entry not valid " << std::endl;
64061 : }
64062 : }
64063 : else
64064 : {
64065 0 : std::cout << "SgStatementPtrList p_init_stmt --> NULL " << std::endl;
64066 : }
64067 : }
64068 :
64069 0 : if ( p_numeric_label != NULL )
64070 : {
64071 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64072 : {
64073 0 : if ( p_numeric_label->isInMemoryPool() == false )
64074 : {
64075 0 : std::cout << "SgForInitStatement :: ";
64076 0 : std::cout << " p_numeric_label is not in memory pool of ";
64077 0 : std::cout << p_numeric_label->class_name() << std::endl;
64078 : }
64079 : }
64080 : else
64081 : {
64082 0 : std::cout << "SgForInitStatement :: " << std::flush;
64083 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
64084 0 : std::cout << " not valid " << std::endl;
64085 : }
64086 : }
64087 :
64088 0 : if ( p_startOfConstruct != NULL )
64089 : {
64090 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64091 : {
64092 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
64093 : {
64094 0 : std::cout << "SgForInitStatement :: ";
64095 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
64096 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
64097 : }
64098 : }
64099 : else
64100 : {
64101 0 : std::cout << "SgForInitStatement :: " << std::flush;
64102 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
64103 0 : std::cout << " not valid " << std::endl;
64104 : }
64105 : }
64106 :
64107 0 : if ( p_endOfConstruct != NULL )
64108 : {
64109 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64110 : {
64111 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
64112 : {
64113 0 : std::cout << "SgForInitStatement :: ";
64114 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
64115 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
64116 : }
64117 : }
64118 : else
64119 : {
64120 0 : std::cout << "SgForInitStatement :: " << std::flush;
64121 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
64122 0 : std::cout << " not valid " << std::endl;
64123 : }
64124 : }
64125 :
64126 0 : if ( p_parent != NULL )
64127 : {
64128 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64129 : {
64130 0 : if ( p_parent->isInMemoryPool() == false )
64131 : {
64132 0 : std::cout << "SgForInitStatement :: ";
64133 0 : std::cout << " p_parent is not in memory pool of ";
64134 0 : std::cout << p_parent->class_name() << std::endl;
64135 : }
64136 : }
64137 : else
64138 : {
64139 0 : std::cout << "SgForInitStatement :: " << std::flush;
64140 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
64141 0 : std::cout << " not valid " << std::endl;
64142 : }
64143 : }
64144 :
64145 :
64146 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64147 :
64148 0 : }
64149 :
64150 :
64151 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
64152 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
64153 : bool
64154 0 : SgForInitStatement::isInMemoryPool ()
64155 : {
64156 0 : typedef unsigned char* TestType;
64157 :
64158 0 : bool found = false;
64159 :
64160 0 : ROSE_ASSERT(this != NULL);
64161 :
64162 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
64163 :
64164 0 : TestType tested = (TestType) ( this ) ;
64165 :
64166 0 : std::vector < unsigned char* > :: const_iterator block = SgForInitStatement::pools.begin();
64167 :
64168 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
64169 : // while (found == false && block < Memory_Block_List.end())
64170 0 : while ( (found == false) && (block != SgForInitStatement::pools.end()) )
64171 : {
64172 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgForInitStatement::pool_size * sizeof(SgForInitStatement) ) ) ;
64173 0 : ++block;
64174 : }
64175 :
64176 : // Special handling for static data
64177 :
64178 :
64179 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
64180 0 : ROSE_ASSERT(found == true);
64181 :
64182 0 : return found;
64183 : }
64184 : /* #line 64185 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
64185 :
64186 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
64187 :
64188 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64189 :
64190 : /* #line 64191 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
64191 :
64192 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64193 :
64194 : void
64195 0 : SgCatchStatementSeq::checkDataMemberPointersIfInMemoryPool()
64196 : {
64197 : // ------------ checking pointers of SgCatchStatementSeq -------------------
64198 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
64199 :
64200 0 : SgStatementPtrList::iterator i_catch_statement_seq = p_catch_statement_seq.begin() ;
64201 0 : for ( ; i_catch_statement_seq != p_catch_statement_seq.end(); ++i_catch_statement_seq )
64202 : {
64203 0 : if ( (*i_catch_statement_seq) != NULL )
64204 : {
64205 0 : if ( (*i_catch_statement_seq)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64206 : {
64207 0 : if ( (*i_catch_statement_seq)->isInMemoryPool() == false )
64208 : {
64209 0 : std::cout << "SgCatchStatementSeq :: ";
64210 0 : std::cout << " p_catch_statement_seq ( list of poitners to IR nodes ), entry is not in memory pool of ";
64211 0 : std::cout << (*i_catch_statement_seq)->class_name() << std::endl;
64212 : }
64213 : }
64214 : else
64215 : {
64216 0 : std::cout << "SgCatchStatementSeq :: " << std::flush;
64217 0 : std::cout << "SgStatementPtrList p_catch_statement_seq --> " << std::flush;
64218 0 : std::cout << " entry not valid " << std::endl;
64219 : }
64220 : }
64221 : else
64222 : {
64223 0 : std::cout << "SgStatementPtrList p_catch_statement_seq --> NULL " << std::endl;
64224 : }
64225 : }
64226 :
64227 0 : if ( p_numeric_label != NULL )
64228 : {
64229 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64230 : {
64231 0 : if ( p_numeric_label->isInMemoryPool() == false )
64232 : {
64233 0 : std::cout << "SgCatchStatementSeq :: ";
64234 0 : std::cout << " p_numeric_label is not in memory pool of ";
64235 0 : std::cout << p_numeric_label->class_name() << std::endl;
64236 : }
64237 : }
64238 : else
64239 : {
64240 0 : std::cout << "SgCatchStatementSeq :: " << std::flush;
64241 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
64242 0 : std::cout << " not valid " << std::endl;
64243 : }
64244 : }
64245 :
64246 0 : if ( p_startOfConstruct != NULL )
64247 : {
64248 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64249 : {
64250 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
64251 : {
64252 0 : std::cout << "SgCatchStatementSeq :: ";
64253 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
64254 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
64255 : }
64256 : }
64257 : else
64258 : {
64259 0 : std::cout << "SgCatchStatementSeq :: " << std::flush;
64260 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
64261 0 : std::cout << " not valid " << std::endl;
64262 : }
64263 : }
64264 :
64265 0 : if ( p_endOfConstruct != NULL )
64266 : {
64267 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64268 : {
64269 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
64270 : {
64271 0 : std::cout << "SgCatchStatementSeq :: ";
64272 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
64273 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
64274 : }
64275 : }
64276 : else
64277 : {
64278 0 : std::cout << "SgCatchStatementSeq :: " << std::flush;
64279 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
64280 0 : std::cout << " not valid " << std::endl;
64281 : }
64282 : }
64283 :
64284 0 : if ( p_parent != NULL )
64285 : {
64286 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64287 : {
64288 0 : if ( p_parent->isInMemoryPool() == false )
64289 : {
64290 0 : std::cout << "SgCatchStatementSeq :: ";
64291 0 : std::cout << " p_parent is not in memory pool of ";
64292 0 : std::cout << p_parent->class_name() << std::endl;
64293 : }
64294 : }
64295 : else
64296 : {
64297 0 : std::cout << "SgCatchStatementSeq :: " << std::flush;
64298 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
64299 0 : std::cout << " not valid " << std::endl;
64300 : }
64301 : }
64302 :
64303 :
64304 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64305 :
64306 0 : }
64307 :
64308 :
64309 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
64310 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
64311 : bool
64312 0 : SgCatchStatementSeq::isInMemoryPool ()
64313 : {
64314 0 : typedef unsigned char* TestType;
64315 :
64316 0 : bool found = false;
64317 :
64318 0 : ROSE_ASSERT(this != NULL);
64319 :
64320 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
64321 :
64322 0 : TestType tested = (TestType) ( this ) ;
64323 :
64324 0 : std::vector < unsigned char* > :: const_iterator block = SgCatchStatementSeq::pools.begin();
64325 :
64326 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
64327 : // while (found == false && block < Memory_Block_List.end())
64328 0 : while ( (found == false) && (block != SgCatchStatementSeq::pools.end()) )
64329 : {
64330 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCatchStatementSeq::pool_size * sizeof(SgCatchStatementSeq) ) ) ;
64331 0 : ++block;
64332 : }
64333 :
64334 : // Special handling for static data
64335 :
64336 :
64337 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
64338 0 : ROSE_ASSERT(found == true);
64339 :
64340 0 : return found;
64341 : }
64342 : /* #line 64343 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
64343 :
64344 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
64345 :
64346 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64347 :
64348 : /* #line 64349 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
64349 :
64350 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64351 :
64352 : void
64353 0 : SgProcessControlStatement::checkDataMemberPointersIfInMemoryPool()
64354 : {
64355 : // ------------ checking pointers of SgProcessControlStatement -------------------
64356 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
64357 :
64358 0 : if ( p_code != NULL )
64359 : {
64360 0 : if ( p_code->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64361 : {
64362 0 : if ( p_code->isInMemoryPool() == false )
64363 : {
64364 0 : std::cout << "SgProcessControlStatement :: ";
64365 0 : std::cout << " p_code is not in memory pool of ";
64366 0 : std::cout << p_code->class_name() << std::endl;
64367 : }
64368 : }
64369 : else
64370 : {
64371 0 : std::cout << "SgProcessControlStatement :: " << std::flush;
64372 0 : std::cout << "SgExpression* p_code = " << p_code << " --> " << std::flush;
64373 0 : std::cout << " not valid " << std::endl;
64374 : }
64375 : }
64376 :
64377 0 : if ( p_quiet != NULL )
64378 : {
64379 0 : if ( p_quiet->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64380 : {
64381 0 : if ( p_quiet->isInMemoryPool() == false )
64382 : {
64383 0 : std::cout << "SgProcessControlStatement :: ";
64384 0 : std::cout << " p_quiet is not in memory pool of ";
64385 0 : std::cout << p_quiet->class_name() << std::endl;
64386 : }
64387 : }
64388 : else
64389 : {
64390 0 : std::cout << "SgProcessControlStatement :: " << std::flush;
64391 0 : std::cout << "SgExpression* p_quiet = " << p_quiet << " --> " << std::flush;
64392 0 : std::cout << " not valid " << std::endl;
64393 : }
64394 : }
64395 :
64396 0 : if ( p_numeric_label != NULL )
64397 : {
64398 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64399 : {
64400 0 : if ( p_numeric_label->isInMemoryPool() == false )
64401 : {
64402 0 : std::cout << "SgProcessControlStatement :: ";
64403 0 : std::cout << " p_numeric_label is not in memory pool of ";
64404 0 : std::cout << p_numeric_label->class_name() << std::endl;
64405 : }
64406 : }
64407 : else
64408 : {
64409 0 : std::cout << "SgProcessControlStatement :: " << std::flush;
64410 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
64411 0 : std::cout << " not valid " << std::endl;
64412 : }
64413 : }
64414 :
64415 0 : if ( p_startOfConstruct != NULL )
64416 : {
64417 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64418 : {
64419 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
64420 : {
64421 0 : std::cout << "SgProcessControlStatement :: ";
64422 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
64423 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
64424 : }
64425 : }
64426 : else
64427 : {
64428 0 : std::cout << "SgProcessControlStatement :: " << std::flush;
64429 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
64430 0 : std::cout << " not valid " << std::endl;
64431 : }
64432 : }
64433 :
64434 0 : if ( p_endOfConstruct != NULL )
64435 : {
64436 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64437 : {
64438 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
64439 : {
64440 0 : std::cout << "SgProcessControlStatement :: ";
64441 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
64442 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
64443 : }
64444 : }
64445 : else
64446 : {
64447 0 : std::cout << "SgProcessControlStatement :: " << std::flush;
64448 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
64449 0 : std::cout << " not valid " << std::endl;
64450 : }
64451 : }
64452 :
64453 0 : if ( p_parent != NULL )
64454 : {
64455 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64456 : {
64457 0 : if ( p_parent->isInMemoryPool() == false )
64458 : {
64459 0 : std::cout << "SgProcessControlStatement :: ";
64460 0 : std::cout << " p_parent is not in memory pool of ";
64461 0 : std::cout << p_parent->class_name() << std::endl;
64462 : }
64463 : }
64464 : else
64465 : {
64466 0 : std::cout << "SgProcessControlStatement :: " << std::flush;
64467 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
64468 0 : std::cout << " not valid " << std::endl;
64469 : }
64470 : }
64471 :
64472 :
64473 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64474 :
64475 0 : }
64476 :
64477 :
64478 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
64479 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
64480 : bool
64481 0 : SgProcessControlStatement::isInMemoryPool ()
64482 : {
64483 0 : typedef unsigned char* TestType;
64484 :
64485 0 : bool found = false;
64486 :
64487 0 : ROSE_ASSERT(this != NULL);
64488 :
64489 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
64490 :
64491 0 : TestType tested = (TestType) ( this ) ;
64492 :
64493 0 : std::vector < unsigned char* > :: const_iterator block = SgProcessControlStatement::pools.begin();
64494 :
64495 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
64496 : // while (found == false && block < Memory_Block_List.end())
64497 0 : while ( (found == false) && (block != SgProcessControlStatement::pools.end()) )
64498 : {
64499 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgProcessControlStatement::pool_size * sizeof(SgProcessControlStatement) ) ) ;
64500 0 : ++block;
64501 : }
64502 :
64503 : // Special handling for static data
64504 :
64505 :
64506 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
64507 0 : ROSE_ASSERT(found == true);
64508 :
64509 0 : return found;
64510 : }
64511 : /* #line 64512 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
64512 :
64513 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
64514 :
64515 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64516 :
64517 : /* #line 64518 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
64518 :
64519 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64520 :
64521 : void
64522 0 : SgIOStatement::checkDataMemberPointersIfInMemoryPool()
64523 : {
64524 : // ------------ checking pointers of SgIOStatement -------------------
64525 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
64526 :
64527 0 : if ( p_io_stmt_list != NULL )
64528 : {
64529 0 : if ( p_io_stmt_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64530 : {
64531 0 : if ( p_io_stmt_list->isInMemoryPool() == false )
64532 : {
64533 0 : std::cout << "SgIOStatement :: ";
64534 0 : std::cout << " p_io_stmt_list is not in memory pool of ";
64535 0 : std::cout << p_io_stmt_list->class_name() << std::endl;
64536 : }
64537 : }
64538 : else
64539 : {
64540 0 : std::cout << "SgIOStatement :: " << std::flush;
64541 0 : std::cout << "SgExprListExp* p_io_stmt_list = " << p_io_stmt_list << " --> " << std::flush;
64542 0 : std::cout << " not valid " << std::endl;
64543 : }
64544 : }
64545 :
64546 0 : if ( p_unit != NULL )
64547 : {
64548 0 : if ( p_unit->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64549 : {
64550 0 : if ( p_unit->isInMemoryPool() == false )
64551 : {
64552 0 : std::cout << "SgIOStatement :: ";
64553 0 : std::cout << " p_unit is not in memory pool of ";
64554 0 : std::cout << p_unit->class_name() << std::endl;
64555 : }
64556 : }
64557 : else
64558 : {
64559 0 : std::cout << "SgIOStatement :: " << std::flush;
64560 0 : std::cout << "SgExpression* p_unit = " << p_unit << " --> " << std::flush;
64561 0 : std::cout << " not valid " << std::endl;
64562 : }
64563 : }
64564 :
64565 0 : if ( p_iostat != NULL )
64566 : {
64567 0 : if ( p_iostat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64568 : {
64569 0 : if ( p_iostat->isInMemoryPool() == false )
64570 : {
64571 0 : std::cout << "SgIOStatement :: ";
64572 0 : std::cout << " p_iostat is not in memory pool of ";
64573 0 : std::cout << p_iostat->class_name() << std::endl;
64574 : }
64575 : }
64576 : else
64577 : {
64578 0 : std::cout << "SgIOStatement :: " << std::flush;
64579 0 : std::cout << "SgExpression* p_iostat = " << p_iostat << " --> " << std::flush;
64580 0 : std::cout << " not valid " << std::endl;
64581 : }
64582 : }
64583 :
64584 0 : if ( p_err != NULL )
64585 : {
64586 0 : if ( p_err->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64587 : {
64588 0 : if ( p_err->isInMemoryPool() == false )
64589 : {
64590 0 : std::cout << "SgIOStatement :: ";
64591 0 : std::cout << " p_err is not in memory pool of ";
64592 0 : std::cout << p_err->class_name() << std::endl;
64593 : }
64594 : }
64595 : else
64596 : {
64597 0 : std::cout << "SgIOStatement :: " << std::flush;
64598 0 : std::cout << "SgExpression* p_err = " << p_err << " --> " << std::flush;
64599 0 : std::cout << " not valid " << std::endl;
64600 : }
64601 : }
64602 :
64603 0 : if ( p_iomsg != NULL )
64604 : {
64605 0 : if ( p_iomsg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64606 : {
64607 0 : if ( p_iomsg->isInMemoryPool() == false )
64608 : {
64609 0 : std::cout << "SgIOStatement :: ";
64610 0 : std::cout << " p_iomsg is not in memory pool of ";
64611 0 : std::cout << p_iomsg->class_name() << std::endl;
64612 : }
64613 : }
64614 : else
64615 : {
64616 0 : std::cout << "SgIOStatement :: " << std::flush;
64617 0 : std::cout << "SgExpression* p_iomsg = " << p_iomsg << " --> " << std::flush;
64618 0 : std::cout << " not valid " << std::endl;
64619 : }
64620 : }
64621 :
64622 0 : if ( p_numeric_label != NULL )
64623 : {
64624 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64625 : {
64626 0 : if ( p_numeric_label->isInMemoryPool() == false )
64627 : {
64628 0 : std::cout << "SgIOStatement :: ";
64629 0 : std::cout << " p_numeric_label is not in memory pool of ";
64630 0 : std::cout << p_numeric_label->class_name() << std::endl;
64631 : }
64632 : }
64633 : else
64634 : {
64635 0 : std::cout << "SgIOStatement :: " << std::flush;
64636 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
64637 0 : std::cout << " not valid " << std::endl;
64638 : }
64639 : }
64640 :
64641 0 : if ( p_startOfConstruct != NULL )
64642 : {
64643 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64644 : {
64645 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
64646 : {
64647 0 : std::cout << "SgIOStatement :: ";
64648 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
64649 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
64650 : }
64651 : }
64652 : else
64653 : {
64654 0 : std::cout << "SgIOStatement :: " << std::flush;
64655 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
64656 0 : std::cout << " not valid " << std::endl;
64657 : }
64658 : }
64659 :
64660 0 : if ( p_endOfConstruct != NULL )
64661 : {
64662 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64663 : {
64664 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
64665 : {
64666 0 : std::cout << "SgIOStatement :: ";
64667 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
64668 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
64669 : }
64670 : }
64671 : else
64672 : {
64673 0 : std::cout << "SgIOStatement :: " << std::flush;
64674 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
64675 0 : std::cout << " not valid " << std::endl;
64676 : }
64677 : }
64678 :
64679 0 : if ( p_parent != NULL )
64680 : {
64681 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64682 : {
64683 0 : if ( p_parent->isInMemoryPool() == false )
64684 : {
64685 0 : std::cout << "SgIOStatement :: ";
64686 0 : std::cout << " p_parent is not in memory pool of ";
64687 0 : std::cout << p_parent->class_name() << std::endl;
64688 : }
64689 : }
64690 : else
64691 : {
64692 0 : std::cout << "SgIOStatement :: " << std::flush;
64693 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
64694 0 : std::cout << " not valid " << std::endl;
64695 : }
64696 : }
64697 :
64698 :
64699 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64700 :
64701 0 : }
64702 :
64703 :
64704 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
64705 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
64706 : bool
64707 0 : SgIOStatement::isInMemoryPool ()
64708 : {
64709 0 : typedef unsigned char* TestType;
64710 :
64711 0 : bool found = false;
64712 :
64713 0 : ROSE_ASSERT(this != NULL);
64714 :
64715 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
64716 :
64717 0 : TestType tested = (TestType) ( this ) ;
64718 :
64719 0 : std::vector < unsigned char* > :: const_iterator block = SgIOStatement::pools.begin();
64720 :
64721 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
64722 : // while (found == false && block < Memory_Block_List.end())
64723 0 : while ( (found == false) && (block != SgIOStatement::pools.end()) )
64724 : {
64725 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIOStatement::pool_size * sizeof(SgIOStatement) ) ) ;
64726 0 : ++block;
64727 : }
64728 :
64729 : // Special handling for static data
64730 :
64731 :
64732 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
64733 0 : ROSE_ASSERT(found == true);
64734 :
64735 0 : return found;
64736 : }
64737 : /* #line 64738 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
64738 :
64739 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
64740 :
64741 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64742 :
64743 : /* #line 64744 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
64744 :
64745 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64746 :
64747 : void
64748 0 : SgPrintStatement::checkDataMemberPointersIfInMemoryPool()
64749 : {
64750 : // ------------ checking pointers of SgPrintStatement -------------------
64751 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
64752 :
64753 0 : if ( p_format != NULL )
64754 : {
64755 0 : if ( p_format->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64756 : {
64757 0 : if ( p_format->isInMemoryPool() == false )
64758 : {
64759 0 : std::cout << "SgPrintStatement :: ";
64760 0 : std::cout << " p_format is not in memory pool of ";
64761 0 : std::cout << p_format->class_name() << std::endl;
64762 : }
64763 : }
64764 : else
64765 : {
64766 0 : std::cout << "SgPrintStatement :: " << std::flush;
64767 0 : std::cout << "SgExpression* p_format = " << p_format << " --> " << std::flush;
64768 0 : std::cout << " not valid " << std::endl;
64769 : }
64770 : }
64771 :
64772 0 : if ( p_io_stmt_list != NULL )
64773 : {
64774 0 : if ( p_io_stmt_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64775 : {
64776 0 : if ( p_io_stmt_list->isInMemoryPool() == false )
64777 : {
64778 0 : std::cout << "SgPrintStatement :: ";
64779 0 : std::cout << " p_io_stmt_list is not in memory pool of ";
64780 0 : std::cout << p_io_stmt_list->class_name() << std::endl;
64781 : }
64782 : }
64783 : else
64784 : {
64785 0 : std::cout << "SgPrintStatement :: " << std::flush;
64786 0 : std::cout << "SgExprListExp* p_io_stmt_list = " << p_io_stmt_list << " --> " << std::flush;
64787 0 : std::cout << " not valid " << std::endl;
64788 : }
64789 : }
64790 :
64791 0 : if ( p_unit != NULL )
64792 : {
64793 0 : if ( p_unit->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64794 : {
64795 0 : if ( p_unit->isInMemoryPool() == false )
64796 : {
64797 0 : std::cout << "SgPrintStatement :: ";
64798 0 : std::cout << " p_unit is not in memory pool of ";
64799 0 : std::cout << p_unit->class_name() << std::endl;
64800 : }
64801 : }
64802 : else
64803 : {
64804 0 : std::cout << "SgPrintStatement :: " << std::flush;
64805 0 : std::cout << "SgExpression* p_unit = " << p_unit << " --> " << std::flush;
64806 0 : std::cout << " not valid " << std::endl;
64807 : }
64808 : }
64809 :
64810 0 : if ( p_iostat != NULL )
64811 : {
64812 0 : if ( p_iostat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64813 : {
64814 0 : if ( p_iostat->isInMemoryPool() == false )
64815 : {
64816 0 : std::cout << "SgPrintStatement :: ";
64817 0 : std::cout << " p_iostat is not in memory pool of ";
64818 0 : std::cout << p_iostat->class_name() << std::endl;
64819 : }
64820 : }
64821 : else
64822 : {
64823 0 : std::cout << "SgPrintStatement :: " << std::flush;
64824 0 : std::cout << "SgExpression* p_iostat = " << p_iostat << " --> " << std::flush;
64825 0 : std::cout << " not valid " << std::endl;
64826 : }
64827 : }
64828 :
64829 0 : if ( p_err != NULL )
64830 : {
64831 0 : if ( p_err->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64832 : {
64833 0 : if ( p_err->isInMemoryPool() == false )
64834 : {
64835 0 : std::cout << "SgPrintStatement :: ";
64836 0 : std::cout << " p_err is not in memory pool of ";
64837 0 : std::cout << p_err->class_name() << std::endl;
64838 : }
64839 : }
64840 : else
64841 : {
64842 0 : std::cout << "SgPrintStatement :: " << std::flush;
64843 0 : std::cout << "SgExpression* p_err = " << p_err << " --> " << std::flush;
64844 0 : std::cout << " not valid " << std::endl;
64845 : }
64846 : }
64847 :
64848 0 : if ( p_iomsg != NULL )
64849 : {
64850 0 : if ( p_iomsg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64851 : {
64852 0 : if ( p_iomsg->isInMemoryPool() == false )
64853 : {
64854 0 : std::cout << "SgPrintStatement :: ";
64855 0 : std::cout << " p_iomsg is not in memory pool of ";
64856 0 : std::cout << p_iomsg->class_name() << std::endl;
64857 : }
64858 : }
64859 : else
64860 : {
64861 0 : std::cout << "SgPrintStatement :: " << std::flush;
64862 0 : std::cout << "SgExpression* p_iomsg = " << p_iomsg << " --> " << std::flush;
64863 0 : std::cout << " not valid " << std::endl;
64864 : }
64865 : }
64866 :
64867 0 : if ( p_numeric_label != NULL )
64868 : {
64869 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64870 : {
64871 0 : if ( p_numeric_label->isInMemoryPool() == false )
64872 : {
64873 0 : std::cout << "SgPrintStatement :: ";
64874 0 : std::cout << " p_numeric_label is not in memory pool of ";
64875 0 : std::cout << p_numeric_label->class_name() << std::endl;
64876 : }
64877 : }
64878 : else
64879 : {
64880 0 : std::cout << "SgPrintStatement :: " << std::flush;
64881 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
64882 0 : std::cout << " not valid " << std::endl;
64883 : }
64884 : }
64885 :
64886 0 : if ( p_startOfConstruct != NULL )
64887 : {
64888 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64889 : {
64890 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
64891 : {
64892 0 : std::cout << "SgPrintStatement :: ";
64893 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
64894 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
64895 : }
64896 : }
64897 : else
64898 : {
64899 0 : std::cout << "SgPrintStatement :: " << std::flush;
64900 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
64901 0 : std::cout << " not valid " << std::endl;
64902 : }
64903 : }
64904 :
64905 0 : if ( p_endOfConstruct != NULL )
64906 : {
64907 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64908 : {
64909 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
64910 : {
64911 0 : std::cout << "SgPrintStatement :: ";
64912 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
64913 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
64914 : }
64915 : }
64916 : else
64917 : {
64918 0 : std::cout << "SgPrintStatement :: " << std::flush;
64919 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
64920 0 : std::cout << " not valid " << std::endl;
64921 : }
64922 : }
64923 :
64924 0 : if ( p_parent != NULL )
64925 : {
64926 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
64927 : {
64928 0 : if ( p_parent->isInMemoryPool() == false )
64929 : {
64930 0 : std::cout << "SgPrintStatement :: ";
64931 0 : std::cout << " p_parent is not in memory pool of ";
64932 0 : std::cout << p_parent->class_name() << std::endl;
64933 : }
64934 : }
64935 : else
64936 : {
64937 0 : std::cout << "SgPrintStatement :: " << std::flush;
64938 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
64939 0 : std::cout << " not valid " << std::endl;
64940 : }
64941 : }
64942 :
64943 :
64944 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64945 :
64946 0 : }
64947 :
64948 :
64949 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
64950 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
64951 : bool
64952 0 : SgPrintStatement::isInMemoryPool ()
64953 : {
64954 0 : typedef unsigned char* TestType;
64955 :
64956 0 : bool found = false;
64957 :
64958 0 : ROSE_ASSERT(this != NULL);
64959 :
64960 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
64961 :
64962 0 : TestType tested = (TestType) ( this ) ;
64963 :
64964 0 : std::vector < unsigned char* > :: const_iterator block = SgPrintStatement::pools.begin();
64965 :
64966 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
64967 : // while (found == false && block < Memory_Block_List.end())
64968 0 : while ( (found == false) && (block != SgPrintStatement::pools.end()) )
64969 : {
64970 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgPrintStatement::pool_size * sizeof(SgPrintStatement) ) ) ;
64971 0 : ++block;
64972 : }
64973 :
64974 : // Special handling for static data
64975 :
64976 :
64977 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
64978 0 : ROSE_ASSERT(found == true);
64979 :
64980 0 : return found;
64981 : }
64982 : /* #line 64983 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
64983 :
64984 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
64985 :
64986 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64987 :
64988 : /* #line 64989 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
64989 :
64990 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
64991 :
64992 : void
64993 0 : SgReadStatement::checkDataMemberPointersIfInMemoryPool()
64994 : {
64995 : // ------------ checking pointers of SgReadStatement -------------------
64996 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
64997 :
64998 0 : if ( p_format != NULL )
64999 : {
65000 0 : if ( p_format->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65001 : {
65002 0 : if ( p_format->isInMemoryPool() == false )
65003 : {
65004 0 : std::cout << "SgReadStatement :: ";
65005 0 : std::cout << " p_format is not in memory pool of ";
65006 0 : std::cout << p_format->class_name() << std::endl;
65007 : }
65008 : }
65009 : else
65010 : {
65011 0 : std::cout << "SgReadStatement :: " << std::flush;
65012 0 : std::cout << "SgExpression* p_format = " << p_format << " --> " << std::flush;
65013 0 : std::cout << " not valid " << std::endl;
65014 : }
65015 : }
65016 :
65017 0 : if ( p_namelist != NULL )
65018 : {
65019 0 : if ( p_namelist->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65020 : {
65021 0 : if ( p_namelist->isInMemoryPool() == false )
65022 : {
65023 0 : std::cout << "SgReadStatement :: ";
65024 0 : std::cout << " p_namelist is not in memory pool of ";
65025 0 : std::cout << p_namelist->class_name() << std::endl;
65026 : }
65027 : }
65028 : else
65029 : {
65030 0 : std::cout << "SgReadStatement :: " << std::flush;
65031 0 : std::cout << "SgExpression* p_namelist = " << p_namelist << " --> " << std::flush;
65032 0 : std::cout << " not valid " << std::endl;
65033 : }
65034 : }
65035 :
65036 0 : if ( p_advance != NULL )
65037 : {
65038 0 : if ( p_advance->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65039 : {
65040 0 : if ( p_advance->isInMemoryPool() == false )
65041 : {
65042 0 : std::cout << "SgReadStatement :: ";
65043 0 : std::cout << " p_advance is not in memory pool of ";
65044 0 : std::cout << p_advance->class_name() << std::endl;
65045 : }
65046 : }
65047 : else
65048 : {
65049 0 : std::cout << "SgReadStatement :: " << std::flush;
65050 0 : std::cout << "SgExpression* p_advance = " << p_advance << " --> " << std::flush;
65051 0 : std::cout << " not valid " << std::endl;
65052 : }
65053 : }
65054 :
65055 0 : if ( p_asynchronous != NULL )
65056 : {
65057 0 : if ( p_asynchronous->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65058 : {
65059 0 : if ( p_asynchronous->isInMemoryPool() == false )
65060 : {
65061 0 : std::cout << "SgReadStatement :: ";
65062 0 : std::cout << " p_asynchronous is not in memory pool of ";
65063 0 : std::cout << p_asynchronous->class_name() << std::endl;
65064 : }
65065 : }
65066 : else
65067 : {
65068 0 : std::cout << "SgReadStatement :: " << std::flush;
65069 0 : std::cout << "SgExpression* p_asynchronous = " << p_asynchronous << " --> " << std::flush;
65070 0 : std::cout << " not valid " << std::endl;
65071 : }
65072 : }
65073 :
65074 0 : if ( p_blank != NULL )
65075 : {
65076 0 : if ( p_blank->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65077 : {
65078 0 : if ( p_blank->isInMemoryPool() == false )
65079 : {
65080 0 : std::cout << "SgReadStatement :: ";
65081 0 : std::cout << " p_blank is not in memory pool of ";
65082 0 : std::cout << p_blank->class_name() << std::endl;
65083 : }
65084 : }
65085 : else
65086 : {
65087 0 : std::cout << "SgReadStatement :: " << std::flush;
65088 0 : std::cout << "SgExpression* p_blank = " << p_blank << " --> " << std::flush;
65089 0 : std::cout << " not valid " << std::endl;
65090 : }
65091 : }
65092 :
65093 0 : if ( p_decimal != NULL )
65094 : {
65095 0 : if ( p_decimal->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65096 : {
65097 0 : if ( p_decimal->isInMemoryPool() == false )
65098 : {
65099 0 : std::cout << "SgReadStatement :: ";
65100 0 : std::cout << " p_decimal is not in memory pool of ";
65101 0 : std::cout << p_decimal->class_name() << std::endl;
65102 : }
65103 : }
65104 : else
65105 : {
65106 0 : std::cout << "SgReadStatement :: " << std::flush;
65107 0 : std::cout << "SgExpression* p_decimal = " << p_decimal << " --> " << std::flush;
65108 0 : std::cout << " not valid " << std::endl;
65109 : }
65110 : }
65111 :
65112 0 : if ( p_delim != NULL )
65113 : {
65114 0 : if ( p_delim->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65115 : {
65116 0 : if ( p_delim->isInMemoryPool() == false )
65117 : {
65118 0 : std::cout << "SgReadStatement :: ";
65119 0 : std::cout << " p_delim is not in memory pool of ";
65120 0 : std::cout << p_delim->class_name() << std::endl;
65121 : }
65122 : }
65123 : else
65124 : {
65125 0 : std::cout << "SgReadStatement :: " << std::flush;
65126 0 : std::cout << "SgExpression* p_delim = " << p_delim << " --> " << std::flush;
65127 0 : std::cout << " not valid " << std::endl;
65128 : }
65129 : }
65130 :
65131 0 : if ( p_end != NULL )
65132 : {
65133 0 : if ( p_end->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65134 : {
65135 0 : if ( p_end->isInMemoryPool() == false )
65136 : {
65137 0 : std::cout << "SgReadStatement :: ";
65138 0 : std::cout << " p_end is not in memory pool of ";
65139 0 : std::cout << p_end->class_name() << std::endl;
65140 : }
65141 : }
65142 : else
65143 : {
65144 0 : std::cout << "SgReadStatement :: " << std::flush;
65145 0 : std::cout << "SgExpression* p_end = " << p_end << " --> " << std::flush;
65146 0 : std::cout << " not valid " << std::endl;
65147 : }
65148 : }
65149 :
65150 0 : if ( p_eor != NULL )
65151 : {
65152 0 : if ( p_eor->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65153 : {
65154 0 : if ( p_eor->isInMemoryPool() == false )
65155 : {
65156 0 : std::cout << "SgReadStatement :: ";
65157 0 : std::cout << " p_eor is not in memory pool of ";
65158 0 : std::cout << p_eor->class_name() << std::endl;
65159 : }
65160 : }
65161 : else
65162 : {
65163 0 : std::cout << "SgReadStatement :: " << std::flush;
65164 0 : std::cout << "SgExpression* p_eor = " << p_eor << " --> " << std::flush;
65165 0 : std::cout << " not valid " << std::endl;
65166 : }
65167 : }
65168 :
65169 0 : if ( p_id != NULL )
65170 : {
65171 0 : if ( p_id->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65172 : {
65173 0 : if ( p_id->isInMemoryPool() == false )
65174 : {
65175 0 : std::cout << "SgReadStatement :: ";
65176 0 : std::cout << " p_id is not in memory pool of ";
65177 0 : std::cout << p_id->class_name() << std::endl;
65178 : }
65179 : }
65180 : else
65181 : {
65182 0 : std::cout << "SgReadStatement :: " << std::flush;
65183 0 : std::cout << "SgExpression* p_id = " << p_id << " --> " << std::flush;
65184 0 : std::cout << " not valid " << std::endl;
65185 : }
65186 : }
65187 :
65188 0 : if ( p_pad != NULL )
65189 : {
65190 0 : if ( p_pad->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65191 : {
65192 0 : if ( p_pad->isInMemoryPool() == false )
65193 : {
65194 0 : std::cout << "SgReadStatement :: ";
65195 0 : std::cout << " p_pad is not in memory pool of ";
65196 0 : std::cout << p_pad->class_name() << std::endl;
65197 : }
65198 : }
65199 : else
65200 : {
65201 0 : std::cout << "SgReadStatement :: " << std::flush;
65202 0 : std::cout << "SgExpression* p_pad = " << p_pad << " --> " << std::flush;
65203 0 : std::cout << " not valid " << std::endl;
65204 : }
65205 : }
65206 :
65207 0 : if ( p_pos != NULL )
65208 : {
65209 0 : if ( p_pos->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65210 : {
65211 0 : if ( p_pos->isInMemoryPool() == false )
65212 : {
65213 0 : std::cout << "SgReadStatement :: ";
65214 0 : std::cout << " p_pos is not in memory pool of ";
65215 0 : std::cout << p_pos->class_name() << std::endl;
65216 : }
65217 : }
65218 : else
65219 : {
65220 0 : std::cout << "SgReadStatement :: " << std::flush;
65221 0 : std::cout << "SgExpression* p_pos = " << p_pos << " --> " << std::flush;
65222 0 : std::cout << " not valid " << std::endl;
65223 : }
65224 : }
65225 :
65226 0 : if ( p_rec != NULL )
65227 : {
65228 0 : if ( p_rec->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65229 : {
65230 0 : if ( p_rec->isInMemoryPool() == false )
65231 : {
65232 0 : std::cout << "SgReadStatement :: ";
65233 0 : std::cout << " p_rec is not in memory pool of ";
65234 0 : std::cout << p_rec->class_name() << std::endl;
65235 : }
65236 : }
65237 : else
65238 : {
65239 0 : std::cout << "SgReadStatement :: " << std::flush;
65240 0 : std::cout << "SgExpression* p_rec = " << p_rec << " --> " << std::flush;
65241 0 : std::cout << " not valid " << std::endl;
65242 : }
65243 : }
65244 :
65245 0 : if ( p_round != NULL )
65246 : {
65247 0 : if ( p_round->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65248 : {
65249 0 : if ( p_round->isInMemoryPool() == false )
65250 : {
65251 0 : std::cout << "SgReadStatement :: ";
65252 0 : std::cout << " p_round is not in memory pool of ";
65253 0 : std::cout << p_round->class_name() << std::endl;
65254 : }
65255 : }
65256 : else
65257 : {
65258 0 : std::cout << "SgReadStatement :: " << std::flush;
65259 0 : std::cout << "SgExpression* p_round = " << p_round << " --> " << std::flush;
65260 0 : std::cout << " not valid " << std::endl;
65261 : }
65262 : }
65263 :
65264 0 : if ( p_sign != NULL )
65265 : {
65266 0 : if ( p_sign->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65267 : {
65268 0 : if ( p_sign->isInMemoryPool() == false )
65269 : {
65270 0 : std::cout << "SgReadStatement :: ";
65271 0 : std::cout << " p_sign is not in memory pool of ";
65272 0 : std::cout << p_sign->class_name() << std::endl;
65273 : }
65274 : }
65275 : else
65276 : {
65277 0 : std::cout << "SgReadStatement :: " << std::flush;
65278 0 : std::cout << "SgExpression* p_sign = " << p_sign << " --> " << std::flush;
65279 0 : std::cout << " not valid " << std::endl;
65280 : }
65281 : }
65282 :
65283 0 : if ( p_size != NULL )
65284 : {
65285 0 : if ( p_size->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65286 : {
65287 0 : if ( p_size->isInMemoryPool() == false )
65288 : {
65289 0 : std::cout << "SgReadStatement :: ";
65290 0 : std::cout << " p_size is not in memory pool of ";
65291 0 : std::cout << p_size->class_name() << std::endl;
65292 : }
65293 : }
65294 : else
65295 : {
65296 0 : std::cout << "SgReadStatement :: " << std::flush;
65297 0 : std::cout << "SgExpression* p_size = " << p_size << " --> " << std::flush;
65298 0 : std::cout << " not valid " << std::endl;
65299 : }
65300 : }
65301 :
65302 0 : if ( p_io_stmt_list != NULL )
65303 : {
65304 0 : if ( p_io_stmt_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65305 : {
65306 0 : if ( p_io_stmt_list->isInMemoryPool() == false )
65307 : {
65308 0 : std::cout << "SgReadStatement :: ";
65309 0 : std::cout << " p_io_stmt_list is not in memory pool of ";
65310 0 : std::cout << p_io_stmt_list->class_name() << std::endl;
65311 : }
65312 : }
65313 : else
65314 : {
65315 0 : std::cout << "SgReadStatement :: " << std::flush;
65316 0 : std::cout << "SgExprListExp* p_io_stmt_list = " << p_io_stmt_list << " --> " << std::flush;
65317 0 : std::cout << " not valid " << std::endl;
65318 : }
65319 : }
65320 :
65321 0 : if ( p_unit != NULL )
65322 : {
65323 0 : if ( p_unit->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65324 : {
65325 0 : if ( p_unit->isInMemoryPool() == false )
65326 : {
65327 0 : std::cout << "SgReadStatement :: ";
65328 0 : std::cout << " p_unit is not in memory pool of ";
65329 0 : std::cout << p_unit->class_name() << std::endl;
65330 : }
65331 : }
65332 : else
65333 : {
65334 0 : std::cout << "SgReadStatement :: " << std::flush;
65335 0 : std::cout << "SgExpression* p_unit = " << p_unit << " --> " << std::flush;
65336 0 : std::cout << " not valid " << std::endl;
65337 : }
65338 : }
65339 :
65340 0 : if ( p_iostat != NULL )
65341 : {
65342 0 : if ( p_iostat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65343 : {
65344 0 : if ( p_iostat->isInMemoryPool() == false )
65345 : {
65346 0 : std::cout << "SgReadStatement :: ";
65347 0 : std::cout << " p_iostat is not in memory pool of ";
65348 0 : std::cout << p_iostat->class_name() << std::endl;
65349 : }
65350 : }
65351 : else
65352 : {
65353 0 : std::cout << "SgReadStatement :: " << std::flush;
65354 0 : std::cout << "SgExpression* p_iostat = " << p_iostat << " --> " << std::flush;
65355 0 : std::cout << " not valid " << std::endl;
65356 : }
65357 : }
65358 :
65359 0 : if ( p_err != NULL )
65360 : {
65361 0 : if ( p_err->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65362 : {
65363 0 : if ( p_err->isInMemoryPool() == false )
65364 : {
65365 0 : std::cout << "SgReadStatement :: ";
65366 0 : std::cout << " p_err is not in memory pool of ";
65367 0 : std::cout << p_err->class_name() << std::endl;
65368 : }
65369 : }
65370 : else
65371 : {
65372 0 : std::cout << "SgReadStatement :: " << std::flush;
65373 0 : std::cout << "SgExpression* p_err = " << p_err << " --> " << std::flush;
65374 0 : std::cout << " not valid " << std::endl;
65375 : }
65376 : }
65377 :
65378 0 : if ( p_iomsg != NULL )
65379 : {
65380 0 : if ( p_iomsg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65381 : {
65382 0 : if ( p_iomsg->isInMemoryPool() == false )
65383 : {
65384 0 : std::cout << "SgReadStatement :: ";
65385 0 : std::cout << " p_iomsg is not in memory pool of ";
65386 0 : std::cout << p_iomsg->class_name() << std::endl;
65387 : }
65388 : }
65389 : else
65390 : {
65391 0 : std::cout << "SgReadStatement :: " << std::flush;
65392 0 : std::cout << "SgExpression* p_iomsg = " << p_iomsg << " --> " << std::flush;
65393 0 : std::cout << " not valid " << std::endl;
65394 : }
65395 : }
65396 :
65397 0 : if ( p_numeric_label != NULL )
65398 : {
65399 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65400 : {
65401 0 : if ( p_numeric_label->isInMemoryPool() == false )
65402 : {
65403 0 : std::cout << "SgReadStatement :: ";
65404 0 : std::cout << " p_numeric_label is not in memory pool of ";
65405 0 : std::cout << p_numeric_label->class_name() << std::endl;
65406 : }
65407 : }
65408 : else
65409 : {
65410 0 : std::cout << "SgReadStatement :: " << std::flush;
65411 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
65412 0 : std::cout << " not valid " << std::endl;
65413 : }
65414 : }
65415 :
65416 0 : if ( p_startOfConstruct != NULL )
65417 : {
65418 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65419 : {
65420 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
65421 : {
65422 0 : std::cout << "SgReadStatement :: ";
65423 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
65424 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
65425 : }
65426 : }
65427 : else
65428 : {
65429 0 : std::cout << "SgReadStatement :: " << std::flush;
65430 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
65431 0 : std::cout << " not valid " << std::endl;
65432 : }
65433 : }
65434 :
65435 0 : if ( p_endOfConstruct != NULL )
65436 : {
65437 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65438 : {
65439 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
65440 : {
65441 0 : std::cout << "SgReadStatement :: ";
65442 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
65443 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
65444 : }
65445 : }
65446 : else
65447 : {
65448 0 : std::cout << "SgReadStatement :: " << std::flush;
65449 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
65450 0 : std::cout << " not valid " << std::endl;
65451 : }
65452 : }
65453 :
65454 0 : if ( p_parent != NULL )
65455 : {
65456 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65457 : {
65458 0 : if ( p_parent->isInMemoryPool() == false )
65459 : {
65460 0 : std::cout << "SgReadStatement :: ";
65461 0 : std::cout << " p_parent is not in memory pool of ";
65462 0 : std::cout << p_parent->class_name() << std::endl;
65463 : }
65464 : }
65465 : else
65466 : {
65467 0 : std::cout << "SgReadStatement :: " << std::flush;
65468 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
65469 0 : std::cout << " not valid " << std::endl;
65470 : }
65471 : }
65472 :
65473 :
65474 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
65475 :
65476 0 : }
65477 :
65478 :
65479 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
65480 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
65481 : bool
65482 0 : SgReadStatement::isInMemoryPool ()
65483 : {
65484 0 : typedef unsigned char* TestType;
65485 :
65486 0 : bool found = false;
65487 :
65488 0 : ROSE_ASSERT(this != NULL);
65489 :
65490 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
65491 :
65492 0 : TestType tested = (TestType) ( this ) ;
65493 :
65494 0 : std::vector < unsigned char* > :: const_iterator block = SgReadStatement::pools.begin();
65495 :
65496 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
65497 : // while (found == false && block < Memory_Block_List.end())
65498 0 : while ( (found == false) && (block != SgReadStatement::pools.end()) )
65499 : {
65500 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgReadStatement::pool_size * sizeof(SgReadStatement) ) ) ;
65501 0 : ++block;
65502 : }
65503 :
65504 : // Special handling for static data
65505 :
65506 :
65507 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
65508 0 : ROSE_ASSERT(found == true);
65509 :
65510 0 : return found;
65511 : }
65512 : /* #line 65513 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
65513 :
65514 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
65515 :
65516 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
65517 :
65518 : /* #line 65519 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
65519 :
65520 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
65521 :
65522 : void
65523 0 : SgWriteStatement::checkDataMemberPointersIfInMemoryPool()
65524 : {
65525 : // ------------ checking pointers of SgWriteStatement -------------------
65526 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
65527 :
65528 0 : if ( p_format != NULL )
65529 : {
65530 0 : if ( p_format->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65531 : {
65532 0 : if ( p_format->isInMemoryPool() == false )
65533 : {
65534 0 : std::cout << "SgWriteStatement :: ";
65535 0 : std::cout << " p_format is not in memory pool of ";
65536 0 : std::cout << p_format->class_name() << std::endl;
65537 : }
65538 : }
65539 : else
65540 : {
65541 0 : std::cout << "SgWriteStatement :: " << std::flush;
65542 0 : std::cout << "SgExpression* p_format = " << p_format << " --> " << std::flush;
65543 0 : std::cout << " not valid " << std::endl;
65544 : }
65545 : }
65546 :
65547 0 : if ( p_namelist != NULL )
65548 : {
65549 0 : if ( p_namelist->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65550 : {
65551 0 : if ( p_namelist->isInMemoryPool() == false )
65552 : {
65553 0 : std::cout << "SgWriteStatement :: ";
65554 0 : std::cout << " p_namelist is not in memory pool of ";
65555 0 : std::cout << p_namelist->class_name() << std::endl;
65556 : }
65557 : }
65558 : else
65559 : {
65560 0 : std::cout << "SgWriteStatement :: " << std::flush;
65561 0 : std::cout << "SgExpression* p_namelist = " << p_namelist << " --> " << std::flush;
65562 0 : std::cout << " not valid " << std::endl;
65563 : }
65564 : }
65565 :
65566 0 : if ( p_advance != NULL )
65567 : {
65568 0 : if ( p_advance->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65569 : {
65570 0 : if ( p_advance->isInMemoryPool() == false )
65571 : {
65572 0 : std::cout << "SgWriteStatement :: ";
65573 0 : std::cout << " p_advance is not in memory pool of ";
65574 0 : std::cout << p_advance->class_name() << std::endl;
65575 : }
65576 : }
65577 : else
65578 : {
65579 0 : std::cout << "SgWriteStatement :: " << std::flush;
65580 0 : std::cout << "SgExpression* p_advance = " << p_advance << " --> " << std::flush;
65581 0 : std::cout << " not valid " << std::endl;
65582 : }
65583 : }
65584 :
65585 0 : if ( p_asynchronous != NULL )
65586 : {
65587 0 : if ( p_asynchronous->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65588 : {
65589 0 : if ( p_asynchronous->isInMemoryPool() == false )
65590 : {
65591 0 : std::cout << "SgWriteStatement :: ";
65592 0 : std::cout << " p_asynchronous is not in memory pool of ";
65593 0 : std::cout << p_asynchronous->class_name() << std::endl;
65594 : }
65595 : }
65596 : else
65597 : {
65598 0 : std::cout << "SgWriteStatement :: " << std::flush;
65599 0 : std::cout << "SgExpression* p_asynchronous = " << p_asynchronous << " --> " << std::flush;
65600 0 : std::cout << " not valid " << std::endl;
65601 : }
65602 : }
65603 :
65604 0 : if ( p_blank != NULL )
65605 : {
65606 0 : if ( p_blank->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65607 : {
65608 0 : if ( p_blank->isInMemoryPool() == false )
65609 : {
65610 0 : std::cout << "SgWriteStatement :: ";
65611 0 : std::cout << " p_blank is not in memory pool of ";
65612 0 : std::cout << p_blank->class_name() << std::endl;
65613 : }
65614 : }
65615 : else
65616 : {
65617 0 : std::cout << "SgWriteStatement :: " << std::flush;
65618 0 : std::cout << "SgExpression* p_blank = " << p_blank << " --> " << std::flush;
65619 0 : std::cout << " not valid " << std::endl;
65620 : }
65621 : }
65622 :
65623 0 : if ( p_decimal != NULL )
65624 : {
65625 0 : if ( p_decimal->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65626 : {
65627 0 : if ( p_decimal->isInMemoryPool() == false )
65628 : {
65629 0 : std::cout << "SgWriteStatement :: ";
65630 0 : std::cout << " p_decimal is not in memory pool of ";
65631 0 : std::cout << p_decimal->class_name() << std::endl;
65632 : }
65633 : }
65634 : else
65635 : {
65636 0 : std::cout << "SgWriteStatement :: " << std::flush;
65637 0 : std::cout << "SgExpression* p_decimal = " << p_decimal << " --> " << std::flush;
65638 0 : std::cout << " not valid " << std::endl;
65639 : }
65640 : }
65641 :
65642 0 : if ( p_delim != NULL )
65643 : {
65644 0 : if ( p_delim->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65645 : {
65646 0 : if ( p_delim->isInMemoryPool() == false )
65647 : {
65648 0 : std::cout << "SgWriteStatement :: ";
65649 0 : std::cout << " p_delim is not in memory pool of ";
65650 0 : std::cout << p_delim->class_name() << std::endl;
65651 : }
65652 : }
65653 : else
65654 : {
65655 0 : std::cout << "SgWriteStatement :: " << std::flush;
65656 0 : std::cout << "SgExpression* p_delim = " << p_delim << " --> " << std::flush;
65657 0 : std::cout << " not valid " << std::endl;
65658 : }
65659 : }
65660 :
65661 0 : if ( p_end != NULL )
65662 : {
65663 0 : if ( p_end->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65664 : {
65665 0 : if ( p_end->isInMemoryPool() == false )
65666 : {
65667 0 : std::cout << "SgWriteStatement :: ";
65668 0 : std::cout << " p_end is not in memory pool of ";
65669 0 : std::cout << p_end->class_name() << std::endl;
65670 : }
65671 : }
65672 : else
65673 : {
65674 0 : std::cout << "SgWriteStatement :: " << std::flush;
65675 0 : std::cout << "SgExpression* p_end = " << p_end << " --> " << std::flush;
65676 0 : std::cout << " not valid " << std::endl;
65677 : }
65678 : }
65679 :
65680 0 : if ( p_eor != NULL )
65681 : {
65682 0 : if ( p_eor->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65683 : {
65684 0 : if ( p_eor->isInMemoryPool() == false )
65685 : {
65686 0 : std::cout << "SgWriteStatement :: ";
65687 0 : std::cout << " p_eor is not in memory pool of ";
65688 0 : std::cout << p_eor->class_name() << std::endl;
65689 : }
65690 : }
65691 : else
65692 : {
65693 0 : std::cout << "SgWriteStatement :: " << std::flush;
65694 0 : std::cout << "SgExpression* p_eor = " << p_eor << " --> " << std::flush;
65695 0 : std::cout << " not valid " << std::endl;
65696 : }
65697 : }
65698 :
65699 0 : if ( p_id != NULL )
65700 : {
65701 0 : if ( p_id->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65702 : {
65703 0 : if ( p_id->isInMemoryPool() == false )
65704 : {
65705 0 : std::cout << "SgWriteStatement :: ";
65706 0 : std::cout << " p_id is not in memory pool of ";
65707 0 : std::cout << p_id->class_name() << std::endl;
65708 : }
65709 : }
65710 : else
65711 : {
65712 0 : std::cout << "SgWriteStatement :: " << std::flush;
65713 0 : std::cout << "SgExpression* p_id = " << p_id << " --> " << std::flush;
65714 0 : std::cout << " not valid " << std::endl;
65715 : }
65716 : }
65717 :
65718 0 : if ( p_pad != NULL )
65719 : {
65720 0 : if ( p_pad->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65721 : {
65722 0 : if ( p_pad->isInMemoryPool() == false )
65723 : {
65724 0 : std::cout << "SgWriteStatement :: ";
65725 0 : std::cout << " p_pad is not in memory pool of ";
65726 0 : std::cout << p_pad->class_name() << std::endl;
65727 : }
65728 : }
65729 : else
65730 : {
65731 0 : std::cout << "SgWriteStatement :: " << std::flush;
65732 0 : std::cout << "SgExpression* p_pad = " << p_pad << " --> " << std::flush;
65733 0 : std::cout << " not valid " << std::endl;
65734 : }
65735 : }
65736 :
65737 0 : if ( p_pos != NULL )
65738 : {
65739 0 : if ( p_pos->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65740 : {
65741 0 : if ( p_pos->isInMemoryPool() == false )
65742 : {
65743 0 : std::cout << "SgWriteStatement :: ";
65744 0 : std::cout << " p_pos is not in memory pool of ";
65745 0 : std::cout << p_pos->class_name() << std::endl;
65746 : }
65747 : }
65748 : else
65749 : {
65750 0 : std::cout << "SgWriteStatement :: " << std::flush;
65751 0 : std::cout << "SgExpression* p_pos = " << p_pos << " --> " << std::flush;
65752 0 : std::cout << " not valid " << std::endl;
65753 : }
65754 : }
65755 :
65756 0 : if ( p_rec != NULL )
65757 : {
65758 0 : if ( p_rec->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65759 : {
65760 0 : if ( p_rec->isInMemoryPool() == false )
65761 : {
65762 0 : std::cout << "SgWriteStatement :: ";
65763 0 : std::cout << " p_rec is not in memory pool of ";
65764 0 : std::cout << p_rec->class_name() << std::endl;
65765 : }
65766 : }
65767 : else
65768 : {
65769 0 : std::cout << "SgWriteStatement :: " << std::flush;
65770 0 : std::cout << "SgExpression* p_rec = " << p_rec << " --> " << std::flush;
65771 0 : std::cout << " not valid " << std::endl;
65772 : }
65773 : }
65774 :
65775 0 : if ( p_round != NULL )
65776 : {
65777 0 : if ( p_round->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65778 : {
65779 0 : if ( p_round->isInMemoryPool() == false )
65780 : {
65781 0 : std::cout << "SgWriteStatement :: ";
65782 0 : std::cout << " p_round is not in memory pool of ";
65783 0 : std::cout << p_round->class_name() << std::endl;
65784 : }
65785 : }
65786 : else
65787 : {
65788 0 : std::cout << "SgWriteStatement :: " << std::flush;
65789 0 : std::cout << "SgExpression* p_round = " << p_round << " --> " << std::flush;
65790 0 : std::cout << " not valid " << std::endl;
65791 : }
65792 : }
65793 :
65794 0 : if ( p_sign != NULL )
65795 : {
65796 0 : if ( p_sign->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65797 : {
65798 0 : if ( p_sign->isInMemoryPool() == false )
65799 : {
65800 0 : std::cout << "SgWriteStatement :: ";
65801 0 : std::cout << " p_sign is not in memory pool of ";
65802 0 : std::cout << p_sign->class_name() << std::endl;
65803 : }
65804 : }
65805 : else
65806 : {
65807 0 : std::cout << "SgWriteStatement :: " << std::flush;
65808 0 : std::cout << "SgExpression* p_sign = " << p_sign << " --> " << std::flush;
65809 0 : std::cout << " not valid " << std::endl;
65810 : }
65811 : }
65812 :
65813 0 : if ( p_size != NULL )
65814 : {
65815 0 : if ( p_size->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65816 : {
65817 0 : if ( p_size->isInMemoryPool() == false )
65818 : {
65819 0 : std::cout << "SgWriteStatement :: ";
65820 0 : std::cout << " p_size is not in memory pool of ";
65821 0 : std::cout << p_size->class_name() << std::endl;
65822 : }
65823 : }
65824 : else
65825 : {
65826 0 : std::cout << "SgWriteStatement :: " << std::flush;
65827 0 : std::cout << "SgExpression* p_size = " << p_size << " --> " << std::flush;
65828 0 : std::cout << " not valid " << std::endl;
65829 : }
65830 : }
65831 :
65832 0 : if ( p_io_stmt_list != NULL )
65833 : {
65834 0 : if ( p_io_stmt_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65835 : {
65836 0 : if ( p_io_stmt_list->isInMemoryPool() == false )
65837 : {
65838 0 : std::cout << "SgWriteStatement :: ";
65839 0 : std::cout << " p_io_stmt_list is not in memory pool of ";
65840 0 : std::cout << p_io_stmt_list->class_name() << std::endl;
65841 : }
65842 : }
65843 : else
65844 : {
65845 0 : std::cout << "SgWriteStatement :: " << std::flush;
65846 0 : std::cout << "SgExprListExp* p_io_stmt_list = " << p_io_stmt_list << " --> " << std::flush;
65847 0 : std::cout << " not valid " << std::endl;
65848 : }
65849 : }
65850 :
65851 0 : if ( p_unit != NULL )
65852 : {
65853 0 : if ( p_unit->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65854 : {
65855 0 : if ( p_unit->isInMemoryPool() == false )
65856 : {
65857 0 : std::cout << "SgWriteStatement :: ";
65858 0 : std::cout << " p_unit is not in memory pool of ";
65859 0 : std::cout << p_unit->class_name() << std::endl;
65860 : }
65861 : }
65862 : else
65863 : {
65864 0 : std::cout << "SgWriteStatement :: " << std::flush;
65865 0 : std::cout << "SgExpression* p_unit = " << p_unit << " --> " << std::flush;
65866 0 : std::cout << " not valid " << std::endl;
65867 : }
65868 : }
65869 :
65870 0 : if ( p_iostat != NULL )
65871 : {
65872 0 : if ( p_iostat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65873 : {
65874 0 : if ( p_iostat->isInMemoryPool() == false )
65875 : {
65876 0 : std::cout << "SgWriteStatement :: ";
65877 0 : std::cout << " p_iostat is not in memory pool of ";
65878 0 : std::cout << p_iostat->class_name() << std::endl;
65879 : }
65880 : }
65881 : else
65882 : {
65883 0 : std::cout << "SgWriteStatement :: " << std::flush;
65884 0 : std::cout << "SgExpression* p_iostat = " << p_iostat << " --> " << std::flush;
65885 0 : std::cout << " not valid " << std::endl;
65886 : }
65887 : }
65888 :
65889 0 : if ( p_err != NULL )
65890 : {
65891 0 : if ( p_err->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65892 : {
65893 0 : if ( p_err->isInMemoryPool() == false )
65894 : {
65895 0 : std::cout << "SgWriteStatement :: ";
65896 0 : std::cout << " p_err is not in memory pool of ";
65897 0 : std::cout << p_err->class_name() << std::endl;
65898 : }
65899 : }
65900 : else
65901 : {
65902 0 : std::cout << "SgWriteStatement :: " << std::flush;
65903 0 : std::cout << "SgExpression* p_err = " << p_err << " --> " << std::flush;
65904 0 : std::cout << " not valid " << std::endl;
65905 : }
65906 : }
65907 :
65908 0 : if ( p_iomsg != NULL )
65909 : {
65910 0 : if ( p_iomsg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65911 : {
65912 0 : if ( p_iomsg->isInMemoryPool() == false )
65913 : {
65914 0 : std::cout << "SgWriteStatement :: ";
65915 0 : std::cout << " p_iomsg is not in memory pool of ";
65916 0 : std::cout << p_iomsg->class_name() << std::endl;
65917 : }
65918 : }
65919 : else
65920 : {
65921 0 : std::cout << "SgWriteStatement :: " << std::flush;
65922 0 : std::cout << "SgExpression* p_iomsg = " << p_iomsg << " --> " << std::flush;
65923 0 : std::cout << " not valid " << std::endl;
65924 : }
65925 : }
65926 :
65927 0 : if ( p_numeric_label != NULL )
65928 : {
65929 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65930 : {
65931 0 : if ( p_numeric_label->isInMemoryPool() == false )
65932 : {
65933 0 : std::cout << "SgWriteStatement :: ";
65934 0 : std::cout << " p_numeric_label is not in memory pool of ";
65935 0 : std::cout << p_numeric_label->class_name() << std::endl;
65936 : }
65937 : }
65938 : else
65939 : {
65940 0 : std::cout << "SgWriteStatement :: " << std::flush;
65941 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
65942 0 : std::cout << " not valid " << std::endl;
65943 : }
65944 : }
65945 :
65946 0 : if ( p_startOfConstruct != NULL )
65947 : {
65948 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65949 : {
65950 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
65951 : {
65952 0 : std::cout << "SgWriteStatement :: ";
65953 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
65954 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
65955 : }
65956 : }
65957 : else
65958 : {
65959 0 : std::cout << "SgWriteStatement :: " << std::flush;
65960 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
65961 0 : std::cout << " not valid " << std::endl;
65962 : }
65963 : }
65964 :
65965 0 : if ( p_endOfConstruct != NULL )
65966 : {
65967 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65968 : {
65969 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
65970 : {
65971 0 : std::cout << "SgWriteStatement :: ";
65972 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
65973 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
65974 : }
65975 : }
65976 : else
65977 : {
65978 0 : std::cout << "SgWriteStatement :: " << std::flush;
65979 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
65980 0 : std::cout << " not valid " << std::endl;
65981 : }
65982 : }
65983 :
65984 0 : if ( p_parent != NULL )
65985 : {
65986 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
65987 : {
65988 0 : if ( p_parent->isInMemoryPool() == false )
65989 : {
65990 0 : std::cout << "SgWriteStatement :: ";
65991 0 : std::cout << " p_parent is not in memory pool of ";
65992 0 : std::cout << p_parent->class_name() << std::endl;
65993 : }
65994 : }
65995 : else
65996 : {
65997 0 : std::cout << "SgWriteStatement :: " << std::flush;
65998 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
65999 0 : std::cout << " not valid " << std::endl;
66000 : }
66001 : }
66002 :
66003 :
66004 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
66005 :
66006 0 : }
66007 :
66008 :
66009 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
66010 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
66011 : bool
66012 0 : SgWriteStatement::isInMemoryPool ()
66013 : {
66014 0 : typedef unsigned char* TestType;
66015 :
66016 0 : bool found = false;
66017 :
66018 0 : ROSE_ASSERT(this != NULL);
66019 :
66020 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
66021 :
66022 0 : TestType tested = (TestType) ( this ) ;
66023 :
66024 0 : std::vector < unsigned char* > :: const_iterator block = SgWriteStatement::pools.begin();
66025 :
66026 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
66027 : // while (found == false && block < Memory_Block_List.end())
66028 0 : while ( (found == false) && (block != SgWriteStatement::pools.end()) )
66029 : {
66030 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgWriteStatement::pool_size * sizeof(SgWriteStatement) ) ) ;
66031 0 : ++block;
66032 : }
66033 :
66034 : // Special handling for static data
66035 :
66036 :
66037 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
66038 0 : ROSE_ASSERT(found == true);
66039 :
66040 0 : return found;
66041 : }
66042 : /* #line 66043 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
66043 :
66044 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
66045 :
66046 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
66047 :
66048 : /* #line 66049 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
66049 :
66050 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
66051 :
66052 : void
66053 0 : SgOpenStatement::checkDataMemberPointersIfInMemoryPool()
66054 : {
66055 : // ------------ checking pointers of SgOpenStatement -------------------
66056 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
66057 :
66058 0 : if ( p_file != NULL )
66059 : {
66060 0 : if ( p_file->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66061 : {
66062 0 : if ( p_file->isInMemoryPool() == false )
66063 : {
66064 0 : std::cout << "SgOpenStatement :: ";
66065 0 : std::cout << " p_file is not in memory pool of ";
66066 0 : std::cout << p_file->class_name() << std::endl;
66067 : }
66068 : }
66069 : else
66070 : {
66071 0 : std::cout << "SgOpenStatement :: " << std::flush;
66072 0 : std::cout << "SgExpression* p_file = " << p_file << " --> " << std::flush;
66073 0 : std::cout << " not valid " << std::endl;
66074 : }
66075 : }
66076 :
66077 0 : if ( p_status != NULL )
66078 : {
66079 0 : if ( p_status->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66080 : {
66081 0 : if ( p_status->isInMemoryPool() == false )
66082 : {
66083 0 : std::cout << "SgOpenStatement :: ";
66084 0 : std::cout << " p_status is not in memory pool of ";
66085 0 : std::cout << p_status->class_name() << std::endl;
66086 : }
66087 : }
66088 : else
66089 : {
66090 0 : std::cout << "SgOpenStatement :: " << std::flush;
66091 0 : std::cout << "SgExpression* p_status = " << p_status << " --> " << std::flush;
66092 0 : std::cout << " not valid " << std::endl;
66093 : }
66094 : }
66095 :
66096 0 : if ( p_access != NULL )
66097 : {
66098 0 : if ( p_access->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66099 : {
66100 0 : if ( p_access->isInMemoryPool() == false )
66101 : {
66102 0 : std::cout << "SgOpenStatement :: ";
66103 0 : std::cout << " p_access is not in memory pool of ";
66104 0 : std::cout << p_access->class_name() << std::endl;
66105 : }
66106 : }
66107 : else
66108 : {
66109 0 : std::cout << "SgOpenStatement :: " << std::flush;
66110 0 : std::cout << "SgExpression* p_access = " << p_access << " --> " << std::flush;
66111 0 : std::cout << " not valid " << std::endl;
66112 : }
66113 : }
66114 :
66115 0 : if ( p_form != NULL )
66116 : {
66117 0 : if ( p_form->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66118 : {
66119 0 : if ( p_form->isInMemoryPool() == false )
66120 : {
66121 0 : std::cout << "SgOpenStatement :: ";
66122 0 : std::cout << " p_form is not in memory pool of ";
66123 0 : std::cout << p_form->class_name() << std::endl;
66124 : }
66125 : }
66126 : else
66127 : {
66128 0 : std::cout << "SgOpenStatement :: " << std::flush;
66129 0 : std::cout << "SgExpression* p_form = " << p_form << " --> " << std::flush;
66130 0 : std::cout << " not valid " << std::endl;
66131 : }
66132 : }
66133 :
66134 0 : if ( p_recl != NULL )
66135 : {
66136 0 : if ( p_recl->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66137 : {
66138 0 : if ( p_recl->isInMemoryPool() == false )
66139 : {
66140 0 : std::cout << "SgOpenStatement :: ";
66141 0 : std::cout << " p_recl is not in memory pool of ";
66142 0 : std::cout << p_recl->class_name() << std::endl;
66143 : }
66144 : }
66145 : else
66146 : {
66147 0 : std::cout << "SgOpenStatement :: " << std::flush;
66148 0 : std::cout << "SgExpression* p_recl = " << p_recl << " --> " << std::flush;
66149 0 : std::cout << " not valid " << std::endl;
66150 : }
66151 : }
66152 :
66153 0 : if ( p_blank != NULL )
66154 : {
66155 0 : if ( p_blank->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66156 : {
66157 0 : if ( p_blank->isInMemoryPool() == false )
66158 : {
66159 0 : std::cout << "SgOpenStatement :: ";
66160 0 : std::cout << " p_blank is not in memory pool of ";
66161 0 : std::cout << p_blank->class_name() << std::endl;
66162 : }
66163 : }
66164 : else
66165 : {
66166 0 : std::cout << "SgOpenStatement :: " << std::flush;
66167 0 : std::cout << "SgExpression* p_blank = " << p_blank << " --> " << std::flush;
66168 0 : std::cout << " not valid " << std::endl;
66169 : }
66170 : }
66171 :
66172 0 : if ( p_position != NULL )
66173 : {
66174 0 : if ( p_position->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66175 : {
66176 0 : if ( p_position->isInMemoryPool() == false )
66177 : {
66178 0 : std::cout << "SgOpenStatement :: ";
66179 0 : std::cout << " p_position is not in memory pool of ";
66180 0 : std::cout << p_position->class_name() << std::endl;
66181 : }
66182 : }
66183 : else
66184 : {
66185 0 : std::cout << "SgOpenStatement :: " << std::flush;
66186 0 : std::cout << "SgExpression* p_position = " << p_position << " --> " << std::flush;
66187 0 : std::cout << " not valid " << std::endl;
66188 : }
66189 : }
66190 :
66191 0 : if ( p_action != NULL )
66192 : {
66193 0 : if ( p_action->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66194 : {
66195 0 : if ( p_action->isInMemoryPool() == false )
66196 : {
66197 0 : std::cout << "SgOpenStatement :: ";
66198 0 : std::cout << " p_action is not in memory pool of ";
66199 0 : std::cout << p_action->class_name() << std::endl;
66200 : }
66201 : }
66202 : else
66203 : {
66204 0 : std::cout << "SgOpenStatement :: " << std::flush;
66205 0 : std::cout << "SgExpression* p_action = " << p_action << " --> " << std::flush;
66206 0 : std::cout << " not valid " << std::endl;
66207 : }
66208 : }
66209 :
66210 0 : if ( p_delim != NULL )
66211 : {
66212 0 : if ( p_delim->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66213 : {
66214 0 : if ( p_delim->isInMemoryPool() == false )
66215 : {
66216 0 : std::cout << "SgOpenStatement :: ";
66217 0 : std::cout << " p_delim is not in memory pool of ";
66218 0 : std::cout << p_delim->class_name() << std::endl;
66219 : }
66220 : }
66221 : else
66222 : {
66223 0 : std::cout << "SgOpenStatement :: " << std::flush;
66224 0 : std::cout << "SgExpression* p_delim = " << p_delim << " --> " << std::flush;
66225 0 : std::cout << " not valid " << std::endl;
66226 : }
66227 : }
66228 :
66229 0 : if ( p_pad != NULL )
66230 : {
66231 0 : if ( p_pad->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66232 : {
66233 0 : if ( p_pad->isInMemoryPool() == false )
66234 : {
66235 0 : std::cout << "SgOpenStatement :: ";
66236 0 : std::cout << " p_pad is not in memory pool of ";
66237 0 : std::cout << p_pad->class_name() << std::endl;
66238 : }
66239 : }
66240 : else
66241 : {
66242 0 : std::cout << "SgOpenStatement :: " << std::flush;
66243 0 : std::cout << "SgExpression* p_pad = " << p_pad << " --> " << std::flush;
66244 0 : std::cout << " not valid " << std::endl;
66245 : }
66246 : }
66247 :
66248 0 : if ( p_round != NULL )
66249 : {
66250 0 : if ( p_round->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66251 : {
66252 0 : if ( p_round->isInMemoryPool() == false )
66253 : {
66254 0 : std::cout << "SgOpenStatement :: ";
66255 0 : std::cout << " p_round is not in memory pool of ";
66256 0 : std::cout << p_round->class_name() << std::endl;
66257 : }
66258 : }
66259 : else
66260 : {
66261 0 : std::cout << "SgOpenStatement :: " << std::flush;
66262 0 : std::cout << "SgExpression* p_round = " << p_round << " --> " << std::flush;
66263 0 : std::cout << " not valid " << std::endl;
66264 : }
66265 : }
66266 :
66267 0 : if ( p_sign != NULL )
66268 : {
66269 0 : if ( p_sign->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66270 : {
66271 0 : if ( p_sign->isInMemoryPool() == false )
66272 : {
66273 0 : std::cout << "SgOpenStatement :: ";
66274 0 : std::cout << " p_sign is not in memory pool of ";
66275 0 : std::cout << p_sign->class_name() << std::endl;
66276 : }
66277 : }
66278 : else
66279 : {
66280 0 : std::cout << "SgOpenStatement :: " << std::flush;
66281 0 : std::cout << "SgExpression* p_sign = " << p_sign << " --> " << std::flush;
66282 0 : std::cout << " not valid " << std::endl;
66283 : }
66284 : }
66285 :
66286 0 : if ( p_asynchronous != NULL )
66287 : {
66288 0 : if ( p_asynchronous->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66289 : {
66290 0 : if ( p_asynchronous->isInMemoryPool() == false )
66291 : {
66292 0 : std::cout << "SgOpenStatement :: ";
66293 0 : std::cout << " p_asynchronous is not in memory pool of ";
66294 0 : std::cout << p_asynchronous->class_name() << std::endl;
66295 : }
66296 : }
66297 : else
66298 : {
66299 0 : std::cout << "SgOpenStatement :: " << std::flush;
66300 0 : std::cout << "SgExpression* p_asynchronous = " << p_asynchronous << " --> " << std::flush;
66301 0 : std::cout << " not valid " << std::endl;
66302 : }
66303 : }
66304 :
66305 0 : if ( p_io_stmt_list != NULL )
66306 : {
66307 0 : if ( p_io_stmt_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66308 : {
66309 0 : if ( p_io_stmt_list->isInMemoryPool() == false )
66310 : {
66311 0 : std::cout << "SgOpenStatement :: ";
66312 0 : std::cout << " p_io_stmt_list is not in memory pool of ";
66313 0 : std::cout << p_io_stmt_list->class_name() << std::endl;
66314 : }
66315 : }
66316 : else
66317 : {
66318 0 : std::cout << "SgOpenStatement :: " << std::flush;
66319 0 : std::cout << "SgExprListExp* p_io_stmt_list = " << p_io_stmt_list << " --> " << std::flush;
66320 0 : std::cout << " not valid " << std::endl;
66321 : }
66322 : }
66323 :
66324 0 : if ( p_unit != NULL )
66325 : {
66326 0 : if ( p_unit->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66327 : {
66328 0 : if ( p_unit->isInMemoryPool() == false )
66329 : {
66330 0 : std::cout << "SgOpenStatement :: ";
66331 0 : std::cout << " p_unit is not in memory pool of ";
66332 0 : std::cout << p_unit->class_name() << std::endl;
66333 : }
66334 : }
66335 : else
66336 : {
66337 0 : std::cout << "SgOpenStatement :: " << std::flush;
66338 0 : std::cout << "SgExpression* p_unit = " << p_unit << " --> " << std::flush;
66339 0 : std::cout << " not valid " << std::endl;
66340 : }
66341 : }
66342 :
66343 0 : if ( p_iostat != NULL )
66344 : {
66345 0 : if ( p_iostat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66346 : {
66347 0 : if ( p_iostat->isInMemoryPool() == false )
66348 : {
66349 0 : std::cout << "SgOpenStatement :: ";
66350 0 : std::cout << " p_iostat is not in memory pool of ";
66351 0 : std::cout << p_iostat->class_name() << std::endl;
66352 : }
66353 : }
66354 : else
66355 : {
66356 0 : std::cout << "SgOpenStatement :: " << std::flush;
66357 0 : std::cout << "SgExpression* p_iostat = " << p_iostat << " --> " << std::flush;
66358 0 : std::cout << " not valid " << std::endl;
66359 : }
66360 : }
66361 :
66362 0 : if ( p_err != NULL )
66363 : {
66364 0 : if ( p_err->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66365 : {
66366 0 : if ( p_err->isInMemoryPool() == false )
66367 : {
66368 0 : std::cout << "SgOpenStatement :: ";
66369 0 : std::cout << " p_err is not in memory pool of ";
66370 0 : std::cout << p_err->class_name() << std::endl;
66371 : }
66372 : }
66373 : else
66374 : {
66375 0 : std::cout << "SgOpenStatement :: " << std::flush;
66376 0 : std::cout << "SgExpression* p_err = " << p_err << " --> " << std::flush;
66377 0 : std::cout << " not valid " << std::endl;
66378 : }
66379 : }
66380 :
66381 0 : if ( p_iomsg != NULL )
66382 : {
66383 0 : if ( p_iomsg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66384 : {
66385 0 : if ( p_iomsg->isInMemoryPool() == false )
66386 : {
66387 0 : std::cout << "SgOpenStatement :: ";
66388 0 : std::cout << " p_iomsg is not in memory pool of ";
66389 0 : std::cout << p_iomsg->class_name() << std::endl;
66390 : }
66391 : }
66392 : else
66393 : {
66394 0 : std::cout << "SgOpenStatement :: " << std::flush;
66395 0 : std::cout << "SgExpression* p_iomsg = " << p_iomsg << " --> " << std::flush;
66396 0 : std::cout << " not valid " << std::endl;
66397 : }
66398 : }
66399 :
66400 0 : if ( p_numeric_label != NULL )
66401 : {
66402 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66403 : {
66404 0 : if ( p_numeric_label->isInMemoryPool() == false )
66405 : {
66406 0 : std::cout << "SgOpenStatement :: ";
66407 0 : std::cout << " p_numeric_label is not in memory pool of ";
66408 0 : std::cout << p_numeric_label->class_name() << std::endl;
66409 : }
66410 : }
66411 : else
66412 : {
66413 0 : std::cout << "SgOpenStatement :: " << std::flush;
66414 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
66415 0 : std::cout << " not valid " << std::endl;
66416 : }
66417 : }
66418 :
66419 0 : if ( p_startOfConstruct != NULL )
66420 : {
66421 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66422 : {
66423 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
66424 : {
66425 0 : std::cout << "SgOpenStatement :: ";
66426 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
66427 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
66428 : }
66429 : }
66430 : else
66431 : {
66432 0 : std::cout << "SgOpenStatement :: " << std::flush;
66433 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
66434 0 : std::cout << " not valid " << std::endl;
66435 : }
66436 : }
66437 :
66438 0 : if ( p_endOfConstruct != NULL )
66439 : {
66440 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66441 : {
66442 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
66443 : {
66444 0 : std::cout << "SgOpenStatement :: ";
66445 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
66446 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
66447 : }
66448 : }
66449 : else
66450 : {
66451 0 : std::cout << "SgOpenStatement :: " << std::flush;
66452 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
66453 0 : std::cout << " not valid " << std::endl;
66454 : }
66455 : }
66456 :
66457 0 : if ( p_parent != NULL )
66458 : {
66459 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66460 : {
66461 0 : if ( p_parent->isInMemoryPool() == false )
66462 : {
66463 0 : std::cout << "SgOpenStatement :: ";
66464 0 : std::cout << " p_parent is not in memory pool of ";
66465 0 : std::cout << p_parent->class_name() << std::endl;
66466 : }
66467 : }
66468 : else
66469 : {
66470 0 : std::cout << "SgOpenStatement :: " << std::flush;
66471 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
66472 0 : std::cout << " not valid " << std::endl;
66473 : }
66474 : }
66475 :
66476 :
66477 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
66478 :
66479 0 : }
66480 :
66481 :
66482 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
66483 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
66484 : bool
66485 0 : SgOpenStatement::isInMemoryPool ()
66486 : {
66487 0 : typedef unsigned char* TestType;
66488 :
66489 0 : bool found = false;
66490 :
66491 0 : ROSE_ASSERT(this != NULL);
66492 :
66493 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
66494 :
66495 0 : TestType tested = (TestType) ( this ) ;
66496 :
66497 0 : std::vector < unsigned char* > :: const_iterator block = SgOpenStatement::pools.begin();
66498 :
66499 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
66500 : // while (found == false && block < Memory_Block_List.end())
66501 0 : while ( (found == false) && (block != SgOpenStatement::pools.end()) )
66502 : {
66503 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOpenStatement::pool_size * sizeof(SgOpenStatement) ) ) ;
66504 0 : ++block;
66505 : }
66506 :
66507 : // Special handling for static data
66508 :
66509 :
66510 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
66511 0 : ROSE_ASSERT(found == true);
66512 :
66513 0 : return found;
66514 : }
66515 : /* #line 66516 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
66516 :
66517 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
66518 :
66519 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
66520 :
66521 : /* #line 66522 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
66522 :
66523 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
66524 :
66525 : void
66526 0 : SgCloseStatement::checkDataMemberPointersIfInMemoryPool()
66527 : {
66528 : // ------------ checking pointers of SgCloseStatement -------------------
66529 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
66530 :
66531 0 : if ( p_status != NULL )
66532 : {
66533 0 : if ( p_status->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66534 : {
66535 0 : if ( p_status->isInMemoryPool() == false )
66536 : {
66537 0 : std::cout << "SgCloseStatement :: ";
66538 0 : std::cout << " p_status is not in memory pool of ";
66539 0 : std::cout << p_status->class_name() << std::endl;
66540 : }
66541 : }
66542 : else
66543 : {
66544 0 : std::cout << "SgCloseStatement :: " << std::flush;
66545 0 : std::cout << "SgExpression* p_status = " << p_status << " --> " << std::flush;
66546 0 : std::cout << " not valid " << std::endl;
66547 : }
66548 : }
66549 :
66550 0 : if ( p_io_stmt_list != NULL )
66551 : {
66552 0 : if ( p_io_stmt_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66553 : {
66554 0 : if ( p_io_stmt_list->isInMemoryPool() == false )
66555 : {
66556 0 : std::cout << "SgCloseStatement :: ";
66557 0 : std::cout << " p_io_stmt_list is not in memory pool of ";
66558 0 : std::cout << p_io_stmt_list->class_name() << std::endl;
66559 : }
66560 : }
66561 : else
66562 : {
66563 0 : std::cout << "SgCloseStatement :: " << std::flush;
66564 0 : std::cout << "SgExprListExp* p_io_stmt_list = " << p_io_stmt_list << " --> " << std::flush;
66565 0 : std::cout << " not valid " << std::endl;
66566 : }
66567 : }
66568 :
66569 0 : if ( p_unit != NULL )
66570 : {
66571 0 : if ( p_unit->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66572 : {
66573 0 : if ( p_unit->isInMemoryPool() == false )
66574 : {
66575 0 : std::cout << "SgCloseStatement :: ";
66576 0 : std::cout << " p_unit is not in memory pool of ";
66577 0 : std::cout << p_unit->class_name() << std::endl;
66578 : }
66579 : }
66580 : else
66581 : {
66582 0 : std::cout << "SgCloseStatement :: " << std::flush;
66583 0 : std::cout << "SgExpression* p_unit = " << p_unit << " --> " << std::flush;
66584 0 : std::cout << " not valid " << std::endl;
66585 : }
66586 : }
66587 :
66588 0 : if ( p_iostat != NULL )
66589 : {
66590 0 : if ( p_iostat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66591 : {
66592 0 : if ( p_iostat->isInMemoryPool() == false )
66593 : {
66594 0 : std::cout << "SgCloseStatement :: ";
66595 0 : std::cout << " p_iostat is not in memory pool of ";
66596 0 : std::cout << p_iostat->class_name() << std::endl;
66597 : }
66598 : }
66599 : else
66600 : {
66601 0 : std::cout << "SgCloseStatement :: " << std::flush;
66602 0 : std::cout << "SgExpression* p_iostat = " << p_iostat << " --> " << std::flush;
66603 0 : std::cout << " not valid " << std::endl;
66604 : }
66605 : }
66606 :
66607 0 : if ( p_err != NULL )
66608 : {
66609 0 : if ( p_err->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66610 : {
66611 0 : if ( p_err->isInMemoryPool() == false )
66612 : {
66613 0 : std::cout << "SgCloseStatement :: ";
66614 0 : std::cout << " p_err is not in memory pool of ";
66615 0 : std::cout << p_err->class_name() << std::endl;
66616 : }
66617 : }
66618 : else
66619 : {
66620 0 : std::cout << "SgCloseStatement :: " << std::flush;
66621 0 : std::cout << "SgExpression* p_err = " << p_err << " --> " << std::flush;
66622 0 : std::cout << " not valid " << std::endl;
66623 : }
66624 : }
66625 :
66626 0 : if ( p_iomsg != NULL )
66627 : {
66628 0 : if ( p_iomsg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66629 : {
66630 0 : if ( p_iomsg->isInMemoryPool() == false )
66631 : {
66632 0 : std::cout << "SgCloseStatement :: ";
66633 0 : std::cout << " p_iomsg is not in memory pool of ";
66634 0 : std::cout << p_iomsg->class_name() << std::endl;
66635 : }
66636 : }
66637 : else
66638 : {
66639 0 : std::cout << "SgCloseStatement :: " << std::flush;
66640 0 : std::cout << "SgExpression* p_iomsg = " << p_iomsg << " --> " << std::flush;
66641 0 : std::cout << " not valid " << std::endl;
66642 : }
66643 : }
66644 :
66645 0 : if ( p_numeric_label != NULL )
66646 : {
66647 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66648 : {
66649 0 : if ( p_numeric_label->isInMemoryPool() == false )
66650 : {
66651 0 : std::cout << "SgCloseStatement :: ";
66652 0 : std::cout << " p_numeric_label is not in memory pool of ";
66653 0 : std::cout << p_numeric_label->class_name() << std::endl;
66654 : }
66655 : }
66656 : else
66657 : {
66658 0 : std::cout << "SgCloseStatement :: " << std::flush;
66659 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
66660 0 : std::cout << " not valid " << std::endl;
66661 : }
66662 : }
66663 :
66664 0 : if ( p_startOfConstruct != NULL )
66665 : {
66666 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66667 : {
66668 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
66669 : {
66670 0 : std::cout << "SgCloseStatement :: ";
66671 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
66672 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
66673 : }
66674 : }
66675 : else
66676 : {
66677 0 : std::cout << "SgCloseStatement :: " << std::flush;
66678 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
66679 0 : std::cout << " not valid " << std::endl;
66680 : }
66681 : }
66682 :
66683 0 : if ( p_endOfConstruct != NULL )
66684 : {
66685 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66686 : {
66687 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
66688 : {
66689 0 : std::cout << "SgCloseStatement :: ";
66690 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
66691 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
66692 : }
66693 : }
66694 : else
66695 : {
66696 0 : std::cout << "SgCloseStatement :: " << std::flush;
66697 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
66698 0 : std::cout << " not valid " << std::endl;
66699 : }
66700 : }
66701 :
66702 0 : if ( p_parent != NULL )
66703 : {
66704 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66705 : {
66706 0 : if ( p_parent->isInMemoryPool() == false )
66707 : {
66708 0 : std::cout << "SgCloseStatement :: ";
66709 0 : std::cout << " p_parent is not in memory pool of ";
66710 0 : std::cout << p_parent->class_name() << std::endl;
66711 : }
66712 : }
66713 : else
66714 : {
66715 0 : std::cout << "SgCloseStatement :: " << std::flush;
66716 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
66717 0 : std::cout << " not valid " << std::endl;
66718 : }
66719 : }
66720 :
66721 :
66722 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
66723 :
66724 0 : }
66725 :
66726 :
66727 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
66728 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
66729 : bool
66730 0 : SgCloseStatement::isInMemoryPool ()
66731 : {
66732 0 : typedef unsigned char* TestType;
66733 :
66734 0 : bool found = false;
66735 :
66736 0 : ROSE_ASSERT(this != NULL);
66737 :
66738 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
66739 :
66740 0 : TestType tested = (TestType) ( this ) ;
66741 :
66742 0 : std::vector < unsigned char* > :: const_iterator block = SgCloseStatement::pools.begin();
66743 :
66744 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
66745 : // while (found == false && block < Memory_Block_List.end())
66746 0 : while ( (found == false) && (block != SgCloseStatement::pools.end()) )
66747 : {
66748 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCloseStatement::pool_size * sizeof(SgCloseStatement) ) ) ;
66749 0 : ++block;
66750 : }
66751 :
66752 : // Special handling for static data
66753 :
66754 :
66755 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
66756 0 : ROSE_ASSERT(found == true);
66757 :
66758 0 : return found;
66759 : }
66760 : /* #line 66761 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
66761 :
66762 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
66763 :
66764 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
66765 :
66766 : /* #line 66767 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
66767 :
66768 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
66769 :
66770 : void
66771 0 : SgInquireStatement::checkDataMemberPointersIfInMemoryPool()
66772 : {
66773 : // ------------ checking pointers of SgInquireStatement -------------------
66774 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
66775 :
66776 0 : if ( p_file != NULL )
66777 : {
66778 0 : if ( p_file->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66779 : {
66780 0 : if ( p_file->isInMemoryPool() == false )
66781 : {
66782 0 : std::cout << "SgInquireStatement :: ";
66783 0 : std::cout << " p_file is not in memory pool of ";
66784 0 : std::cout << p_file->class_name() << std::endl;
66785 : }
66786 : }
66787 : else
66788 : {
66789 0 : std::cout << "SgInquireStatement :: " << std::flush;
66790 0 : std::cout << "SgExpression* p_file = " << p_file << " --> " << std::flush;
66791 0 : std::cout << " not valid " << std::endl;
66792 : }
66793 : }
66794 :
66795 0 : if ( p_access != NULL )
66796 : {
66797 0 : if ( p_access->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66798 : {
66799 0 : if ( p_access->isInMemoryPool() == false )
66800 : {
66801 0 : std::cout << "SgInquireStatement :: ";
66802 0 : std::cout << " p_access is not in memory pool of ";
66803 0 : std::cout << p_access->class_name() << std::endl;
66804 : }
66805 : }
66806 : else
66807 : {
66808 0 : std::cout << "SgInquireStatement :: " << std::flush;
66809 0 : std::cout << "SgExpression* p_access = " << p_access << " --> " << std::flush;
66810 0 : std::cout << " not valid " << std::endl;
66811 : }
66812 : }
66813 :
66814 0 : if ( p_form != NULL )
66815 : {
66816 0 : if ( p_form->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66817 : {
66818 0 : if ( p_form->isInMemoryPool() == false )
66819 : {
66820 0 : std::cout << "SgInquireStatement :: ";
66821 0 : std::cout << " p_form is not in memory pool of ";
66822 0 : std::cout << p_form->class_name() << std::endl;
66823 : }
66824 : }
66825 : else
66826 : {
66827 0 : std::cout << "SgInquireStatement :: " << std::flush;
66828 0 : std::cout << "SgExpression* p_form = " << p_form << " --> " << std::flush;
66829 0 : std::cout << " not valid " << std::endl;
66830 : }
66831 : }
66832 :
66833 0 : if ( p_recl != NULL )
66834 : {
66835 0 : if ( p_recl->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66836 : {
66837 0 : if ( p_recl->isInMemoryPool() == false )
66838 : {
66839 0 : std::cout << "SgInquireStatement :: ";
66840 0 : std::cout << " p_recl is not in memory pool of ";
66841 0 : std::cout << p_recl->class_name() << std::endl;
66842 : }
66843 : }
66844 : else
66845 : {
66846 0 : std::cout << "SgInquireStatement :: " << std::flush;
66847 0 : std::cout << "SgExpression* p_recl = " << p_recl << " --> " << std::flush;
66848 0 : std::cout << " not valid " << std::endl;
66849 : }
66850 : }
66851 :
66852 0 : if ( p_blank != NULL )
66853 : {
66854 0 : if ( p_blank->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66855 : {
66856 0 : if ( p_blank->isInMemoryPool() == false )
66857 : {
66858 0 : std::cout << "SgInquireStatement :: ";
66859 0 : std::cout << " p_blank is not in memory pool of ";
66860 0 : std::cout << p_blank->class_name() << std::endl;
66861 : }
66862 : }
66863 : else
66864 : {
66865 0 : std::cout << "SgInquireStatement :: " << std::flush;
66866 0 : std::cout << "SgExpression* p_blank = " << p_blank << " --> " << std::flush;
66867 0 : std::cout << " not valid " << std::endl;
66868 : }
66869 : }
66870 :
66871 0 : if ( p_exist != NULL )
66872 : {
66873 0 : if ( p_exist->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66874 : {
66875 0 : if ( p_exist->isInMemoryPool() == false )
66876 : {
66877 0 : std::cout << "SgInquireStatement :: ";
66878 0 : std::cout << " p_exist is not in memory pool of ";
66879 0 : std::cout << p_exist->class_name() << std::endl;
66880 : }
66881 : }
66882 : else
66883 : {
66884 0 : std::cout << "SgInquireStatement :: " << std::flush;
66885 0 : std::cout << "SgExpression* p_exist = " << p_exist << " --> " << std::flush;
66886 0 : std::cout << " not valid " << std::endl;
66887 : }
66888 : }
66889 :
66890 0 : if ( p_opened != NULL )
66891 : {
66892 0 : if ( p_opened->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66893 : {
66894 0 : if ( p_opened->isInMemoryPool() == false )
66895 : {
66896 0 : std::cout << "SgInquireStatement :: ";
66897 0 : std::cout << " p_opened is not in memory pool of ";
66898 0 : std::cout << p_opened->class_name() << std::endl;
66899 : }
66900 : }
66901 : else
66902 : {
66903 0 : std::cout << "SgInquireStatement :: " << std::flush;
66904 0 : std::cout << "SgExpression* p_opened = " << p_opened << " --> " << std::flush;
66905 0 : std::cout << " not valid " << std::endl;
66906 : }
66907 : }
66908 :
66909 0 : if ( p_number != NULL )
66910 : {
66911 0 : if ( p_number->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66912 : {
66913 0 : if ( p_number->isInMemoryPool() == false )
66914 : {
66915 0 : std::cout << "SgInquireStatement :: ";
66916 0 : std::cout << " p_number is not in memory pool of ";
66917 0 : std::cout << p_number->class_name() << std::endl;
66918 : }
66919 : }
66920 : else
66921 : {
66922 0 : std::cout << "SgInquireStatement :: " << std::flush;
66923 0 : std::cout << "SgExpression* p_number = " << p_number << " --> " << std::flush;
66924 0 : std::cout << " not valid " << std::endl;
66925 : }
66926 : }
66927 :
66928 0 : if ( p_named != NULL )
66929 : {
66930 0 : if ( p_named->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66931 : {
66932 0 : if ( p_named->isInMemoryPool() == false )
66933 : {
66934 0 : std::cout << "SgInquireStatement :: ";
66935 0 : std::cout << " p_named is not in memory pool of ";
66936 0 : std::cout << p_named->class_name() << std::endl;
66937 : }
66938 : }
66939 : else
66940 : {
66941 0 : std::cout << "SgInquireStatement :: " << std::flush;
66942 0 : std::cout << "SgExpression* p_named = " << p_named << " --> " << std::flush;
66943 0 : std::cout << " not valid " << std::endl;
66944 : }
66945 : }
66946 :
66947 0 : if ( p_name != NULL )
66948 : {
66949 0 : if ( p_name->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66950 : {
66951 0 : if ( p_name->isInMemoryPool() == false )
66952 : {
66953 0 : std::cout << "SgInquireStatement :: ";
66954 0 : std::cout << " p_name is not in memory pool of ";
66955 0 : std::cout << p_name->class_name() << std::endl;
66956 : }
66957 : }
66958 : else
66959 : {
66960 0 : std::cout << "SgInquireStatement :: " << std::flush;
66961 0 : std::cout << "SgExpression* p_name = " << p_name << " --> " << std::flush;
66962 0 : std::cout << " not valid " << std::endl;
66963 : }
66964 : }
66965 :
66966 0 : if ( p_sequential != NULL )
66967 : {
66968 0 : if ( p_sequential->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66969 : {
66970 0 : if ( p_sequential->isInMemoryPool() == false )
66971 : {
66972 0 : std::cout << "SgInquireStatement :: ";
66973 0 : std::cout << " p_sequential is not in memory pool of ";
66974 0 : std::cout << p_sequential->class_name() << std::endl;
66975 : }
66976 : }
66977 : else
66978 : {
66979 0 : std::cout << "SgInquireStatement :: " << std::flush;
66980 0 : std::cout << "SgExpression* p_sequential = " << p_sequential << " --> " << std::flush;
66981 0 : std::cout << " not valid " << std::endl;
66982 : }
66983 : }
66984 :
66985 0 : if ( p_direct != NULL )
66986 : {
66987 0 : if ( p_direct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
66988 : {
66989 0 : if ( p_direct->isInMemoryPool() == false )
66990 : {
66991 0 : std::cout << "SgInquireStatement :: ";
66992 0 : std::cout << " p_direct is not in memory pool of ";
66993 0 : std::cout << p_direct->class_name() << std::endl;
66994 : }
66995 : }
66996 : else
66997 : {
66998 0 : std::cout << "SgInquireStatement :: " << std::flush;
66999 0 : std::cout << "SgExpression* p_direct = " << p_direct << " --> " << std::flush;
67000 0 : std::cout << " not valid " << std::endl;
67001 : }
67002 : }
67003 :
67004 0 : if ( p_formatted != NULL )
67005 : {
67006 0 : if ( p_formatted->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67007 : {
67008 0 : if ( p_formatted->isInMemoryPool() == false )
67009 : {
67010 0 : std::cout << "SgInquireStatement :: ";
67011 0 : std::cout << " p_formatted is not in memory pool of ";
67012 0 : std::cout << p_formatted->class_name() << std::endl;
67013 : }
67014 : }
67015 : else
67016 : {
67017 0 : std::cout << "SgInquireStatement :: " << std::flush;
67018 0 : std::cout << "SgExpression* p_formatted = " << p_formatted << " --> " << std::flush;
67019 0 : std::cout << " not valid " << std::endl;
67020 : }
67021 : }
67022 :
67023 0 : if ( p_unformatted != NULL )
67024 : {
67025 0 : if ( p_unformatted->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67026 : {
67027 0 : if ( p_unformatted->isInMemoryPool() == false )
67028 : {
67029 0 : std::cout << "SgInquireStatement :: ";
67030 0 : std::cout << " p_unformatted is not in memory pool of ";
67031 0 : std::cout << p_unformatted->class_name() << std::endl;
67032 : }
67033 : }
67034 : else
67035 : {
67036 0 : std::cout << "SgInquireStatement :: " << std::flush;
67037 0 : std::cout << "SgExpression* p_unformatted = " << p_unformatted << " --> " << std::flush;
67038 0 : std::cout << " not valid " << std::endl;
67039 : }
67040 : }
67041 :
67042 0 : if ( p_nextrec != NULL )
67043 : {
67044 0 : if ( p_nextrec->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67045 : {
67046 0 : if ( p_nextrec->isInMemoryPool() == false )
67047 : {
67048 0 : std::cout << "SgInquireStatement :: ";
67049 0 : std::cout << " p_nextrec is not in memory pool of ";
67050 0 : std::cout << p_nextrec->class_name() << std::endl;
67051 : }
67052 : }
67053 : else
67054 : {
67055 0 : std::cout << "SgInquireStatement :: " << std::flush;
67056 0 : std::cout << "SgExpression* p_nextrec = " << p_nextrec << " --> " << std::flush;
67057 0 : std::cout << " not valid " << std::endl;
67058 : }
67059 : }
67060 :
67061 0 : if ( p_position != NULL )
67062 : {
67063 0 : if ( p_position->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67064 : {
67065 0 : if ( p_position->isInMemoryPool() == false )
67066 : {
67067 0 : std::cout << "SgInquireStatement :: ";
67068 0 : std::cout << " p_position is not in memory pool of ";
67069 0 : std::cout << p_position->class_name() << std::endl;
67070 : }
67071 : }
67072 : else
67073 : {
67074 0 : std::cout << "SgInquireStatement :: " << std::flush;
67075 0 : std::cout << "SgExpression* p_position = " << p_position << " --> " << std::flush;
67076 0 : std::cout << " not valid " << std::endl;
67077 : }
67078 : }
67079 :
67080 0 : if ( p_action != NULL )
67081 : {
67082 0 : if ( p_action->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67083 : {
67084 0 : if ( p_action->isInMemoryPool() == false )
67085 : {
67086 0 : std::cout << "SgInquireStatement :: ";
67087 0 : std::cout << " p_action is not in memory pool of ";
67088 0 : std::cout << p_action->class_name() << std::endl;
67089 : }
67090 : }
67091 : else
67092 : {
67093 0 : std::cout << "SgInquireStatement :: " << std::flush;
67094 0 : std::cout << "SgExpression* p_action = " << p_action << " --> " << std::flush;
67095 0 : std::cout << " not valid " << std::endl;
67096 : }
67097 : }
67098 :
67099 0 : if ( p_read != NULL )
67100 : {
67101 0 : if ( p_read->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67102 : {
67103 0 : if ( p_read->isInMemoryPool() == false )
67104 : {
67105 0 : std::cout << "SgInquireStatement :: ";
67106 0 : std::cout << " p_read is not in memory pool of ";
67107 0 : std::cout << p_read->class_name() << std::endl;
67108 : }
67109 : }
67110 : else
67111 : {
67112 0 : std::cout << "SgInquireStatement :: " << std::flush;
67113 0 : std::cout << "SgExpression* p_read = " << p_read << " --> " << std::flush;
67114 0 : std::cout << " not valid " << std::endl;
67115 : }
67116 : }
67117 :
67118 0 : if ( p_write != NULL )
67119 : {
67120 0 : if ( p_write->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67121 : {
67122 0 : if ( p_write->isInMemoryPool() == false )
67123 : {
67124 0 : std::cout << "SgInquireStatement :: ";
67125 0 : std::cout << " p_write is not in memory pool of ";
67126 0 : std::cout << p_write->class_name() << std::endl;
67127 : }
67128 : }
67129 : else
67130 : {
67131 0 : std::cout << "SgInquireStatement :: " << std::flush;
67132 0 : std::cout << "SgExpression* p_write = " << p_write << " --> " << std::flush;
67133 0 : std::cout << " not valid " << std::endl;
67134 : }
67135 : }
67136 :
67137 0 : if ( p_readwrite != NULL )
67138 : {
67139 0 : if ( p_readwrite->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67140 : {
67141 0 : if ( p_readwrite->isInMemoryPool() == false )
67142 : {
67143 0 : std::cout << "SgInquireStatement :: ";
67144 0 : std::cout << " p_readwrite is not in memory pool of ";
67145 0 : std::cout << p_readwrite->class_name() << std::endl;
67146 : }
67147 : }
67148 : else
67149 : {
67150 0 : std::cout << "SgInquireStatement :: " << std::flush;
67151 0 : std::cout << "SgExpression* p_readwrite = " << p_readwrite << " --> " << std::flush;
67152 0 : std::cout << " not valid " << std::endl;
67153 : }
67154 : }
67155 :
67156 0 : if ( p_delim != NULL )
67157 : {
67158 0 : if ( p_delim->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67159 : {
67160 0 : if ( p_delim->isInMemoryPool() == false )
67161 : {
67162 0 : std::cout << "SgInquireStatement :: ";
67163 0 : std::cout << " p_delim is not in memory pool of ";
67164 0 : std::cout << p_delim->class_name() << std::endl;
67165 : }
67166 : }
67167 : else
67168 : {
67169 0 : std::cout << "SgInquireStatement :: " << std::flush;
67170 0 : std::cout << "SgExpression* p_delim = " << p_delim << " --> " << std::flush;
67171 0 : std::cout << " not valid " << std::endl;
67172 : }
67173 : }
67174 :
67175 0 : if ( p_pad != NULL )
67176 : {
67177 0 : if ( p_pad->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67178 : {
67179 0 : if ( p_pad->isInMemoryPool() == false )
67180 : {
67181 0 : std::cout << "SgInquireStatement :: ";
67182 0 : std::cout << " p_pad is not in memory pool of ";
67183 0 : std::cout << p_pad->class_name() << std::endl;
67184 : }
67185 : }
67186 : else
67187 : {
67188 0 : std::cout << "SgInquireStatement :: " << std::flush;
67189 0 : std::cout << "SgExpression* p_pad = " << p_pad << " --> " << std::flush;
67190 0 : std::cout << " not valid " << std::endl;
67191 : }
67192 : }
67193 :
67194 0 : if ( p_asynchronous != NULL )
67195 : {
67196 0 : if ( p_asynchronous->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67197 : {
67198 0 : if ( p_asynchronous->isInMemoryPool() == false )
67199 : {
67200 0 : std::cout << "SgInquireStatement :: ";
67201 0 : std::cout << " p_asynchronous is not in memory pool of ";
67202 0 : std::cout << p_asynchronous->class_name() << std::endl;
67203 : }
67204 : }
67205 : else
67206 : {
67207 0 : std::cout << "SgInquireStatement :: " << std::flush;
67208 0 : std::cout << "SgExpression* p_asynchronous = " << p_asynchronous << " --> " << std::flush;
67209 0 : std::cout << " not valid " << std::endl;
67210 : }
67211 : }
67212 :
67213 0 : if ( p_decimal != NULL )
67214 : {
67215 0 : if ( p_decimal->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67216 : {
67217 0 : if ( p_decimal->isInMemoryPool() == false )
67218 : {
67219 0 : std::cout << "SgInquireStatement :: ";
67220 0 : std::cout << " p_decimal is not in memory pool of ";
67221 0 : std::cout << p_decimal->class_name() << std::endl;
67222 : }
67223 : }
67224 : else
67225 : {
67226 0 : std::cout << "SgInquireStatement :: " << std::flush;
67227 0 : std::cout << "SgExpression* p_decimal = " << p_decimal << " --> " << std::flush;
67228 0 : std::cout << " not valid " << std::endl;
67229 : }
67230 : }
67231 :
67232 0 : if ( p_stream != NULL )
67233 : {
67234 0 : if ( p_stream->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67235 : {
67236 0 : if ( p_stream->isInMemoryPool() == false )
67237 : {
67238 0 : std::cout << "SgInquireStatement :: ";
67239 0 : std::cout << " p_stream is not in memory pool of ";
67240 0 : std::cout << p_stream->class_name() << std::endl;
67241 : }
67242 : }
67243 : else
67244 : {
67245 0 : std::cout << "SgInquireStatement :: " << std::flush;
67246 0 : std::cout << "SgExpression* p_stream = " << p_stream << " --> " << std::flush;
67247 0 : std::cout << " not valid " << std::endl;
67248 : }
67249 : }
67250 :
67251 0 : if ( p_size != NULL )
67252 : {
67253 0 : if ( p_size->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67254 : {
67255 0 : if ( p_size->isInMemoryPool() == false )
67256 : {
67257 0 : std::cout << "SgInquireStatement :: ";
67258 0 : std::cout << " p_size is not in memory pool of ";
67259 0 : std::cout << p_size->class_name() << std::endl;
67260 : }
67261 : }
67262 : else
67263 : {
67264 0 : std::cout << "SgInquireStatement :: " << std::flush;
67265 0 : std::cout << "SgExpression* p_size = " << p_size << " --> " << std::flush;
67266 0 : std::cout << " not valid " << std::endl;
67267 : }
67268 : }
67269 :
67270 0 : if ( p_pending != NULL )
67271 : {
67272 0 : if ( p_pending->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67273 : {
67274 0 : if ( p_pending->isInMemoryPool() == false )
67275 : {
67276 0 : std::cout << "SgInquireStatement :: ";
67277 0 : std::cout << " p_pending is not in memory pool of ";
67278 0 : std::cout << p_pending->class_name() << std::endl;
67279 : }
67280 : }
67281 : else
67282 : {
67283 0 : std::cout << "SgInquireStatement :: " << std::flush;
67284 0 : std::cout << "SgExpression* p_pending = " << p_pending << " --> " << std::flush;
67285 0 : std::cout << " not valid " << std::endl;
67286 : }
67287 : }
67288 :
67289 0 : if ( p_iolengthExp != NULL )
67290 : {
67291 0 : if ( p_iolengthExp->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67292 : {
67293 0 : if ( p_iolengthExp->isInMemoryPool() == false )
67294 : {
67295 0 : std::cout << "SgInquireStatement :: ";
67296 0 : std::cout << " p_iolengthExp is not in memory pool of ";
67297 0 : std::cout << p_iolengthExp->class_name() << std::endl;
67298 : }
67299 : }
67300 : else
67301 : {
67302 0 : std::cout << "SgInquireStatement :: " << std::flush;
67303 0 : std::cout << "SgVarRefExp* p_iolengthExp = " << p_iolengthExp << " --> " << std::flush;
67304 0 : std::cout << " not valid " << std::endl;
67305 : }
67306 : }
67307 :
67308 0 : if ( p_io_stmt_list != NULL )
67309 : {
67310 0 : if ( p_io_stmt_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67311 : {
67312 0 : if ( p_io_stmt_list->isInMemoryPool() == false )
67313 : {
67314 0 : std::cout << "SgInquireStatement :: ";
67315 0 : std::cout << " p_io_stmt_list is not in memory pool of ";
67316 0 : std::cout << p_io_stmt_list->class_name() << std::endl;
67317 : }
67318 : }
67319 : else
67320 : {
67321 0 : std::cout << "SgInquireStatement :: " << std::flush;
67322 0 : std::cout << "SgExprListExp* p_io_stmt_list = " << p_io_stmt_list << " --> " << std::flush;
67323 0 : std::cout << " not valid " << std::endl;
67324 : }
67325 : }
67326 :
67327 0 : if ( p_unit != NULL )
67328 : {
67329 0 : if ( p_unit->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67330 : {
67331 0 : if ( p_unit->isInMemoryPool() == false )
67332 : {
67333 0 : std::cout << "SgInquireStatement :: ";
67334 0 : std::cout << " p_unit is not in memory pool of ";
67335 0 : std::cout << p_unit->class_name() << std::endl;
67336 : }
67337 : }
67338 : else
67339 : {
67340 0 : std::cout << "SgInquireStatement :: " << std::flush;
67341 0 : std::cout << "SgExpression* p_unit = " << p_unit << " --> " << std::flush;
67342 0 : std::cout << " not valid " << std::endl;
67343 : }
67344 : }
67345 :
67346 0 : if ( p_iostat != NULL )
67347 : {
67348 0 : if ( p_iostat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67349 : {
67350 0 : if ( p_iostat->isInMemoryPool() == false )
67351 : {
67352 0 : std::cout << "SgInquireStatement :: ";
67353 0 : std::cout << " p_iostat is not in memory pool of ";
67354 0 : std::cout << p_iostat->class_name() << std::endl;
67355 : }
67356 : }
67357 : else
67358 : {
67359 0 : std::cout << "SgInquireStatement :: " << std::flush;
67360 0 : std::cout << "SgExpression* p_iostat = " << p_iostat << " --> " << std::flush;
67361 0 : std::cout << " not valid " << std::endl;
67362 : }
67363 : }
67364 :
67365 0 : if ( p_err != NULL )
67366 : {
67367 0 : if ( p_err->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67368 : {
67369 0 : if ( p_err->isInMemoryPool() == false )
67370 : {
67371 0 : std::cout << "SgInquireStatement :: ";
67372 0 : std::cout << " p_err is not in memory pool of ";
67373 0 : std::cout << p_err->class_name() << std::endl;
67374 : }
67375 : }
67376 : else
67377 : {
67378 0 : std::cout << "SgInquireStatement :: " << std::flush;
67379 0 : std::cout << "SgExpression* p_err = " << p_err << " --> " << std::flush;
67380 0 : std::cout << " not valid " << std::endl;
67381 : }
67382 : }
67383 :
67384 0 : if ( p_iomsg != NULL )
67385 : {
67386 0 : if ( p_iomsg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67387 : {
67388 0 : if ( p_iomsg->isInMemoryPool() == false )
67389 : {
67390 0 : std::cout << "SgInquireStatement :: ";
67391 0 : std::cout << " p_iomsg is not in memory pool of ";
67392 0 : std::cout << p_iomsg->class_name() << std::endl;
67393 : }
67394 : }
67395 : else
67396 : {
67397 0 : std::cout << "SgInquireStatement :: " << std::flush;
67398 0 : std::cout << "SgExpression* p_iomsg = " << p_iomsg << " --> " << std::flush;
67399 0 : std::cout << " not valid " << std::endl;
67400 : }
67401 : }
67402 :
67403 0 : if ( p_numeric_label != NULL )
67404 : {
67405 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67406 : {
67407 0 : if ( p_numeric_label->isInMemoryPool() == false )
67408 : {
67409 0 : std::cout << "SgInquireStatement :: ";
67410 0 : std::cout << " p_numeric_label is not in memory pool of ";
67411 0 : std::cout << p_numeric_label->class_name() << std::endl;
67412 : }
67413 : }
67414 : else
67415 : {
67416 0 : std::cout << "SgInquireStatement :: " << std::flush;
67417 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
67418 0 : std::cout << " not valid " << std::endl;
67419 : }
67420 : }
67421 :
67422 0 : if ( p_startOfConstruct != NULL )
67423 : {
67424 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67425 : {
67426 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
67427 : {
67428 0 : std::cout << "SgInquireStatement :: ";
67429 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
67430 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
67431 : }
67432 : }
67433 : else
67434 : {
67435 0 : std::cout << "SgInquireStatement :: " << std::flush;
67436 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
67437 0 : std::cout << " not valid " << std::endl;
67438 : }
67439 : }
67440 :
67441 0 : if ( p_endOfConstruct != NULL )
67442 : {
67443 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67444 : {
67445 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
67446 : {
67447 0 : std::cout << "SgInquireStatement :: ";
67448 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
67449 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
67450 : }
67451 : }
67452 : else
67453 : {
67454 0 : std::cout << "SgInquireStatement :: " << std::flush;
67455 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
67456 0 : std::cout << " not valid " << std::endl;
67457 : }
67458 : }
67459 :
67460 0 : if ( p_parent != NULL )
67461 : {
67462 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67463 : {
67464 0 : if ( p_parent->isInMemoryPool() == false )
67465 : {
67466 0 : std::cout << "SgInquireStatement :: ";
67467 0 : std::cout << " p_parent is not in memory pool of ";
67468 0 : std::cout << p_parent->class_name() << std::endl;
67469 : }
67470 : }
67471 : else
67472 : {
67473 0 : std::cout << "SgInquireStatement :: " << std::flush;
67474 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
67475 0 : std::cout << " not valid " << std::endl;
67476 : }
67477 : }
67478 :
67479 :
67480 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
67481 :
67482 0 : }
67483 :
67484 :
67485 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
67486 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
67487 : bool
67488 0 : SgInquireStatement::isInMemoryPool ()
67489 : {
67490 0 : typedef unsigned char* TestType;
67491 :
67492 0 : bool found = false;
67493 :
67494 0 : ROSE_ASSERT(this != NULL);
67495 :
67496 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
67497 :
67498 0 : TestType tested = (TestType) ( this ) ;
67499 :
67500 0 : std::vector < unsigned char* > :: const_iterator block = SgInquireStatement::pools.begin();
67501 :
67502 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
67503 : // while (found == false && block < Memory_Block_List.end())
67504 0 : while ( (found == false) && (block != SgInquireStatement::pools.end()) )
67505 : {
67506 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgInquireStatement::pool_size * sizeof(SgInquireStatement) ) ) ;
67507 0 : ++block;
67508 : }
67509 :
67510 : // Special handling for static data
67511 :
67512 :
67513 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
67514 0 : ROSE_ASSERT(found == true);
67515 :
67516 0 : return found;
67517 : }
67518 : /* #line 67519 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
67519 :
67520 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
67521 :
67522 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
67523 :
67524 : /* #line 67525 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
67525 :
67526 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
67527 :
67528 : void
67529 0 : SgFlushStatement::checkDataMemberPointersIfInMemoryPool()
67530 : {
67531 : // ------------ checking pointers of SgFlushStatement -------------------
67532 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
67533 :
67534 0 : if ( p_io_stmt_list != NULL )
67535 : {
67536 0 : if ( p_io_stmt_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67537 : {
67538 0 : if ( p_io_stmt_list->isInMemoryPool() == false )
67539 : {
67540 0 : std::cout << "SgFlushStatement :: ";
67541 0 : std::cout << " p_io_stmt_list is not in memory pool of ";
67542 0 : std::cout << p_io_stmt_list->class_name() << std::endl;
67543 : }
67544 : }
67545 : else
67546 : {
67547 0 : std::cout << "SgFlushStatement :: " << std::flush;
67548 0 : std::cout << "SgExprListExp* p_io_stmt_list = " << p_io_stmt_list << " --> " << std::flush;
67549 0 : std::cout << " not valid " << std::endl;
67550 : }
67551 : }
67552 :
67553 0 : if ( p_unit != NULL )
67554 : {
67555 0 : if ( p_unit->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67556 : {
67557 0 : if ( p_unit->isInMemoryPool() == false )
67558 : {
67559 0 : std::cout << "SgFlushStatement :: ";
67560 0 : std::cout << " p_unit is not in memory pool of ";
67561 0 : std::cout << p_unit->class_name() << std::endl;
67562 : }
67563 : }
67564 : else
67565 : {
67566 0 : std::cout << "SgFlushStatement :: " << std::flush;
67567 0 : std::cout << "SgExpression* p_unit = " << p_unit << " --> " << std::flush;
67568 0 : std::cout << " not valid " << std::endl;
67569 : }
67570 : }
67571 :
67572 0 : if ( p_iostat != NULL )
67573 : {
67574 0 : if ( p_iostat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67575 : {
67576 0 : if ( p_iostat->isInMemoryPool() == false )
67577 : {
67578 0 : std::cout << "SgFlushStatement :: ";
67579 0 : std::cout << " p_iostat is not in memory pool of ";
67580 0 : std::cout << p_iostat->class_name() << std::endl;
67581 : }
67582 : }
67583 : else
67584 : {
67585 0 : std::cout << "SgFlushStatement :: " << std::flush;
67586 0 : std::cout << "SgExpression* p_iostat = " << p_iostat << " --> " << std::flush;
67587 0 : std::cout << " not valid " << std::endl;
67588 : }
67589 : }
67590 :
67591 0 : if ( p_err != NULL )
67592 : {
67593 0 : if ( p_err->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67594 : {
67595 0 : if ( p_err->isInMemoryPool() == false )
67596 : {
67597 0 : std::cout << "SgFlushStatement :: ";
67598 0 : std::cout << " p_err is not in memory pool of ";
67599 0 : std::cout << p_err->class_name() << std::endl;
67600 : }
67601 : }
67602 : else
67603 : {
67604 0 : std::cout << "SgFlushStatement :: " << std::flush;
67605 0 : std::cout << "SgExpression* p_err = " << p_err << " --> " << std::flush;
67606 0 : std::cout << " not valid " << std::endl;
67607 : }
67608 : }
67609 :
67610 0 : if ( p_iomsg != NULL )
67611 : {
67612 0 : if ( p_iomsg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67613 : {
67614 0 : if ( p_iomsg->isInMemoryPool() == false )
67615 : {
67616 0 : std::cout << "SgFlushStatement :: ";
67617 0 : std::cout << " p_iomsg is not in memory pool of ";
67618 0 : std::cout << p_iomsg->class_name() << std::endl;
67619 : }
67620 : }
67621 : else
67622 : {
67623 0 : std::cout << "SgFlushStatement :: " << std::flush;
67624 0 : std::cout << "SgExpression* p_iomsg = " << p_iomsg << " --> " << std::flush;
67625 0 : std::cout << " not valid " << std::endl;
67626 : }
67627 : }
67628 :
67629 0 : if ( p_numeric_label != NULL )
67630 : {
67631 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67632 : {
67633 0 : if ( p_numeric_label->isInMemoryPool() == false )
67634 : {
67635 0 : std::cout << "SgFlushStatement :: ";
67636 0 : std::cout << " p_numeric_label is not in memory pool of ";
67637 0 : std::cout << p_numeric_label->class_name() << std::endl;
67638 : }
67639 : }
67640 : else
67641 : {
67642 0 : std::cout << "SgFlushStatement :: " << std::flush;
67643 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
67644 0 : std::cout << " not valid " << std::endl;
67645 : }
67646 : }
67647 :
67648 0 : if ( p_startOfConstruct != NULL )
67649 : {
67650 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67651 : {
67652 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
67653 : {
67654 0 : std::cout << "SgFlushStatement :: ";
67655 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
67656 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
67657 : }
67658 : }
67659 : else
67660 : {
67661 0 : std::cout << "SgFlushStatement :: " << std::flush;
67662 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
67663 0 : std::cout << " not valid " << std::endl;
67664 : }
67665 : }
67666 :
67667 0 : if ( p_endOfConstruct != NULL )
67668 : {
67669 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67670 : {
67671 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
67672 : {
67673 0 : std::cout << "SgFlushStatement :: ";
67674 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
67675 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
67676 : }
67677 : }
67678 : else
67679 : {
67680 0 : std::cout << "SgFlushStatement :: " << std::flush;
67681 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
67682 0 : std::cout << " not valid " << std::endl;
67683 : }
67684 : }
67685 :
67686 0 : if ( p_parent != NULL )
67687 : {
67688 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67689 : {
67690 0 : if ( p_parent->isInMemoryPool() == false )
67691 : {
67692 0 : std::cout << "SgFlushStatement :: ";
67693 0 : std::cout << " p_parent is not in memory pool of ";
67694 0 : std::cout << p_parent->class_name() << std::endl;
67695 : }
67696 : }
67697 : else
67698 : {
67699 0 : std::cout << "SgFlushStatement :: " << std::flush;
67700 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
67701 0 : std::cout << " not valid " << std::endl;
67702 : }
67703 : }
67704 :
67705 :
67706 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
67707 :
67708 0 : }
67709 :
67710 :
67711 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
67712 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
67713 : bool
67714 0 : SgFlushStatement::isInMemoryPool ()
67715 : {
67716 0 : typedef unsigned char* TestType;
67717 :
67718 0 : bool found = false;
67719 :
67720 0 : ROSE_ASSERT(this != NULL);
67721 :
67722 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
67723 :
67724 0 : TestType tested = (TestType) ( this ) ;
67725 :
67726 0 : std::vector < unsigned char* > :: const_iterator block = SgFlushStatement::pools.begin();
67727 :
67728 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
67729 : // while (found == false && block < Memory_Block_List.end())
67730 0 : while ( (found == false) && (block != SgFlushStatement::pools.end()) )
67731 : {
67732 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFlushStatement::pool_size * sizeof(SgFlushStatement) ) ) ;
67733 0 : ++block;
67734 : }
67735 :
67736 : // Special handling for static data
67737 :
67738 :
67739 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
67740 0 : ROSE_ASSERT(found == true);
67741 :
67742 0 : return found;
67743 : }
67744 : /* #line 67745 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
67745 :
67746 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
67747 :
67748 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
67749 :
67750 : /* #line 67751 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
67751 :
67752 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
67753 :
67754 : void
67755 0 : SgBackspaceStatement::checkDataMemberPointersIfInMemoryPool()
67756 : {
67757 : // ------------ checking pointers of SgBackspaceStatement -------------------
67758 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
67759 :
67760 0 : if ( p_io_stmt_list != NULL )
67761 : {
67762 0 : if ( p_io_stmt_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67763 : {
67764 0 : if ( p_io_stmt_list->isInMemoryPool() == false )
67765 : {
67766 0 : std::cout << "SgBackspaceStatement :: ";
67767 0 : std::cout << " p_io_stmt_list is not in memory pool of ";
67768 0 : std::cout << p_io_stmt_list->class_name() << std::endl;
67769 : }
67770 : }
67771 : else
67772 : {
67773 0 : std::cout << "SgBackspaceStatement :: " << std::flush;
67774 0 : std::cout << "SgExprListExp* p_io_stmt_list = " << p_io_stmt_list << " --> " << std::flush;
67775 0 : std::cout << " not valid " << std::endl;
67776 : }
67777 : }
67778 :
67779 0 : if ( p_unit != NULL )
67780 : {
67781 0 : if ( p_unit->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67782 : {
67783 0 : if ( p_unit->isInMemoryPool() == false )
67784 : {
67785 0 : std::cout << "SgBackspaceStatement :: ";
67786 0 : std::cout << " p_unit is not in memory pool of ";
67787 0 : std::cout << p_unit->class_name() << std::endl;
67788 : }
67789 : }
67790 : else
67791 : {
67792 0 : std::cout << "SgBackspaceStatement :: " << std::flush;
67793 0 : std::cout << "SgExpression* p_unit = " << p_unit << " --> " << std::flush;
67794 0 : std::cout << " not valid " << std::endl;
67795 : }
67796 : }
67797 :
67798 0 : if ( p_iostat != NULL )
67799 : {
67800 0 : if ( p_iostat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67801 : {
67802 0 : if ( p_iostat->isInMemoryPool() == false )
67803 : {
67804 0 : std::cout << "SgBackspaceStatement :: ";
67805 0 : std::cout << " p_iostat is not in memory pool of ";
67806 0 : std::cout << p_iostat->class_name() << std::endl;
67807 : }
67808 : }
67809 : else
67810 : {
67811 0 : std::cout << "SgBackspaceStatement :: " << std::flush;
67812 0 : std::cout << "SgExpression* p_iostat = " << p_iostat << " --> " << std::flush;
67813 0 : std::cout << " not valid " << std::endl;
67814 : }
67815 : }
67816 :
67817 0 : if ( p_err != NULL )
67818 : {
67819 0 : if ( p_err->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67820 : {
67821 0 : if ( p_err->isInMemoryPool() == false )
67822 : {
67823 0 : std::cout << "SgBackspaceStatement :: ";
67824 0 : std::cout << " p_err is not in memory pool of ";
67825 0 : std::cout << p_err->class_name() << std::endl;
67826 : }
67827 : }
67828 : else
67829 : {
67830 0 : std::cout << "SgBackspaceStatement :: " << std::flush;
67831 0 : std::cout << "SgExpression* p_err = " << p_err << " --> " << std::flush;
67832 0 : std::cout << " not valid " << std::endl;
67833 : }
67834 : }
67835 :
67836 0 : if ( p_iomsg != NULL )
67837 : {
67838 0 : if ( p_iomsg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67839 : {
67840 0 : if ( p_iomsg->isInMemoryPool() == false )
67841 : {
67842 0 : std::cout << "SgBackspaceStatement :: ";
67843 0 : std::cout << " p_iomsg is not in memory pool of ";
67844 0 : std::cout << p_iomsg->class_name() << std::endl;
67845 : }
67846 : }
67847 : else
67848 : {
67849 0 : std::cout << "SgBackspaceStatement :: " << std::flush;
67850 0 : std::cout << "SgExpression* p_iomsg = " << p_iomsg << " --> " << std::flush;
67851 0 : std::cout << " not valid " << std::endl;
67852 : }
67853 : }
67854 :
67855 0 : if ( p_numeric_label != NULL )
67856 : {
67857 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67858 : {
67859 0 : if ( p_numeric_label->isInMemoryPool() == false )
67860 : {
67861 0 : std::cout << "SgBackspaceStatement :: ";
67862 0 : std::cout << " p_numeric_label is not in memory pool of ";
67863 0 : std::cout << p_numeric_label->class_name() << std::endl;
67864 : }
67865 : }
67866 : else
67867 : {
67868 0 : std::cout << "SgBackspaceStatement :: " << std::flush;
67869 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
67870 0 : std::cout << " not valid " << std::endl;
67871 : }
67872 : }
67873 :
67874 0 : if ( p_startOfConstruct != NULL )
67875 : {
67876 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67877 : {
67878 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
67879 : {
67880 0 : std::cout << "SgBackspaceStatement :: ";
67881 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
67882 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
67883 : }
67884 : }
67885 : else
67886 : {
67887 0 : std::cout << "SgBackspaceStatement :: " << std::flush;
67888 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
67889 0 : std::cout << " not valid " << std::endl;
67890 : }
67891 : }
67892 :
67893 0 : if ( p_endOfConstruct != NULL )
67894 : {
67895 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67896 : {
67897 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
67898 : {
67899 0 : std::cout << "SgBackspaceStatement :: ";
67900 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
67901 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
67902 : }
67903 : }
67904 : else
67905 : {
67906 0 : std::cout << "SgBackspaceStatement :: " << std::flush;
67907 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
67908 0 : std::cout << " not valid " << std::endl;
67909 : }
67910 : }
67911 :
67912 0 : if ( p_parent != NULL )
67913 : {
67914 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67915 : {
67916 0 : if ( p_parent->isInMemoryPool() == false )
67917 : {
67918 0 : std::cout << "SgBackspaceStatement :: ";
67919 0 : std::cout << " p_parent is not in memory pool of ";
67920 0 : std::cout << p_parent->class_name() << std::endl;
67921 : }
67922 : }
67923 : else
67924 : {
67925 0 : std::cout << "SgBackspaceStatement :: " << std::flush;
67926 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
67927 0 : std::cout << " not valid " << std::endl;
67928 : }
67929 : }
67930 :
67931 :
67932 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
67933 :
67934 0 : }
67935 :
67936 :
67937 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
67938 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
67939 : bool
67940 0 : SgBackspaceStatement::isInMemoryPool ()
67941 : {
67942 0 : typedef unsigned char* TestType;
67943 :
67944 0 : bool found = false;
67945 :
67946 0 : ROSE_ASSERT(this != NULL);
67947 :
67948 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
67949 :
67950 0 : TestType tested = (TestType) ( this ) ;
67951 :
67952 0 : std::vector < unsigned char* > :: const_iterator block = SgBackspaceStatement::pools.begin();
67953 :
67954 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
67955 : // while (found == false && block < Memory_Block_List.end())
67956 0 : while ( (found == false) && (block != SgBackspaceStatement::pools.end()) )
67957 : {
67958 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgBackspaceStatement::pool_size * sizeof(SgBackspaceStatement) ) ) ;
67959 0 : ++block;
67960 : }
67961 :
67962 : // Special handling for static data
67963 :
67964 :
67965 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
67966 0 : ROSE_ASSERT(found == true);
67967 :
67968 0 : return found;
67969 : }
67970 : /* #line 67971 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
67971 :
67972 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
67973 :
67974 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
67975 :
67976 : /* #line 67977 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
67977 :
67978 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
67979 :
67980 : void
67981 0 : SgRewindStatement::checkDataMemberPointersIfInMemoryPool()
67982 : {
67983 : // ------------ checking pointers of SgRewindStatement -------------------
67984 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
67985 :
67986 0 : if ( p_io_stmt_list != NULL )
67987 : {
67988 0 : if ( p_io_stmt_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
67989 : {
67990 0 : if ( p_io_stmt_list->isInMemoryPool() == false )
67991 : {
67992 0 : std::cout << "SgRewindStatement :: ";
67993 0 : std::cout << " p_io_stmt_list is not in memory pool of ";
67994 0 : std::cout << p_io_stmt_list->class_name() << std::endl;
67995 : }
67996 : }
67997 : else
67998 : {
67999 0 : std::cout << "SgRewindStatement :: " << std::flush;
68000 0 : std::cout << "SgExprListExp* p_io_stmt_list = " << p_io_stmt_list << " --> " << std::flush;
68001 0 : std::cout << " not valid " << std::endl;
68002 : }
68003 : }
68004 :
68005 0 : if ( p_unit != NULL )
68006 : {
68007 0 : if ( p_unit->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68008 : {
68009 0 : if ( p_unit->isInMemoryPool() == false )
68010 : {
68011 0 : std::cout << "SgRewindStatement :: ";
68012 0 : std::cout << " p_unit is not in memory pool of ";
68013 0 : std::cout << p_unit->class_name() << std::endl;
68014 : }
68015 : }
68016 : else
68017 : {
68018 0 : std::cout << "SgRewindStatement :: " << std::flush;
68019 0 : std::cout << "SgExpression* p_unit = " << p_unit << " --> " << std::flush;
68020 0 : std::cout << " not valid " << std::endl;
68021 : }
68022 : }
68023 :
68024 0 : if ( p_iostat != NULL )
68025 : {
68026 0 : if ( p_iostat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68027 : {
68028 0 : if ( p_iostat->isInMemoryPool() == false )
68029 : {
68030 0 : std::cout << "SgRewindStatement :: ";
68031 0 : std::cout << " p_iostat is not in memory pool of ";
68032 0 : std::cout << p_iostat->class_name() << std::endl;
68033 : }
68034 : }
68035 : else
68036 : {
68037 0 : std::cout << "SgRewindStatement :: " << std::flush;
68038 0 : std::cout << "SgExpression* p_iostat = " << p_iostat << " --> " << std::flush;
68039 0 : std::cout << " not valid " << std::endl;
68040 : }
68041 : }
68042 :
68043 0 : if ( p_err != NULL )
68044 : {
68045 0 : if ( p_err->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68046 : {
68047 0 : if ( p_err->isInMemoryPool() == false )
68048 : {
68049 0 : std::cout << "SgRewindStatement :: ";
68050 0 : std::cout << " p_err is not in memory pool of ";
68051 0 : std::cout << p_err->class_name() << std::endl;
68052 : }
68053 : }
68054 : else
68055 : {
68056 0 : std::cout << "SgRewindStatement :: " << std::flush;
68057 0 : std::cout << "SgExpression* p_err = " << p_err << " --> " << std::flush;
68058 0 : std::cout << " not valid " << std::endl;
68059 : }
68060 : }
68061 :
68062 0 : if ( p_iomsg != NULL )
68063 : {
68064 0 : if ( p_iomsg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68065 : {
68066 0 : if ( p_iomsg->isInMemoryPool() == false )
68067 : {
68068 0 : std::cout << "SgRewindStatement :: ";
68069 0 : std::cout << " p_iomsg is not in memory pool of ";
68070 0 : std::cout << p_iomsg->class_name() << std::endl;
68071 : }
68072 : }
68073 : else
68074 : {
68075 0 : std::cout << "SgRewindStatement :: " << std::flush;
68076 0 : std::cout << "SgExpression* p_iomsg = " << p_iomsg << " --> " << std::flush;
68077 0 : std::cout << " not valid " << std::endl;
68078 : }
68079 : }
68080 :
68081 0 : if ( p_numeric_label != NULL )
68082 : {
68083 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68084 : {
68085 0 : if ( p_numeric_label->isInMemoryPool() == false )
68086 : {
68087 0 : std::cout << "SgRewindStatement :: ";
68088 0 : std::cout << " p_numeric_label is not in memory pool of ";
68089 0 : std::cout << p_numeric_label->class_name() << std::endl;
68090 : }
68091 : }
68092 : else
68093 : {
68094 0 : std::cout << "SgRewindStatement :: " << std::flush;
68095 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
68096 0 : std::cout << " not valid " << std::endl;
68097 : }
68098 : }
68099 :
68100 0 : if ( p_startOfConstruct != NULL )
68101 : {
68102 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68103 : {
68104 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
68105 : {
68106 0 : std::cout << "SgRewindStatement :: ";
68107 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
68108 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
68109 : }
68110 : }
68111 : else
68112 : {
68113 0 : std::cout << "SgRewindStatement :: " << std::flush;
68114 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
68115 0 : std::cout << " not valid " << std::endl;
68116 : }
68117 : }
68118 :
68119 0 : if ( p_endOfConstruct != NULL )
68120 : {
68121 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68122 : {
68123 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
68124 : {
68125 0 : std::cout << "SgRewindStatement :: ";
68126 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
68127 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
68128 : }
68129 : }
68130 : else
68131 : {
68132 0 : std::cout << "SgRewindStatement :: " << std::flush;
68133 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
68134 0 : std::cout << " not valid " << std::endl;
68135 : }
68136 : }
68137 :
68138 0 : if ( p_parent != NULL )
68139 : {
68140 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68141 : {
68142 0 : if ( p_parent->isInMemoryPool() == false )
68143 : {
68144 0 : std::cout << "SgRewindStatement :: ";
68145 0 : std::cout << " p_parent is not in memory pool of ";
68146 0 : std::cout << p_parent->class_name() << std::endl;
68147 : }
68148 : }
68149 : else
68150 : {
68151 0 : std::cout << "SgRewindStatement :: " << std::flush;
68152 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
68153 0 : std::cout << " not valid " << std::endl;
68154 : }
68155 : }
68156 :
68157 :
68158 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
68159 :
68160 0 : }
68161 :
68162 :
68163 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
68164 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
68165 : bool
68166 0 : SgRewindStatement::isInMemoryPool ()
68167 : {
68168 0 : typedef unsigned char* TestType;
68169 :
68170 0 : bool found = false;
68171 :
68172 0 : ROSE_ASSERT(this != NULL);
68173 :
68174 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
68175 :
68176 0 : TestType tested = (TestType) ( this ) ;
68177 :
68178 0 : std::vector < unsigned char* > :: const_iterator block = SgRewindStatement::pools.begin();
68179 :
68180 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
68181 : // while (found == false && block < Memory_Block_List.end())
68182 0 : while ( (found == false) && (block != SgRewindStatement::pools.end()) )
68183 : {
68184 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgRewindStatement::pool_size * sizeof(SgRewindStatement) ) ) ;
68185 0 : ++block;
68186 : }
68187 :
68188 : // Special handling for static data
68189 :
68190 :
68191 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
68192 0 : ROSE_ASSERT(found == true);
68193 :
68194 0 : return found;
68195 : }
68196 : /* #line 68197 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
68197 :
68198 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
68199 :
68200 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
68201 :
68202 : /* #line 68203 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
68203 :
68204 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
68205 :
68206 : void
68207 0 : SgEndfileStatement::checkDataMemberPointersIfInMemoryPool()
68208 : {
68209 : // ------------ checking pointers of SgEndfileStatement -------------------
68210 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
68211 :
68212 0 : if ( p_io_stmt_list != NULL )
68213 : {
68214 0 : if ( p_io_stmt_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68215 : {
68216 0 : if ( p_io_stmt_list->isInMemoryPool() == false )
68217 : {
68218 0 : std::cout << "SgEndfileStatement :: ";
68219 0 : std::cout << " p_io_stmt_list is not in memory pool of ";
68220 0 : std::cout << p_io_stmt_list->class_name() << std::endl;
68221 : }
68222 : }
68223 : else
68224 : {
68225 0 : std::cout << "SgEndfileStatement :: " << std::flush;
68226 0 : std::cout << "SgExprListExp* p_io_stmt_list = " << p_io_stmt_list << " --> " << std::flush;
68227 0 : std::cout << " not valid " << std::endl;
68228 : }
68229 : }
68230 :
68231 0 : if ( p_unit != NULL )
68232 : {
68233 0 : if ( p_unit->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68234 : {
68235 0 : if ( p_unit->isInMemoryPool() == false )
68236 : {
68237 0 : std::cout << "SgEndfileStatement :: ";
68238 0 : std::cout << " p_unit is not in memory pool of ";
68239 0 : std::cout << p_unit->class_name() << std::endl;
68240 : }
68241 : }
68242 : else
68243 : {
68244 0 : std::cout << "SgEndfileStatement :: " << std::flush;
68245 0 : std::cout << "SgExpression* p_unit = " << p_unit << " --> " << std::flush;
68246 0 : std::cout << " not valid " << std::endl;
68247 : }
68248 : }
68249 :
68250 0 : if ( p_iostat != NULL )
68251 : {
68252 0 : if ( p_iostat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68253 : {
68254 0 : if ( p_iostat->isInMemoryPool() == false )
68255 : {
68256 0 : std::cout << "SgEndfileStatement :: ";
68257 0 : std::cout << " p_iostat is not in memory pool of ";
68258 0 : std::cout << p_iostat->class_name() << std::endl;
68259 : }
68260 : }
68261 : else
68262 : {
68263 0 : std::cout << "SgEndfileStatement :: " << std::flush;
68264 0 : std::cout << "SgExpression* p_iostat = " << p_iostat << " --> " << std::flush;
68265 0 : std::cout << " not valid " << std::endl;
68266 : }
68267 : }
68268 :
68269 0 : if ( p_err != NULL )
68270 : {
68271 0 : if ( p_err->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68272 : {
68273 0 : if ( p_err->isInMemoryPool() == false )
68274 : {
68275 0 : std::cout << "SgEndfileStatement :: ";
68276 0 : std::cout << " p_err is not in memory pool of ";
68277 0 : std::cout << p_err->class_name() << std::endl;
68278 : }
68279 : }
68280 : else
68281 : {
68282 0 : std::cout << "SgEndfileStatement :: " << std::flush;
68283 0 : std::cout << "SgExpression* p_err = " << p_err << " --> " << std::flush;
68284 0 : std::cout << " not valid " << std::endl;
68285 : }
68286 : }
68287 :
68288 0 : if ( p_iomsg != NULL )
68289 : {
68290 0 : if ( p_iomsg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68291 : {
68292 0 : if ( p_iomsg->isInMemoryPool() == false )
68293 : {
68294 0 : std::cout << "SgEndfileStatement :: ";
68295 0 : std::cout << " p_iomsg is not in memory pool of ";
68296 0 : std::cout << p_iomsg->class_name() << std::endl;
68297 : }
68298 : }
68299 : else
68300 : {
68301 0 : std::cout << "SgEndfileStatement :: " << std::flush;
68302 0 : std::cout << "SgExpression* p_iomsg = " << p_iomsg << " --> " << std::flush;
68303 0 : std::cout << " not valid " << std::endl;
68304 : }
68305 : }
68306 :
68307 0 : if ( p_numeric_label != NULL )
68308 : {
68309 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68310 : {
68311 0 : if ( p_numeric_label->isInMemoryPool() == false )
68312 : {
68313 0 : std::cout << "SgEndfileStatement :: ";
68314 0 : std::cout << " p_numeric_label is not in memory pool of ";
68315 0 : std::cout << p_numeric_label->class_name() << std::endl;
68316 : }
68317 : }
68318 : else
68319 : {
68320 0 : std::cout << "SgEndfileStatement :: " << std::flush;
68321 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
68322 0 : std::cout << " not valid " << std::endl;
68323 : }
68324 : }
68325 :
68326 0 : if ( p_startOfConstruct != NULL )
68327 : {
68328 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68329 : {
68330 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
68331 : {
68332 0 : std::cout << "SgEndfileStatement :: ";
68333 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
68334 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
68335 : }
68336 : }
68337 : else
68338 : {
68339 0 : std::cout << "SgEndfileStatement :: " << std::flush;
68340 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
68341 0 : std::cout << " not valid " << std::endl;
68342 : }
68343 : }
68344 :
68345 0 : if ( p_endOfConstruct != NULL )
68346 : {
68347 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68348 : {
68349 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
68350 : {
68351 0 : std::cout << "SgEndfileStatement :: ";
68352 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
68353 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
68354 : }
68355 : }
68356 : else
68357 : {
68358 0 : std::cout << "SgEndfileStatement :: " << std::flush;
68359 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
68360 0 : std::cout << " not valid " << std::endl;
68361 : }
68362 : }
68363 :
68364 0 : if ( p_parent != NULL )
68365 : {
68366 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68367 : {
68368 0 : if ( p_parent->isInMemoryPool() == false )
68369 : {
68370 0 : std::cout << "SgEndfileStatement :: ";
68371 0 : std::cout << " p_parent is not in memory pool of ";
68372 0 : std::cout << p_parent->class_name() << std::endl;
68373 : }
68374 : }
68375 : else
68376 : {
68377 0 : std::cout << "SgEndfileStatement :: " << std::flush;
68378 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
68379 0 : std::cout << " not valid " << std::endl;
68380 : }
68381 : }
68382 :
68383 :
68384 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
68385 :
68386 0 : }
68387 :
68388 :
68389 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
68390 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
68391 : bool
68392 0 : SgEndfileStatement::isInMemoryPool ()
68393 : {
68394 0 : typedef unsigned char* TestType;
68395 :
68396 0 : bool found = false;
68397 :
68398 0 : ROSE_ASSERT(this != NULL);
68399 :
68400 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
68401 :
68402 0 : TestType tested = (TestType) ( this ) ;
68403 :
68404 0 : std::vector < unsigned char* > :: const_iterator block = SgEndfileStatement::pools.begin();
68405 :
68406 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
68407 : // while (found == false && block < Memory_Block_List.end())
68408 0 : while ( (found == false) && (block != SgEndfileStatement::pools.end()) )
68409 : {
68410 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgEndfileStatement::pool_size * sizeof(SgEndfileStatement) ) ) ;
68411 0 : ++block;
68412 : }
68413 :
68414 : // Special handling for static data
68415 :
68416 :
68417 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
68418 0 : ROSE_ASSERT(found == true);
68419 :
68420 0 : return found;
68421 : }
68422 : /* #line 68423 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
68423 :
68424 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
68425 :
68426 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
68427 :
68428 : /* #line 68429 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
68429 :
68430 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
68431 :
68432 : void
68433 0 : SgWaitStatement::checkDataMemberPointersIfInMemoryPool()
68434 : {
68435 : // ------------ checking pointers of SgWaitStatement -------------------
68436 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
68437 :
68438 0 : if ( p_io_stmt_list != NULL )
68439 : {
68440 0 : if ( p_io_stmt_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68441 : {
68442 0 : if ( p_io_stmt_list->isInMemoryPool() == false )
68443 : {
68444 0 : std::cout << "SgWaitStatement :: ";
68445 0 : std::cout << " p_io_stmt_list is not in memory pool of ";
68446 0 : std::cout << p_io_stmt_list->class_name() << std::endl;
68447 : }
68448 : }
68449 : else
68450 : {
68451 0 : std::cout << "SgWaitStatement :: " << std::flush;
68452 0 : std::cout << "SgExprListExp* p_io_stmt_list = " << p_io_stmt_list << " --> " << std::flush;
68453 0 : std::cout << " not valid " << std::endl;
68454 : }
68455 : }
68456 :
68457 0 : if ( p_unit != NULL )
68458 : {
68459 0 : if ( p_unit->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68460 : {
68461 0 : if ( p_unit->isInMemoryPool() == false )
68462 : {
68463 0 : std::cout << "SgWaitStatement :: ";
68464 0 : std::cout << " p_unit is not in memory pool of ";
68465 0 : std::cout << p_unit->class_name() << std::endl;
68466 : }
68467 : }
68468 : else
68469 : {
68470 0 : std::cout << "SgWaitStatement :: " << std::flush;
68471 0 : std::cout << "SgExpression* p_unit = " << p_unit << " --> " << std::flush;
68472 0 : std::cout << " not valid " << std::endl;
68473 : }
68474 : }
68475 :
68476 0 : if ( p_iostat != NULL )
68477 : {
68478 0 : if ( p_iostat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68479 : {
68480 0 : if ( p_iostat->isInMemoryPool() == false )
68481 : {
68482 0 : std::cout << "SgWaitStatement :: ";
68483 0 : std::cout << " p_iostat is not in memory pool of ";
68484 0 : std::cout << p_iostat->class_name() << std::endl;
68485 : }
68486 : }
68487 : else
68488 : {
68489 0 : std::cout << "SgWaitStatement :: " << std::flush;
68490 0 : std::cout << "SgExpression* p_iostat = " << p_iostat << " --> " << std::flush;
68491 0 : std::cout << " not valid " << std::endl;
68492 : }
68493 : }
68494 :
68495 0 : if ( p_err != NULL )
68496 : {
68497 0 : if ( p_err->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68498 : {
68499 0 : if ( p_err->isInMemoryPool() == false )
68500 : {
68501 0 : std::cout << "SgWaitStatement :: ";
68502 0 : std::cout << " p_err is not in memory pool of ";
68503 0 : std::cout << p_err->class_name() << std::endl;
68504 : }
68505 : }
68506 : else
68507 : {
68508 0 : std::cout << "SgWaitStatement :: " << std::flush;
68509 0 : std::cout << "SgExpression* p_err = " << p_err << " --> " << std::flush;
68510 0 : std::cout << " not valid " << std::endl;
68511 : }
68512 : }
68513 :
68514 0 : if ( p_iomsg != NULL )
68515 : {
68516 0 : if ( p_iomsg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68517 : {
68518 0 : if ( p_iomsg->isInMemoryPool() == false )
68519 : {
68520 0 : std::cout << "SgWaitStatement :: ";
68521 0 : std::cout << " p_iomsg is not in memory pool of ";
68522 0 : std::cout << p_iomsg->class_name() << std::endl;
68523 : }
68524 : }
68525 : else
68526 : {
68527 0 : std::cout << "SgWaitStatement :: " << std::flush;
68528 0 : std::cout << "SgExpression* p_iomsg = " << p_iomsg << " --> " << std::flush;
68529 0 : std::cout << " not valid " << std::endl;
68530 : }
68531 : }
68532 :
68533 0 : if ( p_numeric_label != NULL )
68534 : {
68535 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68536 : {
68537 0 : if ( p_numeric_label->isInMemoryPool() == false )
68538 : {
68539 0 : std::cout << "SgWaitStatement :: ";
68540 0 : std::cout << " p_numeric_label is not in memory pool of ";
68541 0 : std::cout << p_numeric_label->class_name() << std::endl;
68542 : }
68543 : }
68544 : else
68545 : {
68546 0 : std::cout << "SgWaitStatement :: " << std::flush;
68547 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
68548 0 : std::cout << " not valid " << std::endl;
68549 : }
68550 : }
68551 :
68552 0 : if ( p_startOfConstruct != NULL )
68553 : {
68554 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68555 : {
68556 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
68557 : {
68558 0 : std::cout << "SgWaitStatement :: ";
68559 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
68560 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
68561 : }
68562 : }
68563 : else
68564 : {
68565 0 : std::cout << "SgWaitStatement :: " << std::flush;
68566 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
68567 0 : std::cout << " not valid " << std::endl;
68568 : }
68569 : }
68570 :
68571 0 : if ( p_endOfConstruct != NULL )
68572 : {
68573 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68574 : {
68575 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
68576 : {
68577 0 : std::cout << "SgWaitStatement :: ";
68578 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
68579 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
68580 : }
68581 : }
68582 : else
68583 : {
68584 0 : std::cout << "SgWaitStatement :: " << std::flush;
68585 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
68586 0 : std::cout << " not valid " << std::endl;
68587 : }
68588 : }
68589 :
68590 0 : if ( p_parent != NULL )
68591 : {
68592 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68593 : {
68594 0 : if ( p_parent->isInMemoryPool() == false )
68595 : {
68596 0 : std::cout << "SgWaitStatement :: ";
68597 0 : std::cout << " p_parent is not in memory pool of ";
68598 0 : std::cout << p_parent->class_name() << std::endl;
68599 : }
68600 : }
68601 : else
68602 : {
68603 0 : std::cout << "SgWaitStatement :: " << std::flush;
68604 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
68605 0 : std::cout << " not valid " << std::endl;
68606 : }
68607 : }
68608 :
68609 :
68610 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
68611 :
68612 0 : }
68613 :
68614 :
68615 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
68616 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
68617 : bool
68618 0 : SgWaitStatement::isInMemoryPool ()
68619 : {
68620 0 : typedef unsigned char* TestType;
68621 :
68622 0 : bool found = false;
68623 :
68624 0 : ROSE_ASSERT(this != NULL);
68625 :
68626 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
68627 :
68628 0 : TestType tested = (TestType) ( this ) ;
68629 :
68630 0 : std::vector < unsigned char* > :: const_iterator block = SgWaitStatement::pools.begin();
68631 :
68632 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
68633 : // while (found == false && block < Memory_Block_List.end())
68634 0 : while ( (found == false) && (block != SgWaitStatement::pools.end()) )
68635 : {
68636 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgWaitStatement::pool_size * sizeof(SgWaitStatement) ) ) ;
68637 0 : ++block;
68638 : }
68639 :
68640 : // Special handling for static data
68641 :
68642 :
68643 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
68644 0 : ROSE_ASSERT(found == true);
68645 :
68646 0 : return found;
68647 : }
68648 : /* #line 68649 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
68649 :
68650 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
68651 :
68652 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
68653 :
68654 : /* #line 68655 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
68655 :
68656 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
68657 :
68658 : void
68659 0 : SgWhereStatement::checkDataMemberPointersIfInMemoryPool()
68660 : {
68661 : // ------------ checking pointers of SgWhereStatement -------------------
68662 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
68663 :
68664 0 : if ( p_condition != NULL )
68665 : {
68666 0 : if ( p_condition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68667 : {
68668 0 : if ( p_condition->isInMemoryPool() == false )
68669 : {
68670 0 : std::cout << "SgWhereStatement :: ";
68671 0 : std::cout << " p_condition is not in memory pool of ";
68672 0 : std::cout << p_condition->class_name() << std::endl;
68673 : }
68674 : }
68675 : else
68676 : {
68677 0 : std::cout << "SgWhereStatement :: " << std::flush;
68678 0 : std::cout << "SgExpression* p_condition = " << p_condition << " --> " << std::flush;
68679 0 : std::cout << " not valid " << std::endl;
68680 : }
68681 : }
68682 :
68683 0 : if ( p_body != NULL )
68684 : {
68685 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68686 : {
68687 0 : if ( p_body->isInMemoryPool() == false )
68688 : {
68689 0 : std::cout << "SgWhereStatement :: ";
68690 0 : std::cout << " p_body is not in memory pool of ";
68691 0 : std::cout << p_body->class_name() << std::endl;
68692 : }
68693 : }
68694 : else
68695 : {
68696 0 : std::cout << "SgWhereStatement :: " << std::flush;
68697 0 : std::cout << "SgBasicBlock* p_body = " << p_body << " --> " << std::flush;
68698 0 : std::cout << " not valid " << std::endl;
68699 : }
68700 : }
68701 :
68702 0 : if ( p_elsewhere != NULL )
68703 : {
68704 0 : if ( p_elsewhere->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68705 : {
68706 0 : if ( p_elsewhere->isInMemoryPool() == false )
68707 : {
68708 0 : std::cout << "SgWhereStatement :: ";
68709 0 : std::cout << " p_elsewhere is not in memory pool of ";
68710 0 : std::cout << p_elsewhere->class_name() << std::endl;
68711 : }
68712 : }
68713 : else
68714 : {
68715 0 : std::cout << "SgWhereStatement :: " << std::flush;
68716 0 : std::cout << "SgElseWhereStatement* p_elsewhere = " << p_elsewhere << " --> " << std::flush;
68717 0 : std::cout << " not valid " << std::endl;
68718 : }
68719 : }
68720 :
68721 0 : if ( p_end_numeric_label != NULL )
68722 : {
68723 0 : if ( p_end_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68724 : {
68725 0 : if ( p_end_numeric_label->isInMemoryPool() == false )
68726 : {
68727 0 : std::cout << "SgWhereStatement :: ";
68728 0 : std::cout << " p_end_numeric_label is not in memory pool of ";
68729 0 : std::cout << p_end_numeric_label->class_name() << std::endl;
68730 : }
68731 : }
68732 : else
68733 : {
68734 0 : std::cout << "SgWhereStatement :: " << std::flush;
68735 0 : std::cout << "SgLabelRefExp* p_end_numeric_label = " << p_end_numeric_label << " --> " << std::flush;
68736 0 : std::cout << " not valid " << std::endl;
68737 : }
68738 : }
68739 :
68740 0 : if ( p_numeric_label != NULL )
68741 : {
68742 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68743 : {
68744 0 : if ( p_numeric_label->isInMemoryPool() == false )
68745 : {
68746 0 : std::cout << "SgWhereStatement :: ";
68747 0 : std::cout << " p_numeric_label is not in memory pool of ";
68748 0 : std::cout << p_numeric_label->class_name() << std::endl;
68749 : }
68750 : }
68751 : else
68752 : {
68753 0 : std::cout << "SgWhereStatement :: " << std::flush;
68754 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
68755 0 : std::cout << " not valid " << std::endl;
68756 : }
68757 : }
68758 :
68759 0 : if ( p_startOfConstruct != NULL )
68760 : {
68761 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68762 : {
68763 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
68764 : {
68765 0 : std::cout << "SgWhereStatement :: ";
68766 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
68767 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
68768 : }
68769 : }
68770 : else
68771 : {
68772 0 : std::cout << "SgWhereStatement :: " << std::flush;
68773 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
68774 0 : std::cout << " not valid " << std::endl;
68775 : }
68776 : }
68777 :
68778 0 : if ( p_endOfConstruct != NULL )
68779 : {
68780 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68781 : {
68782 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
68783 : {
68784 0 : std::cout << "SgWhereStatement :: ";
68785 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
68786 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
68787 : }
68788 : }
68789 : else
68790 : {
68791 0 : std::cout << "SgWhereStatement :: " << std::flush;
68792 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
68793 0 : std::cout << " not valid " << std::endl;
68794 : }
68795 : }
68796 :
68797 0 : if ( p_parent != NULL )
68798 : {
68799 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68800 : {
68801 0 : if ( p_parent->isInMemoryPool() == false )
68802 : {
68803 0 : std::cout << "SgWhereStatement :: ";
68804 0 : std::cout << " p_parent is not in memory pool of ";
68805 0 : std::cout << p_parent->class_name() << std::endl;
68806 : }
68807 : }
68808 : else
68809 : {
68810 0 : std::cout << "SgWhereStatement :: " << std::flush;
68811 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
68812 0 : std::cout << " not valid " << std::endl;
68813 : }
68814 : }
68815 :
68816 :
68817 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
68818 :
68819 0 : }
68820 :
68821 :
68822 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
68823 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
68824 : bool
68825 0 : SgWhereStatement::isInMemoryPool ()
68826 : {
68827 0 : typedef unsigned char* TestType;
68828 :
68829 0 : bool found = false;
68830 :
68831 0 : ROSE_ASSERT(this != NULL);
68832 :
68833 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
68834 :
68835 0 : TestType tested = (TestType) ( this ) ;
68836 :
68837 0 : std::vector < unsigned char* > :: const_iterator block = SgWhereStatement::pools.begin();
68838 :
68839 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
68840 : // while (found == false && block < Memory_Block_List.end())
68841 0 : while ( (found == false) && (block != SgWhereStatement::pools.end()) )
68842 : {
68843 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgWhereStatement::pool_size * sizeof(SgWhereStatement) ) ) ;
68844 0 : ++block;
68845 : }
68846 :
68847 : // Special handling for static data
68848 :
68849 :
68850 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
68851 0 : ROSE_ASSERT(found == true);
68852 :
68853 0 : return found;
68854 : }
68855 : /* #line 68856 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
68856 :
68857 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
68858 :
68859 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
68860 :
68861 : /* #line 68862 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
68862 :
68863 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
68864 :
68865 : void
68866 0 : SgElseWhereStatement::checkDataMemberPointersIfInMemoryPool()
68867 : {
68868 : // ------------ checking pointers of SgElseWhereStatement -------------------
68869 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
68870 :
68871 0 : if ( p_condition != NULL )
68872 : {
68873 0 : if ( p_condition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68874 : {
68875 0 : if ( p_condition->isInMemoryPool() == false )
68876 : {
68877 0 : std::cout << "SgElseWhereStatement :: ";
68878 0 : std::cout << " p_condition is not in memory pool of ";
68879 0 : std::cout << p_condition->class_name() << std::endl;
68880 : }
68881 : }
68882 : else
68883 : {
68884 0 : std::cout << "SgElseWhereStatement :: " << std::flush;
68885 0 : std::cout << "SgExpression* p_condition = " << p_condition << " --> " << std::flush;
68886 0 : std::cout << " not valid " << std::endl;
68887 : }
68888 : }
68889 :
68890 0 : if ( p_body != NULL )
68891 : {
68892 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68893 : {
68894 0 : if ( p_body->isInMemoryPool() == false )
68895 : {
68896 0 : std::cout << "SgElseWhereStatement :: ";
68897 0 : std::cout << " p_body is not in memory pool of ";
68898 0 : std::cout << p_body->class_name() << std::endl;
68899 : }
68900 : }
68901 : else
68902 : {
68903 0 : std::cout << "SgElseWhereStatement :: " << std::flush;
68904 0 : std::cout << "SgBasicBlock* p_body = " << p_body << " --> " << std::flush;
68905 0 : std::cout << " not valid " << std::endl;
68906 : }
68907 : }
68908 :
68909 0 : if ( p_elsewhere != NULL )
68910 : {
68911 0 : if ( p_elsewhere->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68912 : {
68913 0 : if ( p_elsewhere->isInMemoryPool() == false )
68914 : {
68915 0 : std::cout << "SgElseWhereStatement :: ";
68916 0 : std::cout << " p_elsewhere is not in memory pool of ";
68917 0 : std::cout << p_elsewhere->class_name() << std::endl;
68918 : }
68919 : }
68920 : else
68921 : {
68922 0 : std::cout << "SgElseWhereStatement :: " << std::flush;
68923 0 : std::cout << "SgElseWhereStatement* p_elsewhere = " << p_elsewhere << " --> " << std::flush;
68924 0 : std::cout << " not valid " << std::endl;
68925 : }
68926 : }
68927 :
68928 0 : if ( p_numeric_label != NULL )
68929 : {
68930 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68931 : {
68932 0 : if ( p_numeric_label->isInMemoryPool() == false )
68933 : {
68934 0 : std::cout << "SgElseWhereStatement :: ";
68935 0 : std::cout << " p_numeric_label is not in memory pool of ";
68936 0 : std::cout << p_numeric_label->class_name() << std::endl;
68937 : }
68938 : }
68939 : else
68940 : {
68941 0 : std::cout << "SgElseWhereStatement :: " << std::flush;
68942 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
68943 0 : std::cout << " not valid " << std::endl;
68944 : }
68945 : }
68946 :
68947 0 : if ( p_startOfConstruct != NULL )
68948 : {
68949 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68950 : {
68951 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
68952 : {
68953 0 : std::cout << "SgElseWhereStatement :: ";
68954 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
68955 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
68956 : }
68957 : }
68958 : else
68959 : {
68960 0 : std::cout << "SgElseWhereStatement :: " << std::flush;
68961 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
68962 0 : std::cout << " not valid " << std::endl;
68963 : }
68964 : }
68965 :
68966 0 : if ( p_endOfConstruct != NULL )
68967 : {
68968 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68969 : {
68970 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
68971 : {
68972 0 : std::cout << "SgElseWhereStatement :: ";
68973 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
68974 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
68975 : }
68976 : }
68977 : else
68978 : {
68979 0 : std::cout << "SgElseWhereStatement :: " << std::flush;
68980 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
68981 0 : std::cout << " not valid " << std::endl;
68982 : }
68983 : }
68984 :
68985 0 : if ( p_parent != NULL )
68986 : {
68987 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
68988 : {
68989 0 : if ( p_parent->isInMemoryPool() == false )
68990 : {
68991 0 : std::cout << "SgElseWhereStatement :: ";
68992 0 : std::cout << " p_parent is not in memory pool of ";
68993 0 : std::cout << p_parent->class_name() << std::endl;
68994 : }
68995 : }
68996 : else
68997 : {
68998 0 : std::cout << "SgElseWhereStatement :: " << std::flush;
68999 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
69000 0 : std::cout << " not valid " << std::endl;
69001 : }
69002 : }
69003 :
69004 :
69005 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69006 :
69007 0 : }
69008 :
69009 :
69010 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
69011 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
69012 : bool
69013 0 : SgElseWhereStatement::isInMemoryPool ()
69014 : {
69015 0 : typedef unsigned char* TestType;
69016 :
69017 0 : bool found = false;
69018 :
69019 0 : ROSE_ASSERT(this != NULL);
69020 :
69021 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
69022 :
69023 0 : TestType tested = (TestType) ( this ) ;
69024 :
69025 0 : std::vector < unsigned char* > :: const_iterator block = SgElseWhereStatement::pools.begin();
69026 :
69027 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
69028 : // while (found == false && block < Memory_Block_List.end())
69029 0 : while ( (found == false) && (block != SgElseWhereStatement::pools.end()) )
69030 : {
69031 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgElseWhereStatement::pool_size * sizeof(SgElseWhereStatement) ) ) ;
69032 0 : ++block;
69033 : }
69034 :
69035 : // Special handling for static data
69036 :
69037 :
69038 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
69039 0 : ROSE_ASSERT(found == true);
69040 :
69041 0 : return found;
69042 : }
69043 : /* #line 69044 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
69044 :
69045 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
69046 :
69047 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69048 :
69049 : /* #line 69050 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
69050 :
69051 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69052 :
69053 : void
69054 0 : SgNullifyStatement::checkDataMemberPointersIfInMemoryPool()
69055 : {
69056 : // ------------ checking pointers of SgNullifyStatement -------------------
69057 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
69058 :
69059 0 : if ( p_pointer_list != NULL )
69060 : {
69061 0 : if ( p_pointer_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69062 : {
69063 0 : if ( p_pointer_list->isInMemoryPool() == false )
69064 : {
69065 0 : std::cout << "SgNullifyStatement :: ";
69066 0 : std::cout << " p_pointer_list is not in memory pool of ";
69067 0 : std::cout << p_pointer_list->class_name() << std::endl;
69068 : }
69069 : }
69070 : else
69071 : {
69072 0 : std::cout << "SgNullifyStatement :: " << std::flush;
69073 0 : std::cout << "SgExprListExp* p_pointer_list = " << p_pointer_list << " --> " << std::flush;
69074 0 : std::cout << " not valid " << std::endl;
69075 : }
69076 : }
69077 :
69078 0 : if ( p_numeric_label != NULL )
69079 : {
69080 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69081 : {
69082 0 : if ( p_numeric_label->isInMemoryPool() == false )
69083 : {
69084 0 : std::cout << "SgNullifyStatement :: ";
69085 0 : std::cout << " p_numeric_label is not in memory pool of ";
69086 0 : std::cout << p_numeric_label->class_name() << std::endl;
69087 : }
69088 : }
69089 : else
69090 : {
69091 0 : std::cout << "SgNullifyStatement :: " << std::flush;
69092 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
69093 0 : std::cout << " not valid " << std::endl;
69094 : }
69095 : }
69096 :
69097 0 : if ( p_startOfConstruct != NULL )
69098 : {
69099 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69100 : {
69101 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
69102 : {
69103 0 : std::cout << "SgNullifyStatement :: ";
69104 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
69105 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
69106 : }
69107 : }
69108 : else
69109 : {
69110 0 : std::cout << "SgNullifyStatement :: " << std::flush;
69111 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
69112 0 : std::cout << " not valid " << std::endl;
69113 : }
69114 : }
69115 :
69116 0 : if ( p_endOfConstruct != NULL )
69117 : {
69118 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69119 : {
69120 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
69121 : {
69122 0 : std::cout << "SgNullifyStatement :: ";
69123 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
69124 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
69125 : }
69126 : }
69127 : else
69128 : {
69129 0 : std::cout << "SgNullifyStatement :: " << std::flush;
69130 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
69131 0 : std::cout << " not valid " << std::endl;
69132 : }
69133 : }
69134 :
69135 0 : if ( p_parent != NULL )
69136 : {
69137 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69138 : {
69139 0 : if ( p_parent->isInMemoryPool() == false )
69140 : {
69141 0 : std::cout << "SgNullifyStatement :: ";
69142 0 : std::cout << " p_parent is not in memory pool of ";
69143 0 : std::cout << p_parent->class_name() << std::endl;
69144 : }
69145 : }
69146 : else
69147 : {
69148 0 : std::cout << "SgNullifyStatement :: " << std::flush;
69149 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
69150 0 : std::cout << " not valid " << std::endl;
69151 : }
69152 : }
69153 :
69154 :
69155 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69156 :
69157 0 : }
69158 :
69159 :
69160 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
69161 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
69162 : bool
69163 0 : SgNullifyStatement::isInMemoryPool ()
69164 : {
69165 0 : typedef unsigned char* TestType;
69166 :
69167 0 : bool found = false;
69168 :
69169 0 : ROSE_ASSERT(this != NULL);
69170 :
69171 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
69172 :
69173 0 : TestType tested = (TestType) ( this ) ;
69174 :
69175 0 : std::vector < unsigned char* > :: const_iterator block = SgNullifyStatement::pools.begin();
69176 :
69177 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
69178 : // while (found == false && block < Memory_Block_List.end())
69179 0 : while ( (found == false) && (block != SgNullifyStatement::pools.end()) )
69180 : {
69181 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNullifyStatement::pool_size * sizeof(SgNullifyStatement) ) ) ;
69182 0 : ++block;
69183 : }
69184 :
69185 : // Special handling for static data
69186 :
69187 :
69188 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
69189 0 : ROSE_ASSERT(found == true);
69190 :
69191 0 : return found;
69192 : }
69193 : /* #line 69194 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
69194 :
69195 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
69196 :
69197 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69198 :
69199 : /* #line 69200 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
69200 :
69201 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69202 :
69203 : void
69204 0 : SgArithmeticIfStatement::checkDataMemberPointersIfInMemoryPool()
69205 : {
69206 : // ------------ checking pointers of SgArithmeticIfStatement -------------------
69207 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
69208 :
69209 0 : if ( p_conditional != NULL )
69210 : {
69211 0 : if ( p_conditional->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69212 : {
69213 0 : if ( p_conditional->isInMemoryPool() == false )
69214 : {
69215 0 : std::cout << "SgArithmeticIfStatement :: ";
69216 0 : std::cout << " p_conditional is not in memory pool of ";
69217 0 : std::cout << p_conditional->class_name() << std::endl;
69218 : }
69219 : }
69220 : else
69221 : {
69222 0 : std::cout << "SgArithmeticIfStatement :: " << std::flush;
69223 0 : std::cout << "SgExpression* p_conditional = " << p_conditional << " --> " << std::flush;
69224 0 : std::cout << " not valid " << std::endl;
69225 : }
69226 : }
69227 :
69228 0 : if ( p_less_label != NULL )
69229 : {
69230 0 : if ( p_less_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69231 : {
69232 0 : if ( p_less_label->isInMemoryPool() == false )
69233 : {
69234 0 : std::cout << "SgArithmeticIfStatement :: ";
69235 0 : std::cout << " p_less_label is not in memory pool of ";
69236 0 : std::cout << p_less_label->class_name() << std::endl;
69237 : }
69238 : }
69239 : else
69240 : {
69241 0 : std::cout << "SgArithmeticIfStatement :: " << std::flush;
69242 0 : std::cout << "SgLabelRefExp* p_less_label = " << p_less_label << " --> " << std::flush;
69243 0 : std::cout << " not valid " << std::endl;
69244 : }
69245 : }
69246 :
69247 0 : if ( p_equal_label != NULL )
69248 : {
69249 0 : if ( p_equal_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69250 : {
69251 0 : if ( p_equal_label->isInMemoryPool() == false )
69252 : {
69253 0 : std::cout << "SgArithmeticIfStatement :: ";
69254 0 : std::cout << " p_equal_label is not in memory pool of ";
69255 0 : std::cout << p_equal_label->class_name() << std::endl;
69256 : }
69257 : }
69258 : else
69259 : {
69260 0 : std::cout << "SgArithmeticIfStatement :: " << std::flush;
69261 0 : std::cout << "SgLabelRefExp* p_equal_label = " << p_equal_label << " --> " << std::flush;
69262 0 : std::cout << " not valid " << std::endl;
69263 : }
69264 : }
69265 :
69266 0 : if ( p_greater_label != NULL )
69267 : {
69268 0 : if ( p_greater_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69269 : {
69270 0 : if ( p_greater_label->isInMemoryPool() == false )
69271 : {
69272 0 : std::cout << "SgArithmeticIfStatement :: ";
69273 0 : std::cout << " p_greater_label is not in memory pool of ";
69274 0 : std::cout << p_greater_label->class_name() << std::endl;
69275 : }
69276 : }
69277 : else
69278 : {
69279 0 : std::cout << "SgArithmeticIfStatement :: " << std::flush;
69280 0 : std::cout << "SgLabelRefExp* p_greater_label = " << p_greater_label << " --> " << std::flush;
69281 0 : std::cout << " not valid " << std::endl;
69282 : }
69283 : }
69284 :
69285 0 : if ( p_numeric_label != NULL )
69286 : {
69287 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69288 : {
69289 0 : if ( p_numeric_label->isInMemoryPool() == false )
69290 : {
69291 0 : std::cout << "SgArithmeticIfStatement :: ";
69292 0 : std::cout << " p_numeric_label is not in memory pool of ";
69293 0 : std::cout << p_numeric_label->class_name() << std::endl;
69294 : }
69295 : }
69296 : else
69297 : {
69298 0 : std::cout << "SgArithmeticIfStatement :: " << std::flush;
69299 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
69300 0 : std::cout << " not valid " << std::endl;
69301 : }
69302 : }
69303 :
69304 0 : if ( p_startOfConstruct != NULL )
69305 : {
69306 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69307 : {
69308 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
69309 : {
69310 0 : std::cout << "SgArithmeticIfStatement :: ";
69311 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
69312 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
69313 : }
69314 : }
69315 : else
69316 : {
69317 0 : std::cout << "SgArithmeticIfStatement :: " << std::flush;
69318 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
69319 0 : std::cout << " not valid " << std::endl;
69320 : }
69321 : }
69322 :
69323 0 : if ( p_endOfConstruct != NULL )
69324 : {
69325 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69326 : {
69327 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
69328 : {
69329 0 : std::cout << "SgArithmeticIfStatement :: ";
69330 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
69331 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
69332 : }
69333 : }
69334 : else
69335 : {
69336 0 : std::cout << "SgArithmeticIfStatement :: " << std::flush;
69337 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
69338 0 : std::cout << " not valid " << std::endl;
69339 : }
69340 : }
69341 :
69342 0 : if ( p_parent != NULL )
69343 : {
69344 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69345 : {
69346 0 : if ( p_parent->isInMemoryPool() == false )
69347 : {
69348 0 : std::cout << "SgArithmeticIfStatement :: ";
69349 0 : std::cout << " p_parent is not in memory pool of ";
69350 0 : std::cout << p_parent->class_name() << std::endl;
69351 : }
69352 : }
69353 : else
69354 : {
69355 0 : std::cout << "SgArithmeticIfStatement :: " << std::flush;
69356 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
69357 0 : std::cout << " not valid " << std::endl;
69358 : }
69359 : }
69360 :
69361 :
69362 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69363 :
69364 0 : }
69365 :
69366 :
69367 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
69368 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
69369 : bool
69370 0 : SgArithmeticIfStatement::isInMemoryPool ()
69371 : {
69372 0 : typedef unsigned char* TestType;
69373 :
69374 0 : bool found = false;
69375 :
69376 0 : ROSE_ASSERT(this != NULL);
69377 :
69378 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
69379 :
69380 0 : TestType tested = (TestType) ( this ) ;
69381 :
69382 0 : std::vector < unsigned char* > :: const_iterator block = SgArithmeticIfStatement::pools.begin();
69383 :
69384 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
69385 : // while (found == false && block < Memory_Block_List.end())
69386 0 : while ( (found == false) && (block != SgArithmeticIfStatement::pools.end()) )
69387 : {
69388 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgArithmeticIfStatement::pool_size * sizeof(SgArithmeticIfStatement) ) ) ;
69389 0 : ++block;
69390 : }
69391 :
69392 : // Special handling for static data
69393 :
69394 :
69395 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
69396 0 : ROSE_ASSERT(found == true);
69397 :
69398 0 : return found;
69399 : }
69400 : /* #line 69401 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
69401 :
69402 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
69403 :
69404 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69405 :
69406 : /* #line 69407 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
69407 :
69408 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69409 :
69410 : void
69411 0 : SgAssignStatement::checkDataMemberPointersIfInMemoryPool()
69412 : {
69413 : // ------------ checking pointers of SgAssignStatement -------------------
69414 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
69415 :
69416 0 : if ( p_label != NULL )
69417 : {
69418 0 : if ( p_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69419 : {
69420 0 : if ( p_label->isInMemoryPool() == false )
69421 : {
69422 0 : std::cout << "SgAssignStatement :: ";
69423 0 : std::cout << " p_label is not in memory pool of ";
69424 0 : std::cout << p_label->class_name() << std::endl;
69425 : }
69426 : }
69427 : else
69428 : {
69429 0 : std::cout << "SgAssignStatement :: " << std::flush;
69430 0 : std::cout << "SgLabelRefExp* p_label = " << p_label << " --> " << std::flush;
69431 0 : std::cout << " not valid " << std::endl;
69432 : }
69433 : }
69434 :
69435 0 : if ( p_value != NULL )
69436 : {
69437 0 : if ( p_value->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69438 : {
69439 0 : if ( p_value->isInMemoryPool() == false )
69440 : {
69441 0 : std::cout << "SgAssignStatement :: ";
69442 0 : std::cout << " p_value is not in memory pool of ";
69443 0 : std::cout << p_value->class_name() << std::endl;
69444 : }
69445 : }
69446 : else
69447 : {
69448 0 : std::cout << "SgAssignStatement :: " << std::flush;
69449 0 : std::cout << "SgExpression* p_value = " << p_value << " --> " << std::flush;
69450 0 : std::cout << " not valid " << std::endl;
69451 : }
69452 : }
69453 :
69454 0 : if ( p_numeric_label != NULL )
69455 : {
69456 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69457 : {
69458 0 : if ( p_numeric_label->isInMemoryPool() == false )
69459 : {
69460 0 : std::cout << "SgAssignStatement :: ";
69461 0 : std::cout << " p_numeric_label is not in memory pool of ";
69462 0 : std::cout << p_numeric_label->class_name() << std::endl;
69463 : }
69464 : }
69465 : else
69466 : {
69467 0 : std::cout << "SgAssignStatement :: " << std::flush;
69468 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
69469 0 : std::cout << " not valid " << std::endl;
69470 : }
69471 : }
69472 :
69473 0 : if ( p_startOfConstruct != NULL )
69474 : {
69475 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69476 : {
69477 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
69478 : {
69479 0 : std::cout << "SgAssignStatement :: ";
69480 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
69481 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
69482 : }
69483 : }
69484 : else
69485 : {
69486 0 : std::cout << "SgAssignStatement :: " << std::flush;
69487 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
69488 0 : std::cout << " not valid " << std::endl;
69489 : }
69490 : }
69491 :
69492 0 : if ( p_endOfConstruct != NULL )
69493 : {
69494 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69495 : {
69496 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
69497 : {
69498 0 : std::cout << "SgAssignStatement :: ";
69499 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
69500 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
69501 : }
69502 : }
69503 : else
69504 : {
69505 0 : std::cout << "SgAssignStatement :: " << std::flush;
69506 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
69507 0 : std::cout << " not valid " << std::endl;
69508 : }
69509 : }
69510 :
69511 0 : if ( p_parent != NULL )
69512 : {
69513 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69514 : {
69515 0 : if ( p_parent->isInMemoryPool() == false )
69516 : {
69517 0 : std::cout << "SgAssignStatement :: ";
69518 0 : std::cout << " p_parent is not in memory pool of ";
69519 0 : std::cout << p_parent->class_name() << std::endl;
69520 : }
69521 : }
69522 : else
69523 : {
69524 0 : std::cout << "SgAssignStatement :: " << std::flush;
69525 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
69526 0 : std::cout << " not valid " << std::endl;
69527 : }
69528 : }
69529 :
69530 :
69531 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69532 :
69533 0 : }
69534 :
69535 :
69536 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
69537 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
69538 : bool
69539 0 : SgAssignStatement::isInMemoryPool ()
69540 : {
69541 0 : typedef unsigned char* TestType;
69542 :
69543 0 : bool found = false;
69544 :
69545 0 : ROSE_ASSERT(this != NULL);
69546 :
69547 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
69548 :
69549 0 : TestType tested = (TestType) ( this ) ;
69550 :
69551 0 : std::vector < unsigned char* > :: const_iterator block = SgAssignStatement::pools.begin();
69552 :
69553 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
69554 : // while (found == false && block < Memory_Block_List.end())
69555 0 : while ( (found == false) && (block != SgAssignStatement::pools.end()) )
69556 : {
69557 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAssignStatement::pool_size * sizeof(SgAssignStatement) ) ) ;
69558 0 : ++block;
69559 : }
69560 :
69561 : // Special handling for static data
69562 :
69563 :
69564 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
69565 0 : ROSE_ASSERT(found == true);
69566 :
69567 0 : return found;
69568 : }
69569 : /* #line 69570 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
69570 :
69571 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
69572 :
69573 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69574 :
69575 : /* #line 69576 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
69576 :
69577 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69578 :
69579 : void
69580 0 : SgComputedGotoStatement::checkDataMemberPointersIfInMemoryPool()
69581 : {
69582 : // ------------ checking pointers of SgComputedGotoStatement -------------------
69583 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
69584 :
69585 0 : if ( p_labelList != NULL )
69586 : {
69587 0 : if ( p_labelList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69588 : {
69589 0 : if ( p_labelList->isInMemoryPool() == false )
69590 : {
69591 0 : std::cout << "SgComputedGotoStatement :: ";
69592 0 : std::cout << " p_labelList is not in memory pool of ";
69593 0 : std::cout << p_labelList->class_name() << std::endl;
69594 : }
69595 : }
69596 : else
69597 : {
69598 0 : std::cout << "SgComputedGotoStatement :: " << std::flush;
69599 0 : std::cout << "SgExprListExp* p_labelList = " << p_labelList << " --> " << std::flush;
69600 0 : std::cout << " not valid " << std::endl;
69601 : }
69602 : }
69603 :
69604 0 : if ( p_label_index != NULL )
69605 : {
69606 0 : if ( p_label_index->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69607 : {
69608 0 : if ( p_label_index->isInMemoryPool() == false )
69609 : {
69610 0 : std::cout << "SgComputedGotoStatement :: ";
69611 0 : std::cout << " p_label_index is not in memory pool of ";
69612 0 : std::cout << p_label_index->class_name() << std::endl;
69613 : }
69614 : }
69615 : else
69616 : {
69617 0 : std::cout << "SgComputedGotoStatement :: " << std::flush;
69618 0 : std::cout << "SgExpression* p_label_index = " << p_label_index << " --> " << std::flush;
69619 0 : std::cout << " not valid " << std::endl;
69620 : }
69621 : }
69622 :
69623 0 : if ( p_numeric_label != NULL )
69624 : {
69625 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69626 : {
69627 0 : if ( p_numeric_label->isInMemoryPool() == false )
69628 : {
69629 0 : std::cout << "SgComputedGotoStatement :: ";
69630 0 : std::cout << " p_numeric_label is not in memory pool of ";
69631 0 : std::cout << p_numeric_label->class_name() << std::endl;
69632 : }
69633 : }
69634 : else
69635 : {
69636 0 : std::cout << "SgComputedGotoStatement :: " << std::flush;
69637 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
69638 0 : std::cout << " not valid " << std::endl;
69639 : }
69640 : }
69641 :
69642 0 : if ( p_startOfConstruct != NULL )
69643 : {
69644 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69645 : {
69646 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
69647 : {
69648 0 : std::cout << "SgComputedGotoStatement :: ";
69649 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
69650 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
69651 : }
69652 : }
69653 : else
69654 : {
69655 0 : std::cout << "SgComputedGotoStatement :: " << std::flush;
69656 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
69657 0 : std::cout << " not valid " << std::endl;
69658 : }
69659 : }
69660 :
69661 0 : if ( p_endOfConstruct != NULL )
69662 : {
69663 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69664 : {
69665 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
69666 : {
69667 0 : std::cout << "SgComputedGotoStatement :: ";
69668 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
69669 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
69670 : }
69671 : }
69672 : else
69673 : {
69674 0 : std::cout << "SgComputedGotoStatement :: " << std::flush;
69675 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
69676 0 : std::cout << " not valid " << std::endl;
69677 : }
69678 : }
69679 :
69680 0 : if ( p_parent != NULL )
69681 : {
69682 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69683 : {
69684 0 : if ( p_parent->isInMemoryPool() == false )
69685 : {
69686 0 : std::cout << "SgComputedGotoStatement :: ";
69687 0 : std::cout << " p_parent is not in memory pool of ";
69688 0 : std::cout << p_parent->class_name() << std::endl;
69689 : }
69690 : }
69691 : else
69692 : {
69693 0 : std::cout << "SgComputedGotoStatement :: " << std::flush;
69694 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
69695 0 : std::cout << " not valid " << std::endl;
69696 : }
69697 : }
69698 :
69699 :
69700 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69701 :
69702 0 : }
69703 :
69704 :
69705 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
69706 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
69707 : bool
69708 0 : SgComputedGotoStatement::isInMemoryPool ()
69709 : {
69710 0 : typedef unsigned char* TestType;
69711 :
69712 0 : bool found = false;
69713 :
69714 0 : ROSE_ASSERT(this != NULL);
69715 :
69716 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
69717 :
69718 0 : TestType tested = (TestType) ( this ) ;
69719 :
69720 0 : std::vector < unsigned char* > :: const_iterator block = SgComputedGotoStatement::pools.begin();
69721 :
69722 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
69723 : // while (found == false && block < Memory_Block_List.end())
69724 0 : while ( (found == false) && (block != SgComputedGotoStatement::pools.end()) )
69725 : {
69726 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgComputedGotoStatement::pool_size * sizeof(SgComputedGotoStatement) ) ) ;
69727 0 : ++block;
69728 : }
69729 :
69730 : // Special handling for static data
69731 :
69732 :
69733 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
69734 0 : ROSE_ASSERT(found == true);
69735 :
69736 0 : return found;
69737 : }
69738 : /* #line 69739 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
69739 :
69740 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
69741 :
69742 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69743 :
69744 : /* #line 69745 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
69745 :
69746 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69747 :
69748 : void
69749 0 : SgAssignedGotoStatement::checkDataMemberPointersIfInMemoryPool()
69750 : {
69751 : // ------------ checking pointers of SgAssignedGotoStatement -------------------
69752 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
69753 :
69754 0 : if ( p_targets != NULL )
69755 : {
69756 0 : if ( p_targets->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69757 : {
69758 0 : if ( p_targets->isInMemoryPool() == false )
69759 : {
69760 0 : std::cout << "SgAssignedGotoStatement :: ";
69761 0 : std::cout << " p_targets is not in memory pool of ";
69762 0 : std::cout << p_targets->class_name() << std::endl;
69763 : }
69764 : }
69765 : else
69766 : {
69767 0 : std::cout << "SgAssignedGotoStatement :: " << std::flush;
69768 0 : std::cout << "SgExprListExp* p_targets = " << p_targets << " --> " << std::flush;
69769 0 : std::cout << " not valid " << std::endl;
69770 : }
69771 : }
69772 :
69773 0 : if ( p_numeric_label != NULL )
69774 : {
69775 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69776 : {
69777 0 : if ( p_numeric_label->isInMemoryPool() == false )
69778 : {
69779 0 : std::cout << "SgAssignedGotoStatement :: ";
69780 0 : std::cout << " p_numeric_label is not in memory pool of ";
69781 0 : std::cout << p_numeric_label->class_name() << std::endl;
69782 : }
69783 : }
69784 : else
69785 : {
69786 0 : std::cout << "SgAssignedGotoStatement :: " << std::flush;
69787 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
69788 0 : std::cout << " not valid " << std::endl;
69789 : }
69790 : }
69791 :
69792 0 : if ( p_startOfConstruct != NULL )
69793 : {
69794 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69795 : {
69796 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
69797 : {
69798 0 : std::cout << "SgAssignedGotoStatement :: ";
69799 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
69800 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
69801 : }
69802 : }
69803 : else
69804 : {
69805 0 : std::cout << "SgAssignedGotoStatement :: " << std::flush;
69806 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
69807 0 : std::cout << " not valid " << std::endl;
69808 : }
69809 : }
69810 :
69811 0 : if ( p_endOfConstruct != NULL )
69812 : {
69813 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69814 : {
69815 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
69816 : {
69817 0 : std::cout << "SgAssignedGotoStatement :: ";
69818 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
69819 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
69820 : }
69821 : }
69822 : else
69823 : {
69824 0 : std::cout << "SgAssignedGotoStatement :: " << std::flush;
69825 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
69826 0 : std::cout << " not valid " << std::endl;
69827 : }
69828 : }
69829 :
69830 0 : if ( p_parent != NULL )
69831 : {
69832 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69833 : {
69834 0 : if ( p_parent->isInMemoryPool() == false )
69835 : {
69836 0 : std::cout << "SgAssignedGotoStatement :: ";
69837 0 : std::cout << " p_parent is not in memory pool of ";
69838 0 : std::cout << p_parent->class_name() << std::endl;
69839 : }
69840 : }
69841 : else
69842 : {
69843 0 : std::cout << "SgAssignedGotoStatement :: " << std::flush;
69844 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
69845 0 : std::cout << " not valid " << std::endl;
69846 : }
69847 : }
69848 :
69849 :
69850 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69851 :
69852 0 : }
69853 :
69854 :
69855 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
69856 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
69857 : bool
69858 0 : SgAssignedGotoStatement::isInMemoryPool ()
69859 : {
69860 0 : typedef unsigned char* TestType;
69861 :
69862 0 : bool found = false;
69863 :
69864 0 : ROSE_ASSERT(this != NULL);
69865 :
69866 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
69867 :
69868 0 : TestType tested = (TestType) ( this ) ;
69869 :
69870 0 : std::vector < unsigned char* > :: const_iterator block = SgAssignedGotoStatement::pools.begin();
69871 :
69872 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
69873 : // while (found == false && block < Memory_Block_List.end())
69874 0 : while ( (found == false) && (block != SgAssignedGotoStatement::pools.end()) )
69875 : {
69876 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAssignedGotoStatement::pool_size * sizeof(SgAssignedGotoStatement) ) ) ;
69877 0 : ++block;
69878 : }
69879 :
69880 : // Special handling for static data
69881 :
69882 :
69883 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
69884 0 : ROSE_ASSERT(found == true);
69885 :
69886 0 : return found;
69887 : }
69888 : /* #line 69889 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
69889 :
69890 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
69891 :
69892 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69893 :
69894 : /* #line 69895 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
69895 :
69896 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
69897 :
69898 : void
69899 0 : SgAllocateStatement::checkDataMemberPointersIfInMemoryPool()
69900 : {
69901 : // ------------ checking pointers of SgAllocateStatement -------------------
69902 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
69903 :
69904 0 : if ( p_expr_list != NULL )
69905 : {
69906 0 : if ( p_expr_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69907 : {
69908 0 : if ( p_expr_list->isInMemoryPool() == false )
69909 : {
69910 0 : std::cout << "SgAllocateStatement :: ";
69911 0 : std::cout << " p_expr_list is not in memory pool of ";
69912 0 : std::cout << p_expr_list->class_name() << std::endl;
69913 : }
69914 : }
69915 : else
69916 : {
69917 0 : std::cout << "SgAllocateStatement :: " << std::flush;
69918 0 : std::cout << "SgExprListExp* p_expr_list = " << p_expr_list << " --> " << std::flush;
69919 0 : std::cout << " not valid " << std::endl;
69920 : }
69921 : }
69922 :
69923 0 : if ( p_stat_expression != NULL )
69924 : {
69925 0 : if ( p_stat_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69926 : {
69927 0 : if ( p_stat_expression->isInMemoryPool() == false )
69928 : {
69929 0 : std::cout << "SgAllocateStatement :: ";
69930 0 : std::cout << " p_stat_expression is not in memory pool of ";
69931 0 : std::cout << p_stat_expression->class_name() << std::endl;
69932 : }
69933 : }
69934 : else
69935 : {
69936 0 : std::cout << "SgAllocateStatement :: " << std::flush;
69937 0 : std::cout << "SgExpression* p_stat_expression = " << p_stat_expression << " --> " << std::flush;
69938 0 : std::cout << " not valid " << std::endl;
69939 : }
69940 : }
69941 :
69942 0 : if ( p_errmsg_expression != NULL )
69943 : {
69944 0 : if ( p_errmsg_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69945 : {
69946 0 : if ( p_errmsg_expression->isInMemoryPool() == false )
69947 : {
69948 0 : std::cout << "SgAllocateStatement :: ";
69949 0 : std::cout << " p_errmsg_expression is not in memory pool of ";
69950 0 : std::cout << p_errmsg_expression->class_name() << std::endl;
69951 : }
69952 : }
69953 : else
69954 : {
69955 0 : std::cout << "SgAllocateStatement :: " << std::flush;
69956 0 : std::cout << "SgExpression* p_errmsg_expression = " << p_errmsg_expression << " --> " << std::flush;
69957 0 : std::cout << " not valid " << std::endl;
69958 : }
69959 : }
69960 :
69961 0 : if ( p_source_expression != NULL )
69962 : {
69963 0 : if ( p_source_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69964 : {
69965 0 : if ( p_source_expression->isInMemoryPool() == false )
69966 : {
69967 0 : std::cout << "SgAllocateStatement :: ";
69968 0 : std::cout << " p_source_expression is not in memory pool of ";
69969 0 : std::cout << p_source_expression->class_name() << std::endl;
69970 : }
69971 : }
69972 : else
69973 : {
69974 0 : std::cout << "SgAllocateStatement :: " << std::flush;
69975 0 : std::cout << "SgExpression* p_source_expression = " << p_source_expression << " --> " << std::flush;
69976 0 : std::cout << " not valid " << std::endl;
69977 : }
69978 : }
69979 :
69980 0 : if ( p_numeric_label != NULL )
69981 : {
69982 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
69983 : {
69984 0 : if ( p_numeric_label->isInMemoryPool() == false )
69985 : {
69986 0 : std::cout << "SgAllocateStatement :: ";
69987 0 : std::cout << " p_numeric_label is not in memory pool of ";
69988 0 : std::cout << p_numeric_label->class_name() << std::endl;
69989 : }
69990 : }
69991 : else
69992 : {
69993 0 : std::cout << "SgAllocateStatement :: " << std::flush;
69994 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
69995 0 : std::cout << " not valid " << std::endl;
69996 : }
69997 : }
69998 :
69999 0 : if ( p_startOfConstruct != NULL )
70000 : {
70001 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70002 : {
70003 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
70004 : {
70005 0 : std::cout << "SgAllocateStatement :: ";
70006 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
70007 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
70008 : }
70009 : }
70010 : else
70011 : {
70012 0 : std::cout << "SgAllocateStatement :: " << std::flush;
70013 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
70014 0 : std::cout << " not valid " << std::endl;
70015 : }
70016 : }
70017 :
70018 0 : if ( p_endOfConstruct != NULL )
70019 : {
70020 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70021 : {
70022 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
70023 : {
70024 0 : std::cout << "SgAllocateStatement :: ";
70025 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
70026 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
70027 : }
70028 : }
70029 : else
70030 : {
70031 0 : std::cout << "SgAllocateStatement :: " << std::flush;
70032 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
70033 0 : std::cout << " not valid " << std::endl;
70034 : }
70035 : }
70036 :
70037 0 : if ( p_parent != NULL )
70038 : {
70039 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70040 : {
70041 0 : if ( p_parent->isInMemoryPool() == false )
70042 : {
70043 0 : std::cout << "SgAllocateStatement :: ";
70044 0 : std::cout << " p_parent is not in memory pool of ";
70045 0 : std::cout << p_parent->class_name() << std::endl;
70046 : }
70047 : }
70048 : else
70049 : {
70050 0 : std::cout << "SgAllocateStatement :: " << std::flush;
70051 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
70052 0 : std::cout << " not valid " << std::endl;
70053 : }
70054 : }
70055 :
70056 :
70057 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70058 :
70059 0 : }
70060 :
70061 :
70062 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
70063 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
70064 : bool
70065 0 : SgAllocateStatement::isInMemoryPool ()
70066 : {
70067 0 : typedef unsigned char* TestType;
70068 :
70069 0 : bool found = false;
70070 :
70071 0 : ROSE_ASSERT(this != NULL);
70072 :
70073 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
70074 :
70075 0 : TestType tested = (TestType) ( this ) ;
70076 :
70077 0 : std::vector < unsigned char* > :: const_iterator block = SgAllocateStatement::pools.begin();
70078 :
70079 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
70080 : // while (found == false && block < Memory_Block_List.end())
70081 0 : while ( (found == false) && (block != SgAllocateStatement::pools.end()) )
70082 : {
70083 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAllocateStatement::pool_size * sizeof(SgAllocateStatement) ) ) ;
70084 0 : ++block;
70085 : }
70086 :
70087 : // Special handling for static data
70088 :
70089 :
70090 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
70091 0 : ROSE_ASSERT(found == true);
70092 :
70093 0 : return found;
70094 : }
70095 : /* #line 70096 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
70096 :
70097 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
70098 :
70099 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70100 :
70101 : /* #line 70102 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
70102 :
70103 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70104 :
70105 : void
70106 0 : SgDeallocateStatement::checkDataMemberPointersIfInMemoryPool()
70107 : {
70108 : // ------------ checking pointers of SgDeallocateStatement -------------------
70109 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
70110 :
70111 0 : if ( p_expr_list != NULL )
70112 : {
70113 0 : if ( p_expr_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70114 : {
70115 0 : if ( p_expr_list->isInMemoryPool() == false )
70116 : {
70117 0 : std::cout << "SgDeallocateStatement :: ";
70118 0 : std::cout << " p_expr_list is not in memory pool of ";
70119 0 : std::cout << p_expr_list->class_name() << std::endl;
70120 : }
70121 : }
70122 : else
70123 : {
70124 0 : std::cout << "SgDeallocateStatement :: " << std::flush;
70125 0 : std::cout << "SgExprListExp* p_expr_list = " << p_expr_list << " --> " << std::flush;
70126 0 : std::cout << " not valid " << std::endl;
70127 : }
70128 : }
70129 :
70130 0 : if ( p_stat_expression != NULL )
70131 : {
70132 0 : if ( p_stat_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70133 : {
70134 0 : if ( p_stat_expression->isInMemoryPool() == false )
70135 : {
70136 0 : std::cout << "SgDeallocateStatement :: ";
70137 0 : std::cout << " p_stat_expression is not in memory pool of ";
70138 0 : std::cout << p_stat_expression->class_name() << std::endl;
70139 : }
70140 : }
70141 : else
70142 : {
70143 0 : std::cout << "SgDeallocateStatement :: " << std::flush;
70144 0 : std::cout << "SgExpression* p_stat_expression = " << p_stat_expression << " --> " << std::flush;
70145 0 : std::cout << " not valid " << std::endl;
70146 : }
70147 : }
70148 :
70149 0 : if ( p_errmsg_expression != NULL )
70150 : {
70151 0 : if ( p_errmsg_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70152 : {
70153 0 : if ( p_errmsg_expression->isInMemoryPool() == false )
70154 : {
70155 0 : std::cout << "SgDeallocateStatement :: ";
70156 0 : std::cout << " p_errmsg_expression is not in memory pool of ";
70157 0 : std::cout << p_errmsg_expression->class_name() << std::endl;
70158 : }
70159 : }
70160 : else
70161 : {
70162 0 : std::cout << "SgDeallocateStatement :: " << std::flush;
70163 0 : std::cout << "SgExpression* p_errmsg_expression = " << p_errmsg_expression << " --> " << std::flush;
70164 0 : std::cout << " not valid " << std::endl;
70165 : }
70166 : }
70167 :
70168 0 : if ( p_numeric_label != NULL )
70169 : {
70170 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70171 : {
70172 0 : if ( p_numeric_label->isInMemoryPool() == false )
70173 : {
70174 0 : std::cout << "SgDeallocateStatement :: ";
70175 0 : std::cout << " p_numeric_label is not in memory pool of ";
70176 0 : std::cout << p_numeric_label->class_name() << std::endl;
70177 : }
70178 : }
70179 : else
70180 : {
70181 0 : std::cout << "SgDeallocateStatement :: " << std::flush;
70182 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
70183 0 : std::cout << " not valid " << std::endl;
70184 : }
70185 : }
70186 :
70187 0 : if ( p_startOfConstruct != NULL )
70188 : {
70189 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70190 : {
70191 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
70192 : {
70193 0 : std::cout << "SgDeallocateStatement :: ";
70194 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
70195 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
70196 : }
70197 : }
70198 : else
70199 : {
70200 0 : std::cout << "SgDeallocateStatement :: " << std::flush;
70201 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
70202 0 : std::cout << " not valid " << std::endl;
70203 : }
70204 : }
70205 :
70206 0 : if ( p_endOfConstruct != NULL )
70207 : {
70208 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70209 : {
70210 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
70211 : {
70212 0 : std::cout << "SgDeallocateStatement :: ";
70213 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
70214 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
70215 : }
70216 : }
70217 : else
70218 : {
70219 0 : std::cout << "SgDeallocateStatement :: " << std::flush;
70220 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
70221 0 : std::cout << " not valid " << std::endl;
70222 : }
70223 : }
70224 :
70225 0 : if ( p_parent != NULL )
70226 : {
70227 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70228 : {
70229 0 : if ( p_parent->isInMemoryPool() == false )
70230 : {
70231 0 : std::cout << "SgDeallocateStatement :: ";
70232 0 : std::cout << " p_parent is not in memory pool of ";
70233 0 : std::cout << p_parent->class_name() << std::endl;
70234 : }
70235 : }
70236 : else
70237 : {
70238 0 : std::cout << "SgDeallocateStatement :: " << std::flush;
70239 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
70240 0 : std::cout << " not valid " << std::endl;
70241 : }
70242 : }
70243 :
70244 :
70245 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70246 :
70247 0 : }
70248 :
70249 :
70250 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
70251 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
70252 : bool
70253 0 : SgDeallocateStatement::isInMemoryPool ()
70254 : {
70255 0 : typedef unsigned char* TestType;
70256 :
70257 0 : bool found = false;
70258 :
70259 0 : ROSE_ASSERT(this != NULL);
70260 :
70261 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
70262 :
70263 0 : TestType tested = (TestType) ( this ) ;
70264 :
70265 0 : std::vector < unsigned char* > :: const_iterator block = SgDeallocateStatement::pools.begin();
70266 :
70267 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
70268 : // while (found == false && block < Memory_Block_List.end())
70269 0 : while ( (found == false) && (block != SgDeallocateStatement::pools.end()) )
70270 : {
70271 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDeallocateStatement::pool_size * sizeof(SgDeallocateStatement) ) ) ;
70272 0 : ++block;
70273 : }
70274 :
70275 : // Special handling for static data
70276 :
70277 :
70278 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
70279 0 : ROSE_ASSERT(found == true);
70280 :
70281 0 : return found;
70282 : }
70283 : /* #line 70284 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
70284 :
70285 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
70286 :
70287 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70288 :
70289 : /* #line 70290 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
70290 :
70291 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70292 :
70293 : void
70294 0 : SgUpcNotifyStatement::checkDataMemberPointersIfInMemoryPool()
70295 : {
70296 : // ------------ checking pointers of SgUpcNotifyStatement -------------------
70297 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
70298 :
70299 0 : if ( p_notify_expression != NULL )
70300 : {
70301 0 : if ( p_notify_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70302 : {
70303 0 : if ( p_notify_expression->isInMemoryPool() == false )
70304 : {
70305 0 : std::cout << "SgUpcNotifyStatement :: ";
70306 0 : std::cout << " p_notify_expression is not in memory pool of ";
70307 0 : std::cout << p_notify_expression->class_name() << std::endl;
70308 : }
70309 : }
70310 : else
70311 : {
70312 0 : std::cout << "SgUpcNotifyStatement :: " << std::flush;
70313 0 : std::cout << "SgExpression* p_notify_expression = " << p_notify_expression << " --> " << std::flush;
70314 0 : std::cout << " not valid " << std::endl;
70315 : }
70316 : }
70317 :
70318 0 : if ( p_numeric_label != NULL )
70319 : {
70320 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70321 : {
70322 0 : if ( p_numeric_label->isInMemoryPool() == false )
70323 : {
70324 0 : std::cout << "SgUpcNotifyStatement :: ";
70325 0 : std::cout << " p_numeric_label is not in memory pool of ";
70326 0 : std::cout << p_numeric_label->class_name() << std::endl;
70327 : }
70328 : }
70329 : else
70330 : {
70331 0 : std::cout << "SgUpcNotifyStatement :: " << std::flush;
70332 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
70333 0 : std::cout << " not valid " << std::endl;
70334 : }
70335 : }
70336 :
70337 0 : if ( p_startOfConstruct != NULL )
70338 : {
70339 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70340 : {
70341 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
70342 : {
70343 0 : std::cout << "SgUpcNotifyStatement :: ";
70344 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
70345 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
70346 : }
70347 : }
70348 : else
70349 : {
70350 0 : std::cout << "SgUpcNotifyStatement :: " << std::flush;
70351 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
70352 0 : std::cout << " not valid " << std::endl;
70353 : }
70354 : }
70355 :
70356 0 : if ( p_endOfConstruct != NULL )
70357 : {
70358 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70359 : {
70360 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
70361 : {
70362 0 : std::cout << "SgUpcNotifyStatement :: ";
70363 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
70364 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
70365 : }
70366 : }
70367 : else
70368 : {
70369 0 : std::cout << "SgUpcNotifyStatement :: " << std::flush;
70370 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
70371 0 : std::cout << " not valid " << std::endl;
70372 : }
70373 : }
70374 :
70375 0 : if ( p_parent != NULL )
70376 : {
70377 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70378 : {
70379 0 : if ( p_parent->isInMemoryPool() == false )
70380 : {
70381 0 : std::cout << "SgUpcNotifyStatement :: ";
70382 0 : std::cout << " p_parent is not in memory pool of ";
70383 0 : std::cout << p_parent->class_name() << std::endl;
70384 : }
70385 : }
70386 : else
70387 : {
70388 0 : std::cout << "SgUpcNotifyStatement :: " << std::flush;
70389 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
70390 0 : std::cout << " not valid " << std::endl;
70391 : }
70392 : }
70393 :
70394 :
70395 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70396 :
70397 0 : }
70398 :
70399 :
70400 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
70401 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
70402 : bool
70403 0 : SgUpcNotifyStatement::isInMemoryPool ()
70404 : {
70405 0 : typedef unsigned char* TestType;
70406 :
70407 0 : bool found = false;
70408 :
70409 0 : ROSE_ASSERT(this != NULL);
70410 :
70411 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
70412 :
70413 0 : TestType tested = (TestType) ( this ) ;
70414 :
70415 0 : std::vector < unsigned char* > :: const_iterator block = SgUpcNotifyStatement::pools.begin();
70416 :
70417 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
70418 : // while (found == false && block < Memory_Block_List.end())
70419 0 : while ( (found == false) && (block != SgUpcNotifyStatement::pools.end()) )
70420 : {
70421 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpcNotifyStatement::pool_size * sizeof(SgUpcNotifyStatement) ) ) ;
70422 0 : ++block;
70423 : }
70424 :
70425 : // Special handling for static data
70426 :
70427 :
70428 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
70429 0 : ROSE_ASSERT(found == true);
70430 :
70431 0 : return found;
70432 : }
70433 : /* #line 70434 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
70434 :
70435 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
70436 :
70437 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70438 :
70439 : /* #line 70440 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
70440 :
70441 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70442 :
70443 : void
70444 0 : SgUpcWaitStatement::checkDataMemberPointersIfInMemoryPool()
70445 : {
70446 : // ------------ checking pointers of SgUpcWaitStatement -------------------
70447 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
70448 :
70449 0 : if ( p_wait_expression != NULL )
70450 : {
70451 0 : if ( p_wait_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70452 : {
70453 0 : if ( p_wait_expression->isInMemoryPool() == false )
70454 : {
70455 0 : std::cout << "SgUpcWaitStatement :: ";
70456 0 : std::cout << " p_wait_expression is not in memory pool of ";
70457 0 : std::cout << p_wait_expression->class_name() << std::endl;
70458 : }
70459 : }
70460 : else
70461 : {
70462 0 : std::cout << "SgUpcWaitStatement :: " << std::flush;
70463 0 : std::cout << "SgExpression* p_wait_expression = " << p_wait_expression << " --> " << std::flush;
70464 0 : std::cout << " not valid " << std::endl;
70465 : }
70466 : }
70467 :
70468 0 : if ( p_numeric_label != NULL )
70469 : {
70470 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70471 : {
70472 0 : if ( p_numeric_label->isInMemoryPool() == false )
70473 : {
70474 0 : std::cout << "SgUpcWaitStatement :: ";
70475 0 : std::cout << " p_numeric_label is not in memory pool of ";
70476 0 : std::cout << p_numeric_label->class_name() << std::endl;
70477 : }
70478 : }
70479 : else
70480 : {
70481 0 : std::cout << "SgUpcWaitStatement :: " << std::flush;
70482 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
70483 0 : std::cout << " not valid " << std::endl;
70484 : }
70485 : }
70486 :
70487 0 : if ( p_startOfConstruct != NULL )
70488 : {
70489 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70490 : {
70491 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
70492 : {
70493 0 : std::cout << "SgUpcWaitStatement :: ";
70494 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
70495 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
70496 : }
70497 : }
70498 : else
70499 : {
70500 0 : std::cout << "SgUpcWaitStatement :: " << std::flush;
70501 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
70502 0 : std::cout << " not valid " << std::endl;
70503 : }
70504 : }
70505 :
70506 0 : if ( p_endOfConstruct != NULL )
70507 : {
70508 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70509 : {
70510 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
70511 : {
70512 0 : std::cout << "SgUpcWaitStatement :: ";
70513 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
70514 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
70515 : }
70516 : }
70517 : else
70518 : {
70519 0 : std::cout << "SgUpcWaitStatement :: " << std::flush;
70520 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
70521 0 : std::cout << " not valid " << std::endl;
70522 : }
70523 : }
70524 :
70525 0 : if ( p_parent != NULL )
70526 : {
70527 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70528 : {
70529 0 : if ( p_parent->isInMemoryPool() == false )
70530 : {
70531 0 : std::cout << "SgUpcWaitStatement :: ";
70532 0 : std::cout << " p_parent is not in memory pool of ";
70533 0 : std::cout << p_parent->class_name() << std::endl;
70534 : }
70535 : }
70536 : else
70537 : {
70538 0 : std::cout << "SgUpcWaitStatement :: " << std::flush;
70539 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
70540 0 : std::cout << " not valid " << std::endl;
70541 : }
70542 : }
70543 :
70544 :
70545 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70546 :
70547 0 : }
70548 :
70549 :
70550 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
70551 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
70552 : bool
70553 0 : SgUpcWaitStatement::isInMemoryPool ()
70554 : {
70555 0 : typedef unsigned char* TestType;
70556 :
70557 0 : bool found = false;
70558 :
70559 0 : ROSE_ASSERT(this != NULL);
70560 :
70561 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
70562 :
70563 0 : TestType tested = (TestType) ( this ) ;
70564 :
70565 0 : std::vector < unsigned char* > :: const_iterator block = SgUpcWaitStatement::pools.begin();
70566 :
70567 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
70568 : // while (found == false && block < Memory_Block_List.end())
70569 0 : while ( (found == false) && (block != SgUpcWaitStatement::pools.end()) )
70570 : {
70571 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpcWaitStatement::pool_size * sizeof(SgUpcWaitStatement) ) ) ;
70572 0 : ++block;
70573 : }
70574 :
70575 : // Special handling for static data
70576 :
70577 :
70578 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
70579 0 : ROSE_ASSERT(found == true);
70580 :
70581 0 : return found;
70582 : }
70583 : /* #line 70584 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
70584 :
70585 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
70586 :
70587 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70588 :
70589 : /* #line 70590 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
70590 :
70591 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70592 :
70593 : void
70594 0 : SgUpcBarrierStatement::checkDataMemberPointersIfInMemoryPool()
70595 : {
70596 : // ------------ checking pointers of SgUpcBarrierStatement -------------------
70597 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
70598 :
70599 0 : if ( p_barrier_expression != NULL )
70600 : {
70601 0 : if ( p_barrier_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70602 : {
70603 0 : if ( p_barrier_expression->isInMemoryPool() == false )
70604 : {
70605 0 : std::cout << "SgUpcBarrierStatement :: ";
70606 0 : std::cout << " p_barrier_expression is not in memory pool of ";
70607 0 : std::cout << p_barrier_expression->class_name() << std::endl;
70608 : }
70609 : }
70610 : else
70611 : {
70612 0 : std::cout << "SgUpcBarrierStatement :: " << std::flush;
70613 0 : std::cout << "SgExpression* p_barrier_expression = " << p_barrier_expression << " --> " << std::flush;
70614 0 : std::cout << " not valid " << std::endl;
70615 : }
70616 : }
70617 :
70618 0 : if ( p_numeric_label != NULL )
70619 : {
70620 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70621 : {
70622 0 : if ( p_numeric_label->isInMemoryPool() == false )
70623 : {
70624 0 : std::cout << "SgUpcBarrierStatement :: ";
70625 0 : std::cout << " p_numeric_label is not in memory pool of ";
70626 0 : std::cout << p_numeric_label->class_name() << std::endl;
70627 : }
70628 : }
70629 : else
70630 : {
70631 0 : std::cout << "SgUpcBarrierStatement :: " << std::flush;
70632 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
70633 0 : std::cout << " not valid " << std::endl;
70634 : }
70635 : }
70636 :
70637 0 : if ( p_startOfConstruct != NULL )
70638 : {
70639 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70640 : {
70641 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
70642 : {
70643 0 : std::cout << "SgUpcBarrierStatement :: ";
70644 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
70645 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
70646 : }
70647 : }
70648 : else
70649 : {
70650 0 : std::cout << "SgUpcBarrierStatement :: " << std::flush;
70651 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
70652 0 : std::cout << " not valid " << std::endl;
70653 : }
70654 : }
70655 :
70656 0 : if ( p_endOfConstruct != NULL )
70657 : {
70658 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70659 : {
70660 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
70661 : {
70662 0 : std::cout << "SgUpcBarrierStatement :: ";
70663 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
70664 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
70665 : }
70666 : }
70667 : else
70668 : {
70669 0 : std::cout << "SgUpcBarrierStatement :: " << std::flush;
70670 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
70671 0 : std::cout << " not valid " << std::endl;
70672 : }
70673 : }
70674 :
70675 0 : if ( p_parent != NULL )
70676 : {
70677 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70678 : {
70679 0 : if ( p_parent->isInMemoryPool() == false )
70680 : {
70681 0 : std::cout << "SgUpcBarrierStatement :: ";
70682 0 : std::cout << " p_parent is not in memory pool of ";
70683 0 : std::cout << p_parent->class_name() << std::endl;
70684 : }
70685 : }
70686 : else
70687 : {
70688 0 : std::cout << "SgUpcBarrierStatement :: " << std::flush;
70689 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
70690 0 : std::cout << " not valid " << std::endl;
70691 : }
70692 : }
70693 :
70694 :
70695 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70696 :
70697 0 : }
70698 :
70699 :
70700 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
70701 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
70702 : bool
70703 0 : SgUpcBarrierStatement::isInMemoryPool ()
70704 : {
70705 0 : typedef unsigned char* TestType;
70706 :
70707 0 : bool found = false;
70708 :
70709 0 : ROSE_ASSERT(this != NULL);
70710 :
70711 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
70712 :
70713 0 : TestType tested = (TestType) ( this ) ;
70714 :
70715 0 : std::vector < unsigned char* > :: const_iterator block = SgUpcBarrierStatement::pools.begin();
70716 :
70717 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
70718 : // while (found == false && block < Memory_Block_List.end())
70719 0 : while ( (found == false) && (block != SgUpcBarrierStatement::pools.end()) )
70720 : {
70721 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpcBarrierStatement::pool_size * sizeof(SgUpcBarrierStatement) ) ) ;
70722 0 : ++block;
70723 : }
70724 :
70725 : // Special handling for static data
70726 :
70727 :
70728 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
70729 0 : ROSE_ASSERT(found == true);
70730 :
70731 0 : return found;
70732 : }
70733 : /* #line 70734 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
70734 :
70735 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
70736 :
70737 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70738 :
70739 : /* #line 70740 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
70740 :
70741 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70742 :
70743 : void
70744 0 : SgUpcFenceStatement::checkDataMemberPointersIfInMemoryPool()
70745 : {
70746 : // ------------ checking pointers of SgUpcFenceStatement -------------------
70747 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
70748 :
70749 0 : if ( p_numeric_label != NULL )
70750 : {
70751 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70752 : {
70753 0 : if ( p_numeric_label->isInMemoryPool() == false )
70754 : {
70755 0 : std::cout << "SgUpcFenceStatement :: ";
70756 0 : std::cout << " p_numeric_label is not in memory pool of ";
70757 0 : std::cout << p_numeric_label->class_name() << std::endl;
70758 : }
70759 : }
70760 : else
70761 : {
70762 0 : std::cout << "SgUpcFenceStatement :: " << std::flush;
70763 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
70764 0 : std::cout << " not valid " << std::endl;
70765 : }
70766 : }
70767 :
70768 0 : if ( p_startOfConstruct != NULL )
70769 : {
70770 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70771 : {
70772 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
70773 : {
70774 0 : std::cout << "SgUpcFenceStatement :: ";
70775 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
70776 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
70777 : }
70778 : }
70779 : else
70780 : {
70781 0 : std::cout << "SgUpcFenceStatement :: " << std::flush;
70782 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
70783 0 : std::cout << " not valid " << std::endl;
70784 : }
70785 : }
70786 :
70787 0 : if ( p_endOfConstruct != NULL )
70788 : {
70789 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70790 : {
70791 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
70792 : {
70793 0 : std::cout << "SgUpcFenceStatement :: ";
70794 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
70795 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
70796 : }
70797 : }
70798 : else
70799 : {
70800 0 : std::cout << "SgUpcFenceStatement :: " << std::flush;
70801 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
70802 0 : std::cout << " not valid " << std::endl;
70803 : }
70804 : }
70805 :
70806 0 : if ( p_parent != NULL )
70807 : {
70808 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70809 : {
70810 0 : if ( p_parent->isInMemoryPool() == false )
70811 : {
70812 0 : std::cout << "SgUpcFenceStatement :: ";
70813 0 : std::cout << " p_parent is not in memory pool of ";
70814 0 : std::cout << p_parent->class_name() << std::endl;
70815 : }
70816 : }
70817 : else
70818 : {
70819 0 : std::cout << "SgUpcFenceStatement :: " << std::flush;
70820 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
70821 0 : std::cout << " not valid " << std::endl;
70822 : }
70823 : }
70824 :
70825 :
70826 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70827 :
70828 0 : }
70829 :
70830 :
70831 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
70832 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
70833 : bool
70834 0 : SgUpcFenceStatement::isInMemoryPool ()
70835 : {
70836 0 : typedef unsigned char* TestType;
70837 :
70838 0 : bool found = false;
70839 :
70840 0 : ROSE_ASSERT(this != NULL);
70841 :
70842 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
70843 :
70844 0 : TestType tested = (TestType) ( this ) ;
70845 :
70846 0 : std::vector < unsigned char* > :: const_iterator block = SgUpcFenceStatement::pools.begin();
70847 :
70848 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
70849 : // while (found == false && block < Memory_Block_List.end())
70850 0 : while ( (found == false) && (block != SgUpcFenceStatement::pools.end()) )
70851 : {
70852 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpcFenceStatement::pool_size * sizeof(SgUpcFenceStatement) ) ) ;
70853 0 : ++block;
70854 : }
70855 :
70856 : // Special handling for static data
70857 :
70858 :
70859 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
70860 0 : ROSE_ASSERT(found == true);
70861 :
70862 0 : return found;
70863 : }
70864 : /* #line 70865 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
70865 :
70866 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
70867 :
70868 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70869 :
70870 : /* #line 70871 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
70871 :
70872 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
70873 :
70874 : void
70875 0 : SgUpirBaseStatement::checkDataMemberPointersIfInMemoryPool()
70876 : {
70877 : // ------------ checking pointers of SgUpirBaseStatement -------------------
70878 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
70879 :
70880 0 : if ( p_upir_parent != NULL )
70881 : {
70882 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70883 : {
70884 0 : if ( p_upir_parent->isInMemoryPool() == false )
70885 : {
70886 0 : std::cout << "SgUpirBaseStatement :: ";
70887 0 : std::cout << " p_upir_parent is not in memory pool of ";
70888 0 : std::cout << p_upir_parent->class_name() << std::endl;
70889 : }
70890 : }
70891 : else
70892 : {
70893 0 : std::cout << "SgUpirBaseStatement :: " << std::flush;
70894 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
70895 0 : std::cout << " not valid " << std::endl;
70896 : }
70897 : }
70898 :
70899 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
70900 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
70901 : {
70902 0 : if ( (*i_upir_children) != NULL )
70903 : {
70904 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70905 : {
70906 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
70907 : {
70908 0 : std::cout << "SgUpirBaseStatement :: ";
70909 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
70910 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
70911 : }
70912 : }
70913 : else
70914 : {
70915 0 : std::cout << "SgUpirBaseStatement :: " << std::flush;
70916 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
70917 0 : std::cout << " entry not valid " << std::endl;
70918 : }
70919 : }
70920 : else
70921 : {
70922 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
70923 : }
70924 : }
70925 :
70926 0 : if ( p_numeric_label != NULL )
70927 : {
70928 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70929 : {
70930 0 : if ( p_numeric_label->isInMemoryPool() == false )
70931 : {
70932 0 : std::cout << "SgUpirBaseStatement :: ";
70933 0 : std::cout << " p_numeric_label is not in memory pool of ";
70934 0 : std::cout << p_numeric_label->class_name() << std::endl;
70935 : }
70936 : }
70937 : else
70938 : {
70939 0 : std::cout << "SgUpirBaseStatement :: " << std::flush;
70940 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
70941 0 : std::cout << " not valid " << std::endl;
70942 : }
70943 : }
70944 :
70945 0 : if ( p_startOfConstruct != NULL )
70946 : {
70947 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70948 : {
70949 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
70950 : {
70951 0 : std::cout << "SgUpirBaseStatement :: ";
70952 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
70953 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
70954 : }
70955 : }
70956 : else
70957 : {
70958 0 : std::cout << "SgUpirBaseStatement :: " << std::flush;
70959 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
70960 0 : std::cout << " not valid " << std::endl;
70961 : }
70962 : }
70963 :
70964 0 : if ( p_endOfConstruct != NULL )
70965 : {
70966 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70967 : {
70968 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
70969 : {
70970 0 : std::cout << "SgUpirBaseStatement :: ";
70971 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
70972 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
70973 : }
70974 : }
70975 : else
70976 : {
70977 0 : std::cout << "SgUpirBaseStatement :: " << std::flush;
70978 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
70979 0 : std::cout << " not valid " << std::endl;
70980 : }
70981 : }
70982 :
70983 0 : if ( p_parent != NULL )
70984 : {
70985 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
70986 : {
70987 0 : if ( p_parent->isInMemoryPool() == false )
70988 : {
70989 0 : std::cout << "SgUpirBaseStatement :: ";
70990 0 : std::cout << " p_parent is not in memory pool of ";
70991 0 : std::cout << p_parent->class_name() << std::endl;
70992 : }
70993 : }
70994 : else
70995 : {
70996 0 : std::cout << "SgUpirBaseStatement :: " << std::flush;
70997 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
70998 0 : std::cout << " not valid " << std::endl;
70999 : }
71000 : }
71001 :
71002 :
71003 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71004 :
71005 0 : }
71006 :
71007 :
71008 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
71009 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
71010 : bool
71011 0 : SgUpirBaseStatement::isInMemoryPool ()
71012 : {
71013 0 : typedef unsigned char* TestType;
71014 :
71015 0 : bool found = false;
71016 :
71017 0 : ROSE_ASSERT(this != NULL);
71018 :
71019 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
71020 :
71021 0 : TestType tested = (TestType) ( this ) ;
71022 :
71023 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirBaseStatement::pools.begin();
71024 :
71025 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
71026 : // while (found == false && block < Memory_Block_List.end())
71027 0 : while ( (found == false) && (block != SgUpirBaseStatement::pools.end()) )
71028 : {
71029 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirBaseStatement::pool_size * sizeof(SgUpirBaseStatement) ) ) ;
71030 0 : ++block;
71031 : }
71032 :
71033 : // Special handling for static data
71034 :
71035 :
71036 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
71037 0 : ROSE_ASSERT(found == true);
71038 :
71039 0 : return found;
71040 : }
71041 : /* #line 71042 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
71042 :
71043 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
71044 :
71045 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71046 :
71047 : /* #line 71048 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
71048 :
71049 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71050 :
71051 : void
71052 0 : SgOmpTaskyieldStatement::checkDataMemberPointersIfInMemoryPool()
71053 : {
71054 : // ------------ checking pointers of SgOmpTaskyieldStatement -------------------
71055 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
71056 :
71057 0 : if ( p_upir_parent != NULL )
71058 : {
71059 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71060 : {
71061 0 : if ( p_upir_parent->isInMemoryPool() == false )
71062 : {
71063 0 : std::cout << "SgOmpTaskyieldStatement :: ";
71064 0 : std::cout << " p_upir_parent is not in memory pool of ";
71065 0 : std::cout << p_upir_parent->class_name() << std::endl;
71066 : }
71067 : }
71068 : else
71069 : {
71070 0 : std::cout << "SgOmpTaskyieldStatement :: " << std::flush;
71071 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
71072 0 : std::cout << " not valid " << std::endl;
71073 : }
71074 : }
71075 :
71076 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
71077 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
71078 : {
71079 0 : if ( (*i_upir_children) != NULL )
71080 : {
71081 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71082 : {
71083 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
71084 : {
71085 0 : std::cout << "SgOmpTaskyieldStatement :: ";
71086 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
71087 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
71088 : }
71089 : }
71090 : else
71091 : {
71092 0 : std::cout << "SgOmpTaskyieldStatement :: " << std::flush;
71093 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
71094 0 : std::cout << " entry not valid " << std::endl;
71095 : }
71096 : }
71097 : else
71098 : {
71099 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
71100 : }
71101 : }
71102 :
71103 0 : if ( p_numeric_label != NULL )
71104 : {
71105 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71106 : {
71107 0 : if ( p_numeric_label->isInMemoryPool() == false )
71108 : {
71109 0 : std::cout << "SgOmpTaskyieldStatement :: ";
71110 0 : std::cout << " p_numeric_label is not in memory pool of ";
71111 0 : std::cout << p_numeric_label->class_name() << std::endl;
71112 : }
71113 : }
71114 : else
71115 : {
71116 0 : std::cout << "SgOmpTaskyieldStatement :: " << std::flush;
71117 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
71118 0 : std::cout << " not valid " << std::endl;
71119 : }
71120 : }
71121 :
71122 0 : if ( p_startOfConstruct != NULL )
71123 : {
71124 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71125 : {
71126 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
71127 : {
71128 0 : std::cout << "SgOmpTaskyieldStatement :: ";
71129 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
71130 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
71131 : }
71132 : }
71133 : else
71134 : {
71135 0 : std::cout << "SgOmpTaskyieldStatement :: " << std::flush;
71136 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
71137 0 : std::cout << " not valid " << std::endl;
71138 : }
71139 : }
71140 :
71141 0 : if ( p_endOfConstruct != NULL )
71142 : {
71143 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71144 : {
71145 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
71146 : {
71147 0 : std::cout << "SgOmpTaskyieldStatement :: ";
71148 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
71149 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
71150 : }
71151 : }
71152 : else
71153 : {
71154 0 : std::cout << "SgOmpTaskyieldStatement :: " << std::flush;
71155 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
71156 0 : std::cout << " not valid " << std::endl;
71157 : }
71158 : }
71159 :
71160 0 : if ( p_parent != NULL )
71161 : {
71162 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71163 : {
71164 0 : if ( p_parent->isInMemoryPool() == false )
71165 : {
71166 0 : std::cout << "SgOmpTaskyieldStatement :: ";
71167 0 : std::cout << " p_parent is not in memory pool of ";
71168 0 : std::cout << p_parent->class_name() << std::endl;
71169 : }
71170 : }
71171 : else
71172 : {
71173 0 : std::cout << "SgOmpTaskyieldStatement :: " << std::flush;
71174 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
71175 0 : std::cout << " not valid " << std::endl;
71176 : }
71177 : }
71178 :
71179 :
71180 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71181 :
71182 0 : }
71183 :
71184 :
71185 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
71186 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
71187 : bool
71188 0 : SgOmpTaskyieldStatement::isInMemoryPool ()
71189 : {
71190 0 : typedef unsigned char* TestType;
71191 :
71192 0 : bool found = false;
71193 :
71194 0 : ROSE_ASSERT(this != NULL);
71195 :
71196 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
71197 :
71198 0 : TestType tested = (TestType) ( this ) ;
71199 :
71200 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTaskyieldStatement::pools.begin();
71201 :
71202 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
71203 : // while (found == false && block < Memory_Block_List.end())
71204 0 : while ( (found == false) && (block != SgOmpTaskyieldStatement::pools.end()) )
71205 : {
71206 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTaskyieldStatement::pool_size * sizeof(SgOmpTaskyieldStatement) ) ) ;
71207 0 : ++block;
71208 : }
71209 :
71210 : // Special handling for static data
71211 :
71212 :
71213 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
71214 0 : ROSE_ASSERT(found == true);
71215 :
71216 0 : return found;
71217 : }
71218 : /* #line 71219 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
71219 :
71220 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
71221 :
71222 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71223 :
71224 : /* #line 71225 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
71225 :
71226 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71227 :
71228 : void
71229 0 : SgOmpBarrierStatement::checkDataMemberPointersIfInMemoryPool()
71230 : {
71231 : // ------------ checking pointers of SgOmpBarrierStatement -------------------
71232 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
71233 :
71234 0 : if ( p_upir_parent != NULL )
71235 : {
71236 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71237 : {
71238 0 : if ( p_upir_parent->isInMemoryPool() == false )
71239 : {
71240 0 : std::cout << "SgOmpBarrierStatement :: ";
71241 0 : std::cout << " p_upir_parent is not in memory pool of ";
71242 0 : std::cout << p_upir_parent->class_name() << std::endl;
71243 : }
71244 : }
71245 : else
71246 : {
71247 0 : std::cout << "SgOmpBarrierStatement :: " << std::flush;
71248 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
71249 0 : std::cout << " not valid " << std::endl;
71250 : }
71251 : }
71252 :
71253 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
71254 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
71255 : {
71256 0 : if ( (*i_upir_children) != NULL )
71257 : {
71258 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71259 : {
71260 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
71261 : {
71262 0 : std::cout << "SgOmpBarrierStatement :: ";
71263 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
71264 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
71265 : }
71266 : }
71267 : else
71268 : {
71269 0 : std::cout << "SgOmpBarrierStatement :: " << std::flush;
71270 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
71271 0 : std::cout << " entry not valid " << std::endl;
71272 : }
71273 : }
71274 : else
71275 : {
71276 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
71277 : }
71278 : }
71279 :
71280 0 : if ( p_numeric_label != NULL )
71281 : {
71282 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71283 : {
71284 0 : if ( p_numeric_label->isInMemoryPool() == false )
71285 : {
71286 0 : std::cout << "SgOmpBarrierStatement :: ";
71287 0 : std::cout << " p_numeric_label is not in memory pool of ";
71288 0 : std::cout << p_numeric_label->class_name() << std::endl;
71289 : }
71290 : }
71291 : else
71292 : {
71293 0 : std::cout << "SgOmpBarrierStatement :: " << std::flush;
71294 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
71295 0 : std::cout << " not valid " << std::endl;
71296 : }
71297 : }
71298 :
71299 0 : if ( p_startOfConstruct != NULL )
71300 : {
71301 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71302 : {
71303 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
71304 : {
71305 0 : std::cout << "SgOmpBarrierStatement :: ";
71306 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
71307 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
71308 : }
71309 : }
71310 : else
71311 : {
71312 0 : std::cout << "SgOmpBarrierStatement :: " << std::flush;
71313 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
71314 0 : std::cout << " not valid " << std::endl;
71315 : }
71316 : }
71317 :
71318 0 : if ( p_endOfConstruct != NULL )
71319 : {
71320 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71321 : {
71322 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
71323 : {
71324 0 : std::cout << "SgOmpBarrierStatement :: ";
71325 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
71326 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
71327 : }
71328 : }
71329 : else
71330 : {
71331 0 : std::cout << "SgOmpBarrierStatement :: " << std::flush;
71332 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
71333 0 : std::cout << " not valid " << std::endl;
71334 : }
71335 : }
71336 :
71337 0 : if ( p_parent != NULL )
71338 : {
71339 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71340 : {
71341 0 : if ( p_parent->isInMemoryPool() == false )
71342 : {
71343 0 : std::cout << "SgOmpBarrierStatement :: ";
71344 0 : std::cout << " p_parent is not in memory pool of ";
71345 0 : std::cout << p_parent->class_name() << std::endl;
71346 : }
71347 : }
71348 : else
71349 : {
71350 0 : std::cout << "SgOmpBarrierStatement :: " << std::flush;
71351 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
71352 0 : std::cout << " not valid " << std::endl;
71353 : }
71354 : }
71355 :
71356 :
71357 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71358 :
71359 0 : }
71360 :
71361 :
71362 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
71363 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
71364 : bool
71365 0 : SgOmpBarrierStatement::isInMemoryPool ()
71366 : {
71367 0 : typedef unsigned char* TestType;
71368 :
71369 0 : bool found = false;
71370 :
71371 0 : ROSE_ASSERT(this != NULL);
71372 :
71373 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
71374 :
71375 0 : TestType tested = (TestType) ( this ) ;
71376 :
71377 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpBarrierStatement::pools.begin();
71378 :
71379 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
71380 : // while (found == false && block < Memory_Block_List.end())
71381 0 : while ( (found == false) && (block != SgOmpBarrierStatement::pools.end()) )
71382 : {
71383 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpBarrierStatement::pool_size * sizeof(SgOmpBarrierStatement) ) ) ;
71384 0 : ++block;
71385 : }
71386 :
71387 : // Special handling for static data
71388 :
71389 :
71390 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
71391 0 : ROSE_ASSERT(found == true);
71392 :
71393 0 : return found;
71394 : }
71395 : /* #line 71396 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
71396 :
71397 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
71398 :
71399 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71400 :
71401 : /* #line 71402 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
71402 :
71403 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71404 :
71405 : void
71406 0 : SgUpirBodyStatement::checkDataMemberPointersIfInMemoryPool()
71407 : {
71408 : // ------------ checking pointers of SgUpirBodyStatement -------------------
71409 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
71410 :
71411 0 : if ( p_body != NULL )
71412 : {
71413 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71414 : {
71415 0 : if ( p_body->isInMemoryPool() == false )
71416 : {
71417 0 : std::cout << "SgUpirBodyStatement :: ";
71418 0 : std::cout << " p_body is not in memory pool of ";
71419 0 : std::cout << p_body->class_name() << std::endl;
71420 : }
71421 : }
71422 : else
71423 : {
71424 0 : std::cout << "SgUpirBodyStatement :: " << std::flush;
71425 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
71426 0 : std::cout << " not valid " << std::endl;
71427 : }
71428 : }
71429 :
71430 0 : if ( p_upir_parent != NULL )
71431 : {
71432 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71433 : {
71434 0 : if ( p_upir_parent->isInMemoryPool() == false )
71435 : {
71436 0 : std::cout << "SgUpirBodyStatement :: ";
71437 0 : std::cout << " p_upir_parent is not in memory pool of ";
71438 0 : std::cout << p_upir_parent->class_name() << std::endl;
71439 : }
71440 : }
71441 : else
71442 : {
71443 0 : std::cout << "SgUpirBodyStatement :: " << std::flush;
71444 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
71445 0 : std::cout << " not valid " << std::endl;
71446 : }
71447 : }
71448 :
71449 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
71450 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
71451 : {
71452 0 : if ( (*i_upir_children) != NULL )
71453 : {
71454 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71455 : {
71456 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
71457 : {
71458 0 : std::cout << "SgUpirBodyStatement :: ";
71459 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
71460 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
71461 : }
71462 : }
71463 : else
71464 : {
71465 0 : std::cout << "SgUpirBodyStatement :: " << std::flush;
71466 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
71467 0 : std::cout << " entry not valid " << std::endl;
71468 : }
71469 : }
71470 : else
71471 : {
71472 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
71473 : }
71474 : }
71475 :
71476 0 : if ( p_numeric_label != NULL )
71477 : {
71478 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71479 : {
71480 0 : if ( p_numeric_label->isInMemoryPool() == false )
71481 : {
71482 0 : std::cout << "SgUpirBodyStatement :: ";
71483 0 : std::cout << " p_numeric_label is not in memory pool of ";
71484 0 : std::cout << p_numeric_label->class_name() << std::endl;
71485 : }
71486 : }
71487 : else
71488 : {
71489 0 : std::cout << "SgUpirBodyStatement :: " << std::flush;
71490 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
71491 0 : std::cout << " not valid " << std::endl;
71492 : }
71493 : }
71494 :
71495 0 : if ( p_startOfConstruct != NULL )
71496 : {
71497 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71498 : {
71499 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
71500 : {
71501 0 : std::cout << "SgUpirBodyStatement :: ";
71502 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
71503 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
71504 : }
71505 : }
71506 : else
71507 : {
71508 0 : std::cout << "SgUpirBodyStatement :: " << std::flush;
71509 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
71510 0 : std::cout << " not valid " << std::endl;
71511 : }
71512 : }
71513 :
71514 0 : if ( p_endOfConstruct != NULL )
71515 : {
71516 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71517 : {
71518 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
71519 : {
71520 0 : std::cout << "SgUpirBodyStatement :: ";
71521 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
71522 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
71523 : }
71524 : }
71525 : else
71526 : {
71527 0 : std::cout << "SgUpirBodyStatement :: " << std::flush;
71528 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
71529 0 : std::cout << " not valid " << std::endl;
71530 : }
71531 : }
71532 :
71533 0 : if ( p_parent != NULL )
71534 : {
71535 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71536 : {
71537 0 : if ( p_parent->isInMemoryPool() == false )
71538 : {
71539 0 : std::cout << "SgUpirBodyStatement :: ";
71540 0 : std::cout << " p_parent is not in memory pool of ";
71541 0 : std::cout << p_parent->class_name() << std::endl;
71542 : }
71543 : }
71544 : else
71545 : {
71546 0 : std::cout << "SgUpirBodyStatement :: " << std::flush;
71547 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
71548 0 : std::cout << " not valid " << std::endl;
71549 : }
71550 : }
71551 :
71552 :
71553 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71554 :
71555 0 : }
71556 :
71557 :
71558 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
71559 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
71560 : bool
71561 0 : SgUpirBodyStatement::isInMemoryPool ()
71562 : {
71563 0 : typedef unsigned char* TestType;
71564 :
71565 0 : bool found = false;
71566 :
71567 0 : ROSE_ASSERT(this != NULL);
71568 :
71569 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
71570 :
71571 0 : TestType tested = (TestType) ( this ) ;
71572 :
71573 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirBodyStatement::pools.begin();
71574 :
71575 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
71576 : // while (found == false && block < Memory_Block_List.end())
71577 0 : while ( (found == false) && (block != SgUpirBodyStatement::pools.end()) )
71578 : {
71579 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirBodyStatement::pool_size * sizeof(SgUpirBodyStatement) ) ) ;
71580 0 : ++block;
71581 : }
71582 :
71583 : // Special handling for static data
71584 :
71585 :
71586 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
71587 0 : ROSE_ASSERT(found == true);
71588 :
71589 0 : return found;
71590 : }
71591 : /* #line 71592 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
71592 :
71593 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
71594 :
71595 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71596 :
71597 : /* #line 71598 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
71598 :
71599 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71600 :
71601 : void
71602 0 : SgOmpMasterStatement::checkDataMemberPointersIfInMemoryPool()
71603 : {
71604 : // ------------ checking pointers of SgOmpMasterStatement -------------------
71605 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
71606 :
71607 0 : if ( p_body != NULL )
71608 : {
71609 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71610 : {
71611 0 : if ( p_body->isInMemoryPool() == false )
71612 : {
71613 0 : std::cout << "SgOmpMasterStatement :: ";
71614 0 : std::cout << " p_body is not in memory pool of ";
71615 0 : std::cout << p_body->class_name() << std::endl;
71616 : }
71617 : }
71618 : else
71619 : {
71620 0 : std::cout << "SgOmpMasterStatement :: " << std::flush;
71621 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
71622 0 : std::cout << " not valid " << std::endl;
71623 : }
71624 : }
71625 :
71626 0 : if ( p_upir_parent != NULL )
71627 : {
71628 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71629 : {
71630 0 : if ( p_upir_parent->isInMemoryPool() == false )
71631 : {
71632 0 : std::cout << "SgOmpMasterStatement :: ";
71633 0 : std::cout << " p_upir_parent is not in memory pool of ";
71634 0 : std::cout << p_upir_parent->class_name() << std::endl;
71635 : }
71636 : }
71637 : else
71638 : {
71639 0 : std::cout << "SgOmpMasterStatement :: " << std::flush;
71640 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
71641 0 : std::cout << " not valid " << std::endl;
71642 : }
71643 : }
71644 :
71645 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
71646 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
71647 : {
71648 0 : if ( (*i_upir_children) != NULL )
71649 : {
71650 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71651 : {
71652 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
71653 : {
71654 0 : std::cout << "SgOmpMasterStatement :: ";
71655 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
71656 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
71657 : }
71658 : }
71659 : else
71660 : {
71661 0 : std::cout << "SgOmpMasterStatement :: " << std::flush;
71662 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
71663 0 : std::cout << " entry not valid " << std::endl;
71664 : }
71665 : }
71666 : else
71667 : {
71668 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
71669 : }
71670 : }
71671 :
71672 0 : if ( p_numeric_label != NULL )
71673 : {
71674 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71675 : {
71676 0 : if ( p_numeric_label->isInMemoryPool() == false )
71677 : {
71678 0 : std::cout << "SgOmpMasterStatement :: ";
71679 0 : std::cout << " p_numeric_label is not in memory pool of ";
71680 0 : std::cout << p_numeric_label->class_name() << std::endl;
71681 : }
71682 : }
71683 : else
71684 : {
71685 0 : std::cout << "SgOmpMasterStatement :: " << std::flush;
71686 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
71687 0 : std::cout << " not valid " << std::endl;
71688 : }
71689 : }
71690 :
71691 0 : if ( p_startOfConstruct != NULL )
71692 : {
71693 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71694 : {
71695 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
71696 : {
71697 0 : std::cout << "SgOmpMasterStatement :: ";
71698 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
71699 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
71700 : }
71701 : }
71702 : else
71703 : {
71704 0 : std::cout << "SgOmpMasterStatement :: " << std::flush;
71705 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
71706 0 : std::cout << " not valid " << std::endl;
71707 : }
71708 : }
71709 :
71710 0 : if ( p_endOfConstruct != NULL )
71711 : {
71712 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71713 : {
71714 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
71715 : {
71716 0 : std::cout << "SgOmpMasterStatement :: ";
71717 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
71718 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
71719 : }
71720 : }
71721 : else
71722 : {
71723 0 : std::cout << "SgOmpMasterStatement :: " << std::flush;
71724 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
71725 0 : std::cout << " not valid " << std::endl;
71726 : }
71727 : }
71728 :
71729 0 : if ( p_parent != NULL )
71730 : {
71731 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71732 : {
71733 0 : if ( p_parent->isInMemoryPool() == false )
71734 : {
71735 0 : std::cout << "SgOmpMasterStatement :: ";
71736 0 : std::cout << " p_parent is not in memory pool of ";
71737 0 : std::cout << p_parent->class_name() << std::endl;
71738 : }
71739 : }
71740 : else
71741 : {
71742 0 : std::cout << "SgOmpMasterStatement :: " << std::flush;
71743 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
71744 0 : std::cout << " not valid " << std::endl;
71745 : }
71746 : }
71747 :
71748 :
71749 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71750 :
71751 0 : }
71752 :
71753 :
71754 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
71755 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
71756 : bool
71757 0 : SgOmpMasterStatement::isInMemoryPool ()
71758 : {
71759 0 : typedef unsigned char* TestType;
71760 :
71761 0 : bool found = false;
71762 :
71763 0 : ROSE_ASSERT(this != NULL);
71764 :
71765 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
71766 :
71767 0 : TestType tested = (TestType) ( this ) ;
71768 :
71769 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpMasterStatement::pools.begin();
71770 :
71771 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
71772 : // while (found == false && block < Memory_Block_List.end())
71773 0 : while ( (found == false) && (block != SgOmpMasterStatement::pools.end()) )
71774 : {
71775 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpMasterStatement::pool_size * sizeof(SgOmpMasterStatement) ) ) ;
71776 0 : ++block;
71777 : }
71778 :
71779 : // Special handling for static data
71780 :
71781 :
71782 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
71783 0 : ROSE_ASSERT(found == true);
71784 :
71785 0 : return found;
71786 : }
71787 : /* #line 71788 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
71788 :
71789 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
71790 :
71791 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71792 :
71793 : /* #line 71794 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
71794 :
71795 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71796 :
71797 : void
71798 0 : SgOmpSectionStatement::checkDataMemberPointersIfInMemoryPool()
71799 : {
71800 : // ------------ checking pointers of SgOmpSectionStatement -------------------
71801 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
71802 :
71803 0 : if ( p_body != NULL )
71804 : {
71805 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71806 : {
71807 0 : if ( p_body->isInMemoryPool() == false )
71808 : {
71809 0 : std::cout << "SgOmpSectionStatement :: ";
71810 0 : std::cout << " p_body is not in memory pool of ";
71811 0 : std::cout << p_body->class_name() << std::endl;
71812 : }
71813 : }
71814 : else
71815 : {
71816 0 : std::cout << "SgOmpSectionStatement :: " << std::flush;
71817 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
71818 0 : std::cout << " not valid " << std::endl;
71819 : }
71820 : }
71821 :
71822 0 : if ( p_upir_parent != NULL )
71823 : {
71824 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71825 : {
71826 0 : if ( p_upir_parent->isInMemoryPool() == false )
71827 : {
71828 0 : std::cout << "SgOmpSectionStatement :: ";
71829 0 : std::cout << " p_upir_parent is not in memory pool of ";
71830 0 : std::cout << p_upir_parent->class_name() << std::endl;
71831 : }
71832 : }
71833 : else
71834 : {
71835 0 : std::cout << "SgOmpSectionStatement :: " << std::flush;
71836 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
71837 0 : std::cout << " not valid " << std::endl;
71838 : }
71839 : }
71840 :
71841 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
71842 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
71843 : {
71844 0 : if ( (*i_upir_children) != NULL )
71845 : {
71846 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71847 : {
71848 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
71849 : {
71850 0 : std::cout << "SgOmpSectionStatement :: ";
71851 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
71852 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
71853 : }
71854 : }
71855 : else
71856 : {
71857 0 : std::cout << "SgOmpSectionStatement :: " << std::flush;
71858 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
71859 0 : std::cout << " entry not valid " << std::endl;
71860 : }
71861 : }
71862 : else
71863 : {
71864 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
71865 : }
71866 : }
71867 :
71868 0 : if ( p_numeric_label != NULL )
71869 : {
71870 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71871 : {
71872 0 : if ( p_numeric_label->isInMemoryPool() == false )
71873 : {
71874 0 : std::cout << "SgOmpSectionStatement :: ";
71875 0 : std::cout << " p_numeric_label is not in memory pool of ";
71876 0 : std::cout << p_numeric_label->class_name() << std::endl;
71877 : }
71878 : }
71879 : else
71880 : {
71881 0 : std::cout << "SgOmpSectionStatement :: " << std::flush;
71882 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
71883 0 : std::cout << " not valid " << std::endl;
71884 : }
71885 : }
71886 :
71887 0 : if ( p_startOfConstruct != NULL )
71888 : {
71889 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71890 : {
71891 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
71892 : {
71893 0 : std::cout << "SgOmpSectionStatement :: ";
71894 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
71895 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
71896 : }
71897 : }
71898 : else
71899 : {
71900 0 : std::cout << "SgOmpSectionStatement :: " << std::flush;
71901 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
71902 0 : std::cout << " not valid " << std::endl;
71903 : }
71904 : }
71905 :
71906 0 : if ( p_endOfConstruct != NULL )
71907 : {
71908 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71909 : {
71910 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
71911 : {
71912 0 : std::cout << "SgOmpSectionStatement :: ";
71913 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
71914 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
71915 : }
71916 : }
71917 : else
71918 : {
71919 0 : std::cout << "SgOmpSectionStatement :: " << std::flush;
71920 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
71921 0 : std::cout << " not valid " << std::endl;
71922 : }
71923 : }
71924 :
71925 0 : if ( p_parent != NULL )
71926 : {
71927 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
71928 : {
71929 0 : if ( p_parent->isInMemoryPool() == false )
71930 : {
71931 0 : std::cout << "SgOmpSectionStatement :: ";
71932 0 : std::cout << " p_parent is not in memory pool of ";
71933 0 : std::cout << p_parent->class_name() << std::endl;
71934 : }
71935 : }
71936 : else
71937 : {
71938 0 : std::cout << "SgOmpSectionStatement :: " << std::flush;
71939 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
71940 0 : std::cout << " not valid " << std::endl;
71941 : }
71942 : }
71943 :
71944 :
71945 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71946 :
71947 0 : }
71948 :
71949 :
71950 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
71951 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
71952 : bool
71953 0 : SgOmpSectionStatement::isInMemoryPool ()
71954 : {
71955 0 : typedef unsigned char* TestType;
71956 :
71957 0 : bool found = false;
71958 :
71959 0 : ROSE_ASSERT(this != NULL);
71960 :
71961 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
71962 :
71963 0 : TestType tested = (TestType) ( this ) ;
71964 :
71965 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpSectionStatement::pools.begin();
71966 :
71967 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
71968 : // while (found == false && block < Memory_Block_List.end())
71969 0 : while ( (found == false) && (block != SgOmpSectionStatement::pools.end()) )
71970 : {
71971 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpSectionStatement::pool_size * sizeof(SgOmpSectionStatement) ) ) ;
71972 0 : ++block;
71973 : }
71974 :
71975 : // Special handling for static data
71976 :
71977 :
71978 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
71979 0 : ROSE_ASSERT(found == true);
71980 :
71981 0 : return found;
71982 : }
71983 : /* #line 71984 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
71984 :
71985 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
71986 :
71987 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71988 :
71989 : /* #line 71990 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
71990 :
71991 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
71992 :
71993 : void
71994 0 : SgOmpWorkshareStatement::checkDataMemberPointersIfInMemoryPool()
71995 : {
71996 : // ------------ checking pointers of SgOmpWorkshareStatement -------------------
71997 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
71998 :
71999 0 : if ( p_body != NULL )
72000 : {
72001 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72002 : {
72003 0 : if ( p_body->isInMemoryPool() == false )
72004 : {
72005 0 : std::cout << "SgOmpWorkshareStatement :: ";
72006 0 : std::cout << " p_body is not in memory pool of ";
72007 0 : std::cout << p_body->class_name() << std::endl;
72008 : }
72009 : }
72010 : else
72011 : {
72012 0 : std::cout << "SgOmpWorkshareStatement :: " << std::flush;
72013 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
72014 0 : std::cout << " not valid " << std::endl;
72015 : }
72016 : }
72017 :
72018 0 : if ( p_upir_parent != NULL )
72019 : {
72020 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72021 : {
72022 0 : if ( p_upir_parent->isInMemoryPool() == false )
72023 : {
72024 0 : std::cout << "SgOmpWorkshareStatement :: ";
72025 0 : std::cout << " p_upir_parent is not in memory pool of ";
72026 0 : std::cout << p_upir_parent->class_name() << std::endl;
72027 : }
72028 : }
72029 : else
72030 : {
72031 0 : std::cout << "SgOmpWorkshareStatement :: " << std::flush;
72032 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
72033 0 : std::cout << " not valid " << std::endl;
72034 : }
72035 : }
72036 :
72037 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
72038 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
72039 : {
72040 0 : if ( (*i_upir_children) != NULL )
72041 : {
72042 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72043 : {
72044 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
72045 : {
72046 0 : std::cout << "SgOmpWorkshareStatement :: ";
72047 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
72048 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
72049 : }
72050 : }
72051 : else
72052 : {
72053 0 : std::cout << "SgOmpWorkshareStatement :: " << std::flush;
72054 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
72055 0 : std::cout << " entry not valid " << std::endl;
72056 : }
72057 : }
72058 : else
72059 : {
72060 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
72061 : }
72062 : }
72063 :
72064 0 : if ( p_numeric_label != NULL )
72065 : {
72066 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72067 : {
72068 0 : if ( p_numeric_label->isInMemoryPool() == false )
72069 : {
72070 0 : std::cout << "SgOmpWorkshareStatement :: ";
72071 0 : std::cout << " p_numeric_label is not in memory pool of ";
72072 0 : std::cout << p_numeric_label->class_name() << std::endl;
72073 : }
72074 : }
72075 : else
72076 : {
72077 0 : std::cout << "SgOmpWorkshareStatement :: " << std::flush;
72078 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
72079 0 : std::cout << " not valid " << std::endl;
72080 : }
72081 : }
72082 :
72083 0 : if ( p_startOfConstruct != NULL )
72084 : {
72085 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72086 : {
72087 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
72088 : {
72089 0 : std::cout << "SgOmpWorkshareStatement :: ";
72090 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
72091 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
72092 : }
72093 : }
72094 : else
72095 : {
72096 0 : std::cout << "SgOmpWorkshareStatement :: " << std::flush;
72097 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
72098 0 : std::cout << " not valid " << std::endl;
72099 : }
72100 : }
72101 :
72102 0 : if ( p_endOfConstruct != NULL )
72103 : {
72104 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72105 : {
72106 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
72107 : {
72108 0 : std::cout << "SgOmpWorkshareStatement :: ";
72109 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
72110 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
72111 : }
72112 : }
72113 : else
72114 : {
72115 0 : std::cout << "SgOmpWorkshareStatement :: " << std::flush;
72116 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
72117 0 : std::cout << " not valid " << std::endl;
72118 : }
72119 : }
72120 :
72121 0 : if ( p_parent != NULL )
72122 : {
72123 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72124 : {
72125 0 : if ( p_parent->isInMemoryPool() == false )
72126 : {
72127 0 : std::cout << "SgOmpWorkshareStatement :: ";
72128 0 : std::cout << " p_parent is not in memory pool of ";
72129 0 : std::cout << p_parent->class_name() << std::endl;
72130 : }
72131 : }
72132 : else
72133 : {
72134 0 : std::cout << "SgOmpWorkshareStatement :: " << std::flush;
72135 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
72136 0 : std::cout << " not valid " << std::endl;
72137 : }
72138 : }
72139 :
72140 :
72141 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
72142 :
72143 0 : }
72144 :
72145 :
72146 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
72147 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
72148 : bool
72149 0 : SgOmpWorkshareStatement::isInMemoryPool ()
72150 : {
72151 0 : typedef unsigned char* TestType;
72152 :
72153 0 : bool found = false;
72154 :
72155 0 : ROSE_ASSERT(this != NULL);
72156 :
72157 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
72158 :
72159 0 : TestType tested = (TestType) ( this ) ;
72160 :
72161 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpWorkshareStatement::pools.begin();
72162 :
72163 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
72164 : // while (found == false && block < Memory_Block_List.end())
72165 0 : while ( (found == false) && (block != SgOmpWorkshareStatement::pools.end()) )
72166 : {
72167 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpWorkshareStatement::pool_size * sizeof(SgOmpWorkshareStatement) ) ) ;
72168 0 : ++block;
72169 : }
72170 :
72171 : // Special handling for static data
72172 :
72173 :
72174 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
72175 0 : ROSE_ASSERT(found == true);
72176 :
72177 0 : return found;
72178 : }
72179 : /* #line 72180 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
72180 :
72181 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
72182 :
72183 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
72184 :
72185 : /* #line 72186 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
72186 :
72187 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
72188 :
72189 : void
72190 0 : SgUpirFieldBodyStatement::checkDataMemberPointersIfInMemoryPool()
72191 : {
72192 : // ------------ checking pointers of SgUpirFieldBodyStatement -------------------
72193 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
72194 :
72195 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
72196 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
72197 : {
72198 0 : if ( (*i_clauses) != NULL )
72199 : {
72200 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72201 : {
72202 0 : if ( (*i_clauses)->isInMemoryPool() == false )
72203 : {
72204 0 : std::cout << "SgUpirFieldBodyStatement :: ";
72205 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
72206 0 : std::cout << (*i_clauses)->class_name() << std::endl;
72207 : }
72208 : }
72209 : else
72210 : {
72211 0 : std::cout << "SgUpirFieldBodyStatement :: " << std::flush;
72212 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
72213 0 : std::cout << " entry not valid " << std::endl;
72214 : }
72215 : }
72216 : else
72217 : {
72218 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
72219 : }
72220 : }
72221 :
72222 0 : if ( p_body != NULL )
72223 : {
72224 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72225 : {
72226 0 : if ( p_body->isInMemoryPool() == false )
72227 : {
72228 0 : std::cout << "SgUpirFieldBodyStatement :: ";
72229 0 : std::cout << " p_body is not in memory pool of ";
72230 0 : std::cout << p_body->class_name() << std::endl;
72231 : }
72232 : }
72233 : else
72234 : {
72235 0 : std::cout << "SgUpirFieldBodyStatement :: " << std::flush;
72236 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
72237 0 : std::cout << " not valid " << std::endl;
72238 : }
72239 : }
72240 :
72241 0 : if ( p_upir_parent != NULL )
72242 : {
72243 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72244 : {
72245 0 : if ( p_upir_parent->isInMemoryPool() == false )
72246 : {
72247 0 : std::cout << "SgUpirFieldBodyStatement :: ";
72248 0 : std::cout << " p_upir_parent is not in memory pool of ";
72249 0 : std::cout << p_upir_parent->class_name() << std::endl;
72250 : }
72251 : }
72252 : else
72253 : {
72254 0 : std::cout << "SgUpirFieldBodyStatement :: " << std::flush;
72255 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
72256 0 : std::cout << " not valid " << std::endl;
72257 : }
72258 : }
72259 :
72260 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
72261 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
72262 : {
72263 0 : if ( (*i_upir_children) != NULL )
72264 : {
72265 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72266 : {
72267 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
72268 : {
72269 0 : std::cout << "SgUpirFieldBodyStatement :: ";
72270 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
72271 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
72272 : }
72273 : }
72274 : else
72275 : {
72276 0 : std::cout << "SgUpirFieldBodyStatement :: " << std::flush;
72277 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
72278 0 : std::cout << " entry not valid " << std::endl;
72279 : }
72280 : }
72281 : else
72282 : {
72283 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
72284 : }
72285 : }
72286 :
72287 0 : if ( p_numeric_label != NULL )
72288 : {
72289 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72290 : {
72291 0 : if ( p_numeric_label->isInMemoryPool() == false )
72292 : {
72293 0 : std::cout << "SgUpirFieldBodyStatement :: ";
72294 0 : std::cout << " p_numeric_label is not in memory pool of ";
72295 0 : std::cout << p_numeric_label->class_name() << std::endl;
72296 : }
72297 : }
72298 : else
72299 : {
72300 0 : std::cout << "SgUpirFieldBodyStatement :: " << std::flush;
72301 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
72302 0 : std::cout << " not valid " << std::endl;
72303 : }
72304 : }
72305 :
72306 0 : if ( p_startOfConstruct != NULL )
72307 : {
72308 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72309 : {
72310 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
72311 : {
72312 0 : std::cout << "SgUpirFieldBodyStatement :: ";
72313 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
72314 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
72315 : }
72316 : }
72317 : else
72318 : {
72319 0 : std::cout << "SgUpirFieldBodyStatement :: " << std::flush;
72320 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
72321 0 : std::cout << " not valid " << std::endl;
72322 : }
72323 : }
72324 :
72325 0 : if ( p_endOfConstruct != NULL )
72326 : {
72327 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72328 : {
72329 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
72330 : {
72331 0 : std::cout << "SgUpirFieldBodyStatement :: ";
72332 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
72333 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
72334 : }
72335 : }
72336 : else
72337 : {
72338 0 : std::cout << "SgUpirFieldBodyStatement :: " << std::flush;
72339 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
72340 0 : std::cout << " not valid " << std::endl;
72341 : }
72342 : }
72343 :
72344 0 : if ( p_parent != NULL )
72345 : {
72346 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72347 : {
72348 0 : if ( p_parent->isInMemoryPool() == false )
72349 : {
72350 0 : std::cout << "SgUpirFieldBodyStatement :: ";
72351 0 : std::cout << " p_parent is not in memory pool of ";
72352 0 : std::cout << p_parent->class_name() << std::endl;
72353 : }
72354 : }
72355 : else
72356 : {
72357 0 : std::cout << "SgUpirFieldBodyStatement :: " << std::flush;
72358 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
72359 0 : std::cout << " not valid " << std::endl;
72360 : }
72361 : }
72362 :
72363 :
72364 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
72365 :
72366 0 : }
72367 :
72368 :
72369 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
72370 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
72371 : bool
72372 0 : SgUpirFieldBodyStatement::isInMemoryPool ()
72373 : {
72374 0 : typedef unsigned char* TestType;
72375 :
72376 0 : bool found = false;
72377 :
72378 0 : ROSE_ASSERT(this != NULL);
72379 :
72380 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
72381 :
72382 0 : TestType tested = (TestType) ( this ) ;
72383 :
72384 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirFieldBodyStatement::pools.begin();
72385 :
72386 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
72387 : // while (found == false && block < Memory_Block_List.end())
72388 0 : while ( (found == false) && (block != SgUpirFieldBodyStatement::pools.end()) )
72389 : {
72390 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirFieldBodyStatement::pool_size * sizeof(SgUpirFieldBodyStatement) ) ) ;
72391 0 : ++block;
72392 : }
72393 :
72394 : // Special handling for static data
72395 :
72396 :
72397 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
72398 0 : ROSE_ASSERT(found == true);
72399 :
72400 0 : return found;
72401 : }
72402 : /* #line 72403 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
72403 :
72404 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
72405 :
72406 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
72407 :
72408 : /* #line 72409 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
72409 :
72410 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
72411 :
72412 : void
72413 0 : SgUpirSpmdStatement::checkDataMemberPointersIfInMemoryPool()
72414 : {
72415 : // ------------ checking pointers of SgUpirSpmdStatement -------------------
72416 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
72417 :
72418 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
72419 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
72420 : {
72421 0 : if ( (*i_clauses) != NULL )
72422 : {
72423 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72424 : {
72425 0 : if ( (*i_clauses)->isInMemoryPool() == false )
72426 : {
72427 0 : std::cout << "SgUpirSpmdStatement :: ";
72428 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
72429 0 : std::cout << (*i_clauses)->class_name() << std::endl;
72430 : }
72431 : }
72432 : else
72433 : {
72434 0 : std::cout << "SgUpirSpmdStatement :: " << std::flush;
72435 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
72436 0 : std::cout << " entry not valid " << std::endl;
72437 : }
72438 : }
72439 : else
72440 : {
72441 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
72442 : }
72443 : }
72444 :
72445 0 : if ( p_body != NULL )
72446 : {
72447 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72448 : {
72449 0 : if ( p_body->isInMemoryPool() == false )
72450 : {
72451 0 : std::cout << "SgUpirSpmdStatement :: ";
72452 0 : std::cout << " p_body is not in memory pool of ";
72453 0 : std::cout << p_body->class_name() << std::endl;
72454 : }
72455 : }
72456 : else
72457 : {
72458 0 : std::cout << "SgUpirSpmdStatement :: " << std::flush;
72459 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
72460 0 : std::cout << " not valid " << std::endl;
72461 : }
72462 : }
72463 :
72464 0 : if ( p_upir_parent != NULL )
72465 : {
72466 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72467 : {
72468 0 : if ( p_upir_parent->isInMemoryPool() == false )
72469 : {
72470 0 : std::cout << "SgUpirSpmdStatement :: ";
72471 0 : std::cout << " p_upir_parent is not in memory pool of ";
72472 0 : std::cout << p_upir_parent->class_name() << std::endl;
72473 : }
72474 : }
72475 : else
72476 : {
72477 0 : std::cout << "SgUpirSpmdStatement :: " << std::flush;
72478 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
72479 0 : std::cout << " not valid " << std::endl;
72480 : }
72481 : }
72482 :
72483 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
72484 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
72485 : {
72486 0 : if ( (*i_upir_children) != NULL )
72487 : {
72488 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72489 : {
72490 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
72491 : {
72492 0 : std::cout << "SgUpirSpmdStatement :: ";
72493 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
72494 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
72495 : }
72496 : }
72497 : else
72498 : {
72499 0 : std::cout << "SgUpirSpmdStatement :: " << std::flush;
72500 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
72501 0 : std::cout << " entry not valid " << std::endl;
72502 : }
72503 : }
72504 : else
72505 : {
72506 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
72507 : }
72508 : }
72509 :
72510 0 : if ( p_numeric_label != NULL )
72511 : {
72512 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72513 : {
72514 0 : if ( p_numeric_label->isInMemoryPool() == false )
72515 : {
72516 0 : std::cout << "SgUpirSpmdStatement :: ";
72517 0 : std::cout << " p_numeric_label is not in memory pool of ";
72518 0 : std::cout << p_numeric_label->class_name() << std::endl;
72519 : }
72520 : }
72521 : else
72522 : {
72523 0 : std::cout << "SgUpirSpmdStatement :: " << std::flush;
72524 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
72525 0 : std::cout << " not valid " << std::endl;
72526 : }
72527 : }
72528 :
72529 0 : if ( p_startOfConstruct != NULL )
72530 : {
72531 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72532 : {
72533 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
72534 : {
72535 0 : std::cout << "SgUpirSpmdStatement :: ";
72536 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
72537 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
72538 : }
72539 : }
72540 : else
72541 : {
72542 0 : std::cout << "SgUpirSpmdStatement :: " << std::flush;
72543 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
72544 0 : std::cout << " not valid " << std::endl;
72545 : }
72546 : }
72547 :
72548 0 : if ( p_endOfConstruct != NULL )
72549 : {
72550 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72551 : {
72552 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
72553 : {
72554 0 : std::cout << "SgUpirSpmdStatement :: ";
72555 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
72556 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
72557 : }
72558 : }
72559 : else
72560 : {
72561 0 : std::cout << "SgUpirSpmdStatement :: " << std::flush;
72562 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
72563 0 : std::cout << " not valid " << std::endl;
72564 : }
72565 : }
72566 :
72567 0 : if ( p_parent != NULL )
72568 : {
72569 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72570 : {
72571 0 : if ( p_parent->isInMemoryPool() == false )
72572 : {
72573 0 : std::cout << "SgUpirSpmdStatement :: ";
72574 0 : std::cout << " p_parent is not in memory pool of ";
72575 0 : std::cout << p_parent->class_name() << std::endl;
72576 : }
72577 : }
72578 : else
72579 : {
72580 0 : std::cout << "SgUpirSpmdStatement :: " << std::flush;
72581 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
72582 0 : std::cout << " not valid " << std::endl;
72583 : }
72584 : }
72585 :
72586 :
72587 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
72588 :
72589 0 : }
72590 :
72591 :
72592 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
72593 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
72594 : bool
72595 0 : SgUpirSpmdStatement::isInMemoryPool ()
72596 : {
72597 0 : typedef unsigned char* TestType;
72598 :
72599 0 : bool found = false;
72600 :
72601 0 : ROSE_ASSERT(this != NULL);
72602 :
72603 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
72604 :
72605 0 : TestType tested = (TestType) ( this ) ;
72606 :
72607 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirSpmdStatement::pools.begin();
72608 :
72609 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
72610 : // while (found == false && block < Memory_Block_List.end())
72611 0 : while ( (found == false) && (block != SgUpirSpmdStatement::pools.end()) )
72612 : {
72613 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirSpmdStatement::pool_size * sizeof(SgUpirSpmdStatement) ) ) ;
72614 0 : ++block;
72615 : }
72616 :
72617 : // Special handling for static data
72618 :
72619 :
72620 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
72621 0 : ROSE_ASSERT(found == true);
72622 :
72623 0 : return found;
72624 : }
72625 : /* #line 72626 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
72626 :
72627 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
72628 :
72629 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
72630 :
72631 : /* #line 72632 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
72632 :
72633 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
72634 :
72635 : void
72636 0 : SgOmpTeamsStatement::checkDataMemberPointersIfInMemoryPool()
72637 : {
72638 : // ------------ checking pointers of SgOmpTeamsStatement -------------------
72639 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
72640 :
72641 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
72642 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
72643 : {
72644 0 : if ( (*i_clauses) != NULL )
72645 : {
72646 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72647 : {
72648 0 : if ( (*i_clauses)->isInMemoryPool() == false )
72649 : {
72650 0 : std::cout << "SgOmpTeamsStatement :: ";
72651 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
72652 0 : std::cout << (*i_clauses)->class_name() << std::endl;
72653 : }
72654 : }
72655 : else
72656 : {
72657 0 : std::cout << "SgOmpTeamsStatement :: " << std::flush;
72658 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
72659 0 : std::cout << " entry not valid " << std::endl;
72660 : }
72661 : }
72662 : else
72663 : {
72664 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
72665 : }
72666 : }
72667 :
72668 0 : if ( p_body != NULL )
72669 : {
72670 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72671 : {
72672 0 : if ( p_body->isInMemoryPool() == false )
72673 : {
72674 0 : std::cout << "SgOmpTeamsStatement :: ";
72675 0 : std::cout << " p_body is not in memory pool of ";
72676 0 : std::cout << p_body->class_name() << std::endl;
72677 : }
72678 : }
72679 : else
72680 : {
72681 0 : std::cout << "SgOmpTeamsStatement :: " << std::flush;
72682 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
72683 0 : std::cout << " not valid " << std::endl;
72684 : }
72685 : }
72686 :
72687 0 : if ( p_upir_parent != NULL )
72688 : {
72689 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72690 : {
72691 0 : if ( p_upir_parent->isInMemoryPool() == false )
72692 : {
72693 0 : std::cout << "SgOmpTeamsStatement :: ";
72694 0 : std::cout << " p_upir_parent is not in memory pool of ";
72695 0 : std::cout << p_upir_parent->class_name() << std::endl;
72696 : }
72697 : }
72698 : else
72699 : {
72700 0 : std::cout << "SgOmpTeamsStatement :: " << std::flush;
72701 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
72702 0 : std::cout << " not valid " << std::endl;
72703 : }
72704 : }
72705 :
72706 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
72707 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
72708 : {
72709 0 : if ( (*i_upir_children) != NULL )
72710 : {
72711 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72712 : {
72713 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
72714 : {
72715 0 : std::cout << "SgOmpTeamsStatement :: ";
72716 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
72717 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
72718 : }
72719 : }
72720 : else
72721 : {
72722 0 : std::cout << "SgOmpTeamsStatement :: " << std::flush;
72723 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
72724 0 : std::cout << " entry not valid " << std::endl;
72725 : }
72726 : }
72727 : else
72728 : {
72729 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
72730 : }
72731 : }
72732 :
72733 0 : if ( p_numeric_label != NULL )
72734 : {
72735 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72736 : {
72737 0 : if ( p_numeric_label->isInMemoryPool() == false )
72738 : {
72739 0 : std::cout << "SgOmpTeamsStatement :: ";
72740 0 : std::cout << " p_numeric_label is not in memory pool of ";
72741 0 : std::cout << p_numeric_label->class_name() << std::endl;
72742 : }
72743 : }
72744 : else
72745 : {
72746 0 : std::cout << "SgOmpTeamsStatement :: " << std::flush;
72747 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
72748 0 : std::cout << " not valid " << std::endl;
72749 : }
72750 : }
72751 :
72752 0 : if ( p_startOfConstruct != NULL )
72753 : {
72754 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72755 : {
72756 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
72757 : {
72758 0 : std::cout << "SgOmpTeamsStatement :: ";
72759 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
72760 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
72761 : }
72762 : }
72763 : else
72764 : {
72765 0 : std::cout << "SgOmpTeamsStatement :: " << std::flush;
72766 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
72767 0 : std::cout << " not valid " << std::endl;
72768 : }
72769 : }
72770 :
72771 0 : if ( p_endOfConstruct != NULL )
72772 : {
72773 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72774 : {
72775 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
72776 : {
72777 0 : std::cout << "SgOmpTeamsStatement :: ";
72778 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
72779 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
72780 : }
72781 : }
72782 : else
72783 : {
72784 0 : std::cout << "SgOmpTeamsStatement :: " << std::flush;
72785 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
72786 0 : std::cout << " not valid " << std::endl;
72787 : }
72788 : }
72789 :
72790 0 : if ( p_parent != NULL )
72791 : {
72792 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72793 : {
72794 0 : if ( p_parent->isInMemoryPool() == false )
72795 : {
72796 0 : std::cout << "SgOmpTeamsStatement :: ";
72797 0 : std::cout << " p_parent is not in memory pool of ";
72798 0 : std::cout << p_parent->class_name() << std::endl;
72799 : }
72800 : }
72801 : else
72802 : {
72803 0 : std::cout << "SgOmpTeamsStatement :: " << std::flush;
72804 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
72805 0 : std::cout << " not valid " << std::endl;
72806 : }
72807 : }
72808 :
72809 :
72810 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
72811 :
72812 0 : }
72813 :
72814 :
72815 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
72816 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
72817 : bool
72818 0 : SgOmpTeamsStatement::isInMemoryPool ()
72819 : {
72820 0 : typedef unsigned char* TestType;
72821 :
72822 0 : bool found = false;
72823 :
72824 0 : ROSE_ASSERT(this != NULL);
72825 :
72826 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
72827 :
72828 0 : TestType tested = (TestType) ( this ) ;
72829 :
72830 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTeamsStatement::pools.begin();
72831 :
72832 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
72833 : // while (found == false && block < Memory_Block_List.end())
72834 0 : while ( (found == false) && (block != SgOmpTeamsStatement::pools.end()) )
72835 : {
72836 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTeamsStatement::pool_size * sizeof(SgOmpTeamsStatement) ) ) ;
72837 0 : ++block;
72838 : }
72839 :
72840 : // Special handling for static data
72841 :
72842 :
72843 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
72844 0 : ROSE_ASSERT(found == true);
72845 :
72846 0 : return found;
72847 : }
72848 : /* #line 72849 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
72849 :
72850 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
72851 :
72852 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
72853 :
72854 : /* #line 72855 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
72855 :
72856 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
72857 :
72858 : void
72859 0 : SgOmpSingleStatement::checkDataMemberPointersIfInMemoryPool()
72860 : {
72861 : // ------------ checking pointers of SgOmpSingleStatement -------------------
72862 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
72863 :
72864 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
72865 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
72866 : {
72867 0 : if ( (*i_clauses) != NULL )
72868 : {
72869 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72870 : {
72871 0 : if ( (*i_clauses)->isInMemoryPool() == false )
72872 : {
72873 0 : std::cout << "SgOmpSingleStatement :: ";
72874 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
72875 0 : std::cout << (*i_clauses)->class_name() << std::endl;
72876 : }
72877 : }
72878 : else
72879 : {
72880 0 : std::cout << "SgOmpSingleStatement :: " << std::flush;
72881 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
72882 0 : std::cout << " entry not valid " << std::endl;
72883 : }
72884 : }
72885 : else
72886 : {
72887 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
72888 : }
72889 : }
72890 :
72891 0 : if ( p_body != NULL )
72892 : {
72893 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72894 : {
72895 0 : if ( p_body->isInMemoryPool() == false )
72896 : {
72897 0 : std::cout << "SgOmpSingleStatement :: ";
72898 0 : std::cout << " p_body is not in memory pool of ";
72899 0 : std::cout << p_body->class_name() << std::endl;
72900 : }
72901 : }
72902 : else
72903 : {
72904 0 : std::cout << "SgOmpSingleStatement :: " << std::flush;
72905 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
72906 0 : std::cout << " not valid " << std::endl;
72907 : }
72908 : }
72909 :
72910 0 : if ( p_upir_parent != NULL )
72911 : {
72912 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72913 : {
72914 0 : if ( p_upir_parent->isInMemoryPool() == false )
72915 : {
72916 0 : std::cout << "SgOmpSingleStatement :: ";
72917 0 : std::cout << " p_upir_parent is not in memory pool of ";
72918 0 : std::cout << p_upir_parent->class_name() << std::endl;
72919 : }
72920 : }
72921 : else
72922 : {
72923 0 : std::cout << "SgOmpSingleStatement :: " << std::flush;
72924 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
72925 0 : std::cout << " not valid " << std::endl;
72926 : }
72927 : }
72928 :
72929 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
72930 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
72931 : {
72932 0 : if ( (*i_upir_children) != NULL )
72933 : {
72934 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72935 : {
72936 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
72937 : {
72938 0 : std::cout << "SgOmpSingleStatement :: ";
72939 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
72940 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
72941 : }
72942 : }
72943 : else
72944 : {
72945 0 : std::cout << "SgOmpSingleStatement :: " << std::flush;
72946 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
72947 0 : std::cout << " entry not valid " << std::endl;
72948 : }
72949 : }
72950 : else
72951 : {
72952 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
72953 : }
72954 : }
72955 :
72956 0 : if ( p_numeric_label != NULL )
72957 : {
72958 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72959 : {
72960 0 : if ( p_numeric_label->isInMemoryPool() == false )
72961 : {
72962 0 : std::cout << "SgOmpSingleStatement :: ";
72963 0 : std::cout << " p_numeric_label is not in memory pool of ";
72964 0 : std::cout << p_numeric_label->class_name() << std::endl;
72965 : }
72966 : }
72967 : else
72968 : {
72969 0 : std::cout << "SgOmpSingleStatement :: " << std::flush;
72970 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
72971 0 : std::cout << " not valid " << std::endl;
72972 : }
72973 : }
72974 :
72975 0 : if ( p_startOfConstruct != NULL )
72976 : {
72977 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72978 : {
72979 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
72980 : {
72981 0 : std::cout << "SgOmpSingleStatement :: ";
72982 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
72983 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
72984 : }
72985 : }
72986 : else
72987 : {
72988 0 : std::cout << "SgOmpSingleStatement :: " << std::flush;
72989 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
72990 0 : std::cout << " not valid " << std::endl;
72991 : }
72992 : }
72993 :
72994 0 : if ( p_endOfConstruct != NULL )
72995 : {
72996 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
72997 : {
72998 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
72999 : {
73000 0 : std::cout << "SgOmpSingleStatement :: ";
73001 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
73002 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
73003 : }
73004 : }
73005 : else
73006 : {
73007 0 : std::cout << "SgOmpSingleStatement :: " << std::flush;
73008 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
73009 0 : std::cout << " not valid " << std::endl;
73010 : }
73011 : }
73012 :
73013 0 : if ( p_parent != NULL )
73014 : {
73015 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73016 : {
73017 0 : if ( p_parent->isInMemoryPool() == false )
73018 : {
73019 0 : std::cout << "SgOmpSingleStatement :: ";
73020 0 : std::cout << " p_parent is not in memory pool of ";
73021 0 : std::cout << p_parent->class_name() << std::endl;
73022 : }
73023 : }
73024 : else
73025 : {
73026 0 : std::cout << "SgOmpSingleStatement :: " << std::flush;
73027 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
73028 0 : std::cout << " not valid " << std::endl;
73029 : }
73030 : }
73031 :
73032 :
73033 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
73034 :
73035 0 : }
73036 :
73037 :
73038 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
73039 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
73040 : bool
73041 0 : SgOmpSingleStatement::isInMemoryPool ()
73042 : {
73043 0 : typedef unsigned char* TestType;
73044 :
73045 0 : bool found = false;
73046 :
73047 0 : ROSE_ASSERT(this != NULL);
73048 :
73049 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
73050 :
73051 0 : TestType tested = (TestType) ( this ) ;
73052 :
73053 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpSingleStatement::pools.begin();
73054 :
73055 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
73056 : // while (found == false && block < Memory_Block_List.end())
73057 0 : while ( (found == false) && (block != SgOmpSingleStatement::pools.end()) )
73058 : {
73059 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpSingleStatement::pool_size * sizeof(SgOmpSingleStatement) ) ) ;
73060 0 : ++block;
73061 : }
73062 :
73063 : // Special handling for static data
73064 :
73065 :
73066 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
73067 0 : ROSE_ASSERT(found == true);
73068 :
73069 0 : return found;
73070 : }
73071 : /* #line 73072 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
73072 :
73073 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
73074 :
73075 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
73076 :
73077 : /* #line 73078 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
73078 :
73079 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
73080 :
73081 : void
73082 0 : SgOmpAtomicStatement::checkDataMemberPointersIfInMemoryPool()
73083 : {
73084 : // ------------ checking pointers of SgOmpAtomicStatement -------------------
73085 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
73086 :
73087 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
73088 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
73089 : {
73090 0 : if ( (*i_clauses) != NULL )
73091 : {
73092 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73093 : {
73094 0 : if ( (*i_clauses)->isInMemoryPool() == false )
73095 : {
73096 0 : std::cout << "SgOmpAtomicStatement :: ";
73097 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
73098 0 : std::cout << (*i_clauses)->class_name() << std::endl;
73099 : }
73100 : }
73101 : else
73102 : {
73103 0 : std::cout << "SgOmpAtomicStatement :: " << std::flush;
73104 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
73105 0 : std::cout << " entry not valid " << std::endl;
73106 : }
73107 : }
73108 : else
73109 : {
73110 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
73111 : }
73112 : }
73113 :
73114 0 : if ( p_body != NULL )
73115 : {
73116 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73117 : {
73118 0 : if ( p_body->isInMemoryPool() == false )
73119 : {
73120 0 : std::cout << "SgOmpAtomicStatement :: ";
73121 0 : std::cout << " p_body is not in memory pool of ";
73122 0 : std::cout << p_body->class_name() << std::endl;
73123 : }
73124 : }
73125 : else
73126 : {
73127 0 : std::cout << "SgOmpAtomicStatement :: " << std::flush;
73128 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
73129 0 : std::cout << " not valid " << std::endl;
73130 : }
73131 : }
73132 :
73133 0 : if ( p_upir_parent != NULL )
73134 : {
73135 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73136 : {
73137 0 : if ( p_upir_parent->isInMemoryPool() == false )
73138 : {
73139 0 : std::cout << "SgOmpAtomicStatement :: ";
73140 0 : std::cout << " p_upir_parent is not in memory pool of ";
73141 0 : std::cout << p_upir_parent->class_name() << std::endl;
73142 : }
73143 : }
73144 : else
73145 : {
73146 0 : std::cout << "SgOmpAtomicStatement :: " << std::flush;
73147 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
73148 0 : std::cout << " not valid " << std::endl;
73149 : }
73150 : }
73151 :
73152 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
73153 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
73154 : {
73155 0 : if ( (*i_upir_children) != NULL )
73156 : {
73157 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73158 : {
73159 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
73160 : {
73161 0 : std::cout << "SgOmpAtomicStatement :: ";
73162 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
73163 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
73164 : }
73165 : }
73166 : else
73167 : {
73168 0 : std::cout << "SgOmpAtomicStatement :: " << std::flush;
73169 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
73170 0 : std::cout << " entry not valid " << std::endl;
73171 : }
73172 : }
73173 : else
73174 : {
73175 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
73176 : }
73177 : }
73178 :
73179 0 : if ( p_numeric_label != NULL )
73180 : {
73181 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73182 : {
73183 0 : if ( p_numeric_label->isInMemoryPool() == false )
73184 : {
73185 0 : std::cout << "SgOmpAtomicStatement :: ";
73186 0 : std::cout << " p_numeric_label is not in memory pool of ";
73187 0 : std::cout << p_numeric_label->class_name() << std::endl;
73188 : }
73189 : }
73190 : else
73191 : {
73192 0 : std::cout << "SgOmpAtomicStatement :: " << std::flush;
73193 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
73194 0 : std::cout << " not valid " << std::endl;
73195 : }
73196 : }
73197 :
73198 0 : if ( p_startOfConstruct != NULL )
73199 : {
73200 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73201 : {
73202 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
73203 : {
73204 0 : std::cout << "SgOmpAtomicStatement :: ";
73205 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
73206 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
73207 : }
73208 : }
73209 : else
73210 : {
73211 0 : std::cout << "SgOmpAtomicStatement :: " << std::flush;
73212 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
73213 0 : std::cout << " not valid " << std::endl;
73214 : }
73215 : }
73216 :
73217 0 : if ( p_endOfConstruct != NULL )
73218 : {
73219 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73220 : {
73221 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
73222 : {
73223 0 : std::cout << "SgOmpAtomicStatement :: ";
73224 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
73225 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
73226 : }
73227 : }
73228 : else
73229 : {
73230 0 : std::cout << "SgOmpAtomicStatement :: " << std::flush;
73231 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
73232 0 : std::cout << " not valid " << std::endl;
73233 : }
73234 : }
73235 :
73236 0 : if ( p_parent != NULL )
73237 : {
73238 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73239 : {
73240 0 : if ( p_parent->isInMemoryPool() == false )
73241 : {
73242 0 : std::cout << "SgOmpAtomicStatement :: ";
73243 0 : std::cout << " p_parent is not in memory pool of ";
73244 0 : std::cout << p_parent->class_name() << std::endl;
73245 : }
73246 : }
73247 : else
73248 : {
73249 0 : std::cout << "SgOmpAtomicStatement :: " << std::flush;
73250 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
73251 0 : std::cout << " not valid " << std::endl;
73252 : }
73253 : }
73254 :
73255 :
73256 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
73257 :
73258 0 : }
73259 :
73260 :
73261 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
73262 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
73263 : bool
73264 0 : SgOmpAtomicStatement::isInMemoryPool ()
73265 : {
73266 0 : typedef unsigned char* TestType;
73267 :
73268 0 : bool found = false;
73269 :
73270 0 : ROSE_ASSERT(this != NULL);
73271 :
73272 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
73273 :
73274 0 : TestType tested = (TestType) ( this ) ;
73275 :
73276 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpAtomicStatement::pools.begin();
73277 :
73278 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
73279 : // while (found == false && block < Memory_Block_List.end())
73280 0 : while ( (found == false) && (block != SgOmpAtomicStatement::pools.end()) )
73281 : {
73282 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpAtomicStatement::pool_size * sizeof(SgOmpAtomicStatement) ) ) ;
73283 0 : ++block;
73284 : }
73285 :
73286 : // Special handling for static data
73287 :
73288 :
73289 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
73290 0 : ROSE_ASSERT(found == true);
73291 :
73292 0 : return found;
73293 : }
73294 : /* #line 73295 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
73295 :
73296 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
73297 :
73298 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
73299 :
73300 : /* #line 73301 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
73301 :
73302 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
73303 :
73304 : void
73305 0 : SgOmpScanStatement::checkDataMemberPointersIfInMemoryPool()
73306 : {
73307 : // ------------ checking pointers of SgOmpScanStatement -------------------
73308 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
73309 :
73310 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
73311 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
73312 : {
73313 0 : if ( (*i_clauses) != NULL )
73314 : {
73315 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73316 : {
73317 0 : if ( (*i_clauses)->isInMemoryPool() == false )
73318 : {
73319 0 : std::cout << "SgOmpScanStatement :: ";
73320 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
73321 0 : std::cout << (*i_clauses)->class_name() << std::endl;
73322 : }
73323 : }
73324 : else
73325 : {
73326 0 : std::cout << "SgOmpScanStatement :: " << std::flush;
73327 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
73328 0 : std::cout << " entry not valid " << std::endl;
73329 : }
73330 : }
73331 : else
73332 : {
73333 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
73334 : }
73335 : }
73336 :
73337 0 : if ( p_body != NULL )
73338 : {
73339 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73340 : {
73341 0 : if ( p_body->isInMemoryPool() == false )
73342 : {
73343 0 : std::cout << "SgOmpScanStatement :: ";
73344 0 : std::cout << " p_body is not in memory pool of ";
73345 0 : std::cout << p_body->class_name() << std::endl;
73346 : }
73347 : }
73348 : else
73349 : {
73350 0 : std::cout << "SgOmpScanStatement :: " << std::flush;
73351 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
73352 0 : std::cout << " not valid " << std::endl;
73353 : }
73354 : }
73355 :
73356 0 : if ( p_upir_parent != NULL )
73357 : {
73358 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73359 : {
73360 0 : if ( p_upir_parent->isInMemoryPool() == false )
73361 : {
73362 0 : std::cout << "SgOmpScanStatement :: ";
73363 0 : std::cout << " p_upir_parent is not in memory pool of ";
73364 0 : std::cout << p_upir_parent->class_name() << std::endl;
73365 : }
73366 : }
73367 : else
73368 : {
73369 0 : std::cout << "SgOmpScanStatement :: " << std::flush;
73370 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
73371 0 : std::cout << " not valid " << std::endl;
73372 : }
73373 : }
73374 :
73375 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
73376 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
73377 : {
73378 0 : if ( (*i_upir_children) != NULL )
73379 : {
73380 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73381 : {
73382 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
73383 : {
73384 0 : std::cout << "SgOmpScanStatement :: ";
73385 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
73386 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
73387 : }
73388 : }
73389 : else
73390 : {
73391 0 : std::cout << "SgOmpScanStatement :: " << std::flush;
73392 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
73393 0 : std::cout << " entry not valid " << std::endl;
73394 : }
73395 : }
73396 : else
73397 : {
73398 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
73399 : }
73400 : }
73401 :
73402 0 : if ( p_numeric_label != NULL )
73403 : {
73404 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73405 : {
73406 0 : if ( p_numeric_label->isInMemoryPool() == false )
73407 : {
73408 0 : std::cout << "SgOmpScanStatement :: ";
73409 0 : std::cout << " p_numeric_label is not in memory pool of ";
73410 0 : std::cout << p_numeric_label->class_name() << std::endl;
73411 : }
73412 : }
73413 : else
73414 : {
73415 0 : std::cout << "SgOmpScanStatement :: " << std::flush;
73416 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
73417 0 : std::cout << " not valid " << std::endl;
73418 : }
73419 : }
73420 :
73421 0 : if ( p_startOfConstruct != NULL )
73422 : {
73423 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73424 : {
73425 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
73426 : {
73427 0 : std::cout << "SgOmpScanStatement :: ";
73428 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
73429 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
73430 : }
73431 : }
73432 : else
73433 : {
73434 0 : std::cout << "SgOmpScanStatement :: " << std::flush;
73435 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
73436 0 : std::cout << " not valid " << std::endl;
73437 : }
73438 : }
73439 :
73440 0 : if ( p_endOfConstruct != NULL )
73441 : {
73442 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73443 : {
73444 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
73445 : {
73446 0 : std::cout << "SgOmpScanStatement :: ";
73447 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
73448 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
73449 : }
73450 : }
73451 : else
73452 : {
73453 0 : std::cout << "SgOmpScanStatement :: " << std::flush;
73454 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
73455 0 : std::cout << " not valid " << std::endl;
73456 : }
73457 : }
73458 :
73459 0 : if ( p_parent != NULL )
73460 : {
73461 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73462 : {
73463 0 : if ( p_parent->isInMemoryPool() == false )
73464 : {
73465 0 : std::cout << "SgOmpScanStatement :: ";
73466 0 : std::cout << " p_parent is not in memory pool of ";
73467 0 : std::cout << p_parent->class_name() << std::endl;
73468 : }
73469 : }
73470 : else
73471 : {
73472 0 : std::cout << "SgOmpScanStatement :: " << std::flush;
73473 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
73474 0 : std::cout << " not valid " << std::endl;
73475 : }
73476 : }
73477 :
73478 :
73479 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
73480 :
73481 0 : }
73482 :
73483 :
73484 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
73485 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
73486 : bool
73487 0 : SgOmpScanStatement::isInMemoryPool ()
73488 : {
73489 0 : typedef unsigned char* TestType;
73490 :
73491 0 : bool found = false;
73492 :
73493 0 : ROSE_ASSERT(this != NULL);
73494 :
73495 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
73496 :
73497 0 : TestType tested = (TestType) ( this ) ;
73498 :
73499 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpScanStatement::pools.begin();
73500 :
73501 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
73502 : // while (found == false && block < Memory_Block_List.end())
73503 0 : while ( (found == false) && (block != SgOmpScanStatement::pools.end()) )
73504 : {
73505 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpScanStatement::pool_size * sizeof(SgOmpScanStatement) ) ) ;
73506 0 : ++block;
73507 : }
73508 :
73509 : // Special handling for static data
73510 :
73511 :
73512 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
73513 0 : ROSE_ASSERT(found == true);
73514 :
73515 0 : return found;
73516 : }
73517 : /* #line 73518 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
73518 :
73519 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
73520 :
73521 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
73522 :
73523 : /* #line 73524 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
73524 :
73525 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
73526 :
73527 : void
73528 0 : SgOmpMetadirectiveStatement::checkDataMemberPointersIfInMemoryPool()
73529 : {
73530 : // ------------ checking pointers of SgOmpMetadirectiveStatement -------------------
73531 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
73532 :
73533 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
73534 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
73535 : {
73536 0 : if ( (*i_clauses) != NULL )
73537 : {
73538 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73539 : {
73540 0 : if ( (*i_clauses)->isInMemoryPool() == false )
73541 : {
73542 0 : std::cout << "SgOmpMetadirectiveStatement :: ";
73543 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
73544 0 : std::cout << (*i_clauses)->class_name() << std::endl;
73545 : }
73546 : }
73547 : else
73548 : {
73549 0 : std::cout << "SgOmpMetadirectiveStatement :: " << std::flush;
73550 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
73551 0 : std::cout << " entry not valid " << std::endl;
73552 : }
73553 : }
73554 : else
73555 : {
73556 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
73557 : }
73558 : }
73559 :
73560 0 : if ( p_body != NULL )
73561 : {
73562 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73563 : {
73564 0 : if ( p_body->isInMemoryPool() == false )
73565 : {
73566 0 : std::cout << "SgOmpMetadirectiveStatement :: ";
73567 0 : std::cout << " p_body is not in memory pool of ";
73568 0 : std::cout << p_body->class_name() << std::endl;
73569 : }
73570 : }
73571 : else
73572 : {
73573 0 : std::cout << "SgOmpMetadirectiveStatement :: " << std::flush;
73574 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
73575 0 : std::cout << " not valid " << std::endl;
73576 : }
73577 : }
73578 :
73579 0 : if ( p_upir_parent != NULL )
73580 : {
73581 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73582 : {
73583 0 : if ( p_upir_parent->isInMemoryPool() == false )
73584 : {
73585 0 : std::cout << "SgOmpMetadirectiveStatement :: ";
73586 0 : std::cout << " p_upir_parent is not in memory pool of ";
73587 0 : std::cout << p_upir_parent->class_name() << std::endl;
73588 : }
73589 : }
73590 : else
73591 : {
73592 0 : std::cout << "SgOmpMetadirectiveStatement :: " << std::flush;
73593 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
73594 0 : std::cout << " not valid " << std::endl;
73595 : }
73596 : }
73597 :
73598 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
73599 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
73600 : {
73601 0 : if ( (*i_upir_children) != NULL )
73602 : {
73603 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73604 : {
73605 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
73606 : {
73607 0 : std::cout << "SgOmpMetadirectiveStatement :: ";
73608 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
73609 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
73610 : }
73611 : }
73612 : else
73613 : {
73614 0 : std::cout << "SgOmpMetadirectiveStatement :: " << std::flush;
73615 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
73616 0 : std::cout << " entry not valid " << std::endl;
73617 : }
73618 : }
73619 : else
73620 : {
73621 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
73622 : }
73623 : }
73624 :
73625 0 : if ( p_numeric_label != NULL )
73626 : {
73627 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73628 : {
73629 0 : if ( p_numeric_label->isInMemoryPool() == false )
73630 : {
73631 0 : std::cout << "SgOmpMetadirectiveStatement :: ";
73632 0 : std::cout << " p_numeric_label is not in memory pool of ";
73633 0 : std::cout << p_numeric_label->class_name() << std::endl;
73634 : }
73635 : }
73636 : else
73637 : {
73638 0 : std::cout << "SgOmpMetadirectiveStatement :: " << std::flush;
73639 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
73640 0 : std::cout << " not valid " << std::endl;
73641 : }
73642 : }
73643 :
73644 0 : if ( p_startOfConstruct != NULL )
73645 : {
73646 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73647 : {
73648 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
73649 : {
73650 0 : std::cout << "SgOmpMetadirectiveStatement :: ";
73651 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
73652 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
73653 : }
73654 : }
73655 : else
73656 : {
73657 0 : std::cout << "SgOmpMetadirectiveStatement :: " << std::flush;
73658 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
73659 0 : std::cout << " not valid " << std::endl;
73660 : }
73661 : }
73662 :
73663 0 : if ( p_endOfConstruct != NULL )
73664 : {
73665 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73666 : {
73667 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
73668 : {
73669 0 : std::cout << "SgOmpMetadirectiveStatement :: ";
73670 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
73671 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
73672 : }
73673 : }
73674 : else
73675 : {
73676 0 : std::cout << "SgOmpMetadirectiveStatement :: " << std::flush;
73677 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
73678 0 : std::cout << " not valid " << std::endl;
73679 : }
73680 : }
73681 :
73682 0 : if ( p_parent != NULL )
73683 : {
73684 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73685 : {
73686 0 : if ( p_parent->isInMemoryPool() == false )
73687 : {
73688 0 : std::cout << "SgOmpMetadirectiveStatement :: ";
73689 0 : std::cout << " p_parent is not in memory pool of ";
73690 0 : std::cout << p_parent->class_name() << std::endl;
73691 : }
73692 : }
73693 : else
73694 : {
73695 0 : std::cout << "SgOmpMetadirectiveStatement :: " << std::flush;
73696 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
73697 0 : std::cout << " not valid " << std::endl;
73698 : }
73699 : }
73700 :
73701 :
73702 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
73703 :
73704 0 : }
73705 :
73706 :
73707 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
73708 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
73709 : bool
73710 0 : SgOmpMetadirectiveStatement::isInMemoryPool ()
73711 : {
73712 0 : typedef unsigned char* TestType;
73713 :
73714 0 : bool found = false;
73715 :
73716 0 : ROSE_ASSERT(this != NULL);
73717 :
73718 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
73719 :
73720 0 : TestType tested = (TestType) ( this ) ;
73721 :
73722 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpMetadirectiveStatement::pools.begin();
73723 :
73724 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
73725 : // while (found == false && block < Memory_Block_List.end())
73726 0 : while ( (found == false) && (block != SgOmpMetadirectiveStatement::pools.end()) )
73727 : {
73728 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpMetadirectiveStatement::pool_size * sizeof(SgOmpMetadirectiveStatement) ) ) ;
73729 0 : ++block;
73730 : }
73731 :
73732 : // Special handling for static data
73733 :
73734 :
73735 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
73736 0 : ROSE_ASSERT(found == true);
73737 :
73738 0 : return found;
73739 : }
73740 : /* #line 73741 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
73741 :
73742 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
73743 :
73744 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
73745 :
73746 : /* #line 73747 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
73747 :
73748 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
73749 :
73750 : void
73751 0 : SgOmpLoopStatement::checkDataMemberPointersIfInMemoryPool()
73752 : {
73753 : // ------------ checking pointers of SgOmpLoopStatement -------------------
73754 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
73755 :
73756 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
73757 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
73758 : {
73759 0 : if ( (*i_clauses) != NULL )
73760 : {
73761 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73762 : {
73763 0 : if ( (*i_clauses)->isInMemoryPool() == false )
73764 : {
73765 0 : std::cout << "SgOmpLoopStatement :: ";
73766 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
73767 0 : std::cout << (*i_clauses)->class_name() << std::endl;
73768 : }
73769 : }
73770 : else
73771 : {
73772 0 : std::cout << "SgOmpLoopStatement :: " << std::flush;
73773 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
73774 0 : std::cout << " entry not valid " << std::endl;
73775 : }
73776 : }
73777 : else
73778 : {
73779 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
73780 : }
73781 : }
73782 :
73783 0 : if ( p_body != NULL )
73784 : {
73785 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73786 : {
73787 0 : if ( p_body->isInMemoryPool() == false )
73788 : {
73789 0 : std::cout << "SgOmpLoopStatement :: ";
73790 0 : std::cout << " p_body is not in memory pool of ";
73791 0 : std::cout << p_body->class_name() << std::endl;
73792 : }
73793 : }
73794 : else
73795 : {
73796 0 : std::cout << "SgOmpLoopStatement :: " << std::flush;
73797 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
73798 0 : std::cout << " not valid " << std::endl;
73799 : }
73800 : }
73801 :
73802 0 : if ( p_upir_parent != NULL )
73803 : {
73804 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73805 : {
73806 0 : if ( p_upir_parent->isInMemoryPool() == false )
73807 : {
73808 0 : std::cout << "SgOmpLoopStatement :: ";
73809 0 : std::cout << " p_upir_parent is not in memory pool of ";
73810 0 : std::cout << p_upir_parent->class_name() << std::endl;
73811 : }
73812 : }
73813 : else
73814 : {
73815 0 : std::cout << "SgOmpLoopStatement :: " << std::flush;
73816 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
73817 0 : std::cout << " not valid " << std::endl;
73818 : }
73819 : }
73820 :
73821 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
73822 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
73823 : {
73824 0 : if ( (*i_upir_children) != NULL )
73825 : {
73826 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73827 : {
73828 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
73829 : {
73830 0 : std::cout << "SgOmpLoopStatement :: ";
73831 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
73832 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
73833 : }
73834 : }
73835 : else
73836 : {
73837 0 : std::cout << "SgOmpLoopStatement :: " << std::flush;
73838 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
73839 0 : std::cout << " entry not valid " << std::endl;
73840 : }
73841 : }
73842 : else
73843 : {
73844 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
73845 : }
73846 : }
73847 :
73848 0 : if ( p_numeric_label != NULL )
73849 : {
73850 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73851 : {
73852 0 : if ( p_numeric_label->isInMemoryPool() == false )
73853 : {
73854 0 : std::cout << "SgOmpLoopStatement :: ";
73855 0 : std::cout << " p_numeric_label is not in memory pool of ";
73856 0 : std::cout << p_numeric_label->class_name() << std::endl;
73857 : }
73858 : }
73859 : else
73860 : {
73861 0 : std::cout << "SgOmpLoopStatement :: " << std::flush;
73862 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
73863 0 : std::cout << " not valid " << std::endl;
73864 : }
73865 : }
73866 :
73867 0 : if ( p_startOfConstruct != NULL )
73868 : {
73869 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73870 : {
73871 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
73872 : {
73873 0 : std::cout << "SgOmpLoopStatement :: ";
73874 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
73875 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
73876 : }
73877 : }
73878 : else
73879 : {
73880 0 : std::cout << "SgOmpLoopStatement :: " << std::flush;
73881 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
73882 0 : std::cout << " not valid " << std::endl;
73883 : }
73884 : }
73885 :
73886 0 : if ( p_endOfConstruct != NULL )
73887 : {
73888 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73889 : {
73890 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
73891 : {
73892 0 : std::cout << "SgOmpLoopStatement :: ";
73893 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
73894 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
73895 : }
73896 : }
73897 : else
73898 : {
73899 0 : std::cout << "SgOmpLoopStatement :: " << std::flush;
73900 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
73901 0 : std::cout << " not valid " << std::endl;
73902 : }
73903 : }
73904 :
73905 0 : if ( p_parent != NULL )
73906 : {
73907 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73908 : {
73909 0 : if ( p_parent->isInMemoryPool() == false )
73910 : {
73911 0 : std::cout << "SgOmpLoopStatement :: ";
73912 0 : std::cout << " p_parent is not in memory pool of ";
73913 0 : std::cout << p_parent->class_name() << std::endl;
73914 : }
73915 : }
73916 : else
73917 : {
73918 0 : std::cout << "SgOmpLoopStatement :: " << std::flush;
73919 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
73920 0 : std::cout << " not valid " << std::endl;
73921 : }
73922 : }
73923 :
73924 :
73925 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
73926 :
73927 0 : }
73928 :
73929 :
73930 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
73931 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
73932 : bool
73933 0 : SgOmpLoopStatement::isInMemoryPool ()
73934 : {
73935 0 : typedef unsigned char* TestType;
73936 :
73937 0 : bool found = false;
73938 :
73939 0 : ROSE_ASSERT(this != NULL);
73940 :
73941 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
73942 :
73943 0 : TestType tested = (TestType) ( this ) ;
73944 :
73945 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpLoopStatement::pools.begin();
73946 :
73947 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
73948 : // while (found == false && block < Memory_Block_List.end())
73949 0 : while ( (found == false) && (block != SgOmpLoopStatement::pools.end()) )
73950 : {
73951 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpLoopStatement::pool_size * sizeof(SgOmpLoopStatement) ) ) ;
73952 0 : ++block;
73953 : }
73954 :
73955 : // Special handling for static data
73956 :
73957 :
73958 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
73959 0 : ROSE_ASSERT(found == true);
73960 :
73961 0 : return found;
73962 : }
73963 : /* #line 73964 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
73964 :
73965 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
73966 :
73967 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
73968 :
73969 : /* #line 73970 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
73970 :
73971 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
73972 :
73973 : void
73974 0 : SgOmpOrderedStatement::checkDataMemberPointersIfInMemoryPool()
73975 : {
73976 : // ------------ checking pointers of SgOmpOrderedStatement -------------------
73977 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
73978 :
73979 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
73980 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
73981 : {
73982 0 : if ( (*i_clauses) != NULL )
73983 : {
73984 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
73985 : {
73986 0 : if ( (*i_clauses)->isInMemoryPool() == false )
73987 : {
73988 0 : std::cout << "SgOmpOrderedStatement :: ";
73989 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
73990 0 : std::cout << (*i_clauses)->class_name() << std::endl;
73991 : }
73992 : }
73993 : else
73994 : {
73995 0 : std::cout << "SgOmpOrderedStatement :: " << std::flush;
73996 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
73997 0 : std::cout << " entry not valid " << std::endl;
73998 : }
73999 : }
74000 : else
74001 : {
74002 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
74003 : }
74004 : }
74005 :
74006 0 : if ( p_body != NULL )
74007 : {
74008 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74009 : {
74010 0 : if ( p_body->isInMemoryPool() == false )
74011 : {
74012 0 : std::cout << "SgOmpOrderedStatement :: ";
74013 0 : std::cout << " p_body is not in memory pool of ";
74014 0 : std::cout << p_body->class_name() << std::endl;
74015 : }
74016 : }
74017 : else
74018 : {
74019 0 : std::cout << "SgOmpOrderedStatement :: " << std::flush;
74020 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
74021 0 : std::cout << " not valid " << std::endl;
74022 : }
74023 : }
74024 :
74025 0 : if ( p_upir_parent != NULL )
74026 : {
74027 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74028 : {
74029 0 : if ( p_upir_parent->isInMemoryPool() == false )
74030 : {
74031 0 : std::cout << "SgOmpOrderedStatement :: ";
74032 0 : std::cout << " p_upir_parent is not in memory pool of ";
74033 0 : std::cout << p_upir_parent->class_name() << std::endl;
74034 : }
74035 : }
74036 : else
74037 : {
74038 0 : std::cout << "SgOmpOrderedStatement :: " << std::flush;
74039 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
74040 0 : std::cout << " not valid " << std::endl;
74041 : }
74042 : }
74043 :
74044 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
74045 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
74046 : {
74047 0 : if ( (*i_upir_children) != NULL )
74048 : {
74049 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74050 : {
74051 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
74052 : {
74053 0 : std::cout << "SgOmpOrderedStatement :: ";
74054 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
74055 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
74056 : }
74057 : }
74058 : else
74059 : {
74060 0 : std::cout << "SgOmpOrderedStatement :: " << std::flush;
74061 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
74062 0 : std::cout << " entry not valid " << std::endl;
74063 : }
74064 : }
74065 : else
74066 : {
74067 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
74068 : }
74069 : }
74070 :
74071 0 : if ( p_numeric_label != NULL )
74072 : {
74073 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74074 : {
74075 0 : if ( p_numeric_label->isInMemoryPool() == false )
74076 : {
74077 0 : std::cout << "SgOmpOrderedStatement :: ";
74078 0 : std::cout << " p_numeric_label is not in memory pool of ";
74079 0 : std::cout << p_numeric_label->class_name() << std::endl;
74080 : }
74081 : }
74082 : else
74083 : {
74084 0 : std::cout << "SgOmpOrderedStatement :: " << std::flush;
74085 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
74086 0 : std::cout << " not valid " << std::endl;
74087 : }
74088 : }
74089 :
74090 0 : if ( p_startOfConstruct != NULL )
74091 : {
74092 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74093 : {
74094 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
74095 : {
74096 0 : std::cout << "SgOmpOrderedStatement :: ";
74097 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
74098 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
74099 : }
74100 : }
74101 : else
74102 : {
74103 0 : std::cout << "SgOmpOrderedStatement :: " << std::flush;
74104 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
74105 0 : std::cout << " not valid " << std::endl;
74106 : }
74107 : }
74108 :
74109 0 : if ( p_endOfConstruct != NULL )
74110 : {
74111 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74112 : {
74113 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
74114 : {
74115 0 : std::cout << "SgOmpOrderedStatement :: ";
74116 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
74117 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
74118 : }
74119 : }
74120 : else
74121 : {
74122 0 : std::cout << "SgOmpOrderedStatement :: " << std::flush;
74123 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
74124 0 : std::cout << " not valid " << std::endl;
74125 : }
74126 : }
74127 :
74128 0 : if ( p_parent != NULL )
74129 : {
74130 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74131 : {
74132 0 : if ( p_parent->isInMemoryPool() == false )
74133 : {
74134 0 : std::cout << "SgOmpOrderedStatement :: ";
74135 0 : std::cout << " p_parent is not in memory pool of ";
74136 0 : std::cout << p_parent->class_name() << std::endl;
74137 : }
74138 : }
74139 : else
74140 : {
74141 0 : std::cout << "SgOmpOrderedStatement :: " << std::flush;
74142 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
74143 0 : std::cout << " not valid " << std::endl;
74144 : }
74145 : }
74146 :
74147 :
74148 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
74149 :
74150 0 : }
74151 :
74152 :
74153 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
74154 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
74155 : bool
74156 0 : SgOmpOrderedStatement::isInMemoryPool ()
74157 : {
74158 0 : typedef unsigned char* TestType;
74159 :
74160 0 : bool found = false;
74161 :
74162 0 : ROSE_ASSERT(this != NULL);
74163 :
74164 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
74165 :
74166 0 : TestType tested = (TestType) ( this ) ;
74167 :
74168 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpOrderedStatement::pools.begin();
74169 :
74170 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
74171 : // while (found == false && block < Memory_Block_List.end())
74172 0 : while ( (found == false) && (block != SgOmpOrderedStatement::pools.end()) )
74173 : {
74174 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpOrderedStatement::pool_size * sizeof(SgOmpOrderedStatement) ) ) ;
74175 0 : ++block;
74176 : }
74177 :
74178 : // Special handling for static data
74179 :
74180 :
74181 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
74182 0 : ROSE_ASSERT(found == true);
74183 :
74184 0 : return found;
74185 : }
74186 : /* #line 74187 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
74187 :
74188 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
74189 :
74190 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
74191 :
74192 : /* #line 74193 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
74193 :
74194 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
74195 :
74196 : void
74197 0 : SgOmpTaskgroupStatement::checkDataMemberPointersIfInMemoryPool()
74198 : {
74199 : // ------------ checking pointers of SgOmpTaskgroupStatement -------------------
74200 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
74201 :
74202 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
74203 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
74204 : {
74205 0 : if ( (*i_clauses) != NULL )
74206 : {
74207 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74208 : {
74209 0 : if ( (*i_clauses)->isInMemoryPool() == false )
74210 : {
74211 0 : std::cout << "SgOmpTaskgroupStatement :: ";
74212 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
74213 0 : std::cout << (*i_clauses)->class_name() << std::endl;
74214 : }
74215 : }
74216 : else
74217 : {
74218 0 : std::cout << "SgOmpTaskgroupStatement :: " << std::flush;
74219 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
74220 0 : std::cout << " entry not valid " << std::endl;
74221 : }
74222 : }
74223 : else
74224 : {
74225 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
74226 : }
74227 : }
74228 :
74229 0 : if ( p_body != NULL )
74230 : {
74231 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74232 : {
74233 0 : if ( p_body->isInMemoryPool() == false )
74234 : {
74235 0 : std::cout << "SgOmpTaskgroupStatement :: ";
74236 0 : std::cout << " p_body is not in memory pool of ";
74237 0 : std::cout << p_body->class_name() << std::endl;
74238 : }
74239 : }
74240 : else
74241 : {
74242 0 : std::cout << "SgOmpTaskgroupStatement :: " << std::flush;
74243 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
74244 0 : std::cout << " not valid " << std::endl;
74245 : }
74246 : }
74247 :
74248 0 : if ( p_upir_parent != NULL )
74249 : {
74250 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74251 : {
74252 0 : if ( p_upir_parent->isInMemoryPool() == false )
74253 : {
74254 0 : std::cout << "SgOmpTaskgroupStatement :: ";
74255 0 : std::cout << " p_upir_parent is not in memory pool of ";
74256 0 : std::cout << p_upir_parent->class_name() << std::endl;
74257 : }
74258 : }
74259 : else
74260 : {
74261 0 : std::cout << "SgOmpTaskgroupStatement :: " << std::flush;
74262 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
74263 0 : std::cout << " not valid " << std::endl;
74264 : }
74265 : }
74266 :
74267 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
74268 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
74269 : {
74270 0 : if ( (*i_upir_children) != NULL )
74271 : {
74272 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74273 : {
74274 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
74275 : {
74276 0 : std::cout << "SgOmpTaskgroupStatement :: ";
74277 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
74278 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
74279 : }
74280 : }
74281 : else
74282 : {
74283 0 : std::cout << "SgOmpTaskgroupStatement :: " << std::flush;
74284 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
74285 0 : std::cout << " entry not valid " << std::endl;
74286 : }
74287 : }
74288 : else
74289 : {
74290 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
74291 : }
74292 : }
74293 :
74294 0 : if ( p_numeric_label != NULL )
74295 : {
74296 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74297 : {
74298 0 : if ( p_numeric_label->isInMemoryPool() == false )
74299 : {
74300 0 : std::cout << "SgOmpTaskgroupStatement :: ";
74301 0 : std::cout << " p_numeric_label is not in memory pool of ";
74302 0 : std::cout << p_numeric_label->class_name() << std::endl;
74303 : }
74304 : }
74305 : else
74306 : {
74307 0 : std::cout << "SgOmpTaskgroupStatement :: " << std::flush;
74308 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
74309 0 : std::cout << " not valid " << std::endl;
74310 : }
74311 : }
74312 :
74313 0 : if ( p_startOfConstruct != NULL )
74314 : {
74315 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74316 : {
74317 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
74318 : {
74319 0 : std::cout << "SgOmpTaskgroupStatement :: ";
74320 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
74321 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
74322 : }
74323 : }
74324 : else
74325 : {
74326 0 : std::cout << "SgOmpTaskgroupStatement :: " << std::flush;
74327 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
74328 0 : std::cout << " not valid " << std::endl;
74329 : }
74330 : }
74331 :
74332 0 : if ( p_endOfConstruct != NULL )
74333 : {
74334 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74335 : {
74336 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
74337 : {
74338 0 : std::cout << "SgOmpTaskgroupStatement :: ";
74339 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
74340 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
74341 : }
74342 : }
74343 : else
74344 : {
74345 0 : std::cout << "SgOmpTaskgroupStatement :: " << std::flush;
74346 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
74347 0 : std::cout << " not valid " << std::endl;
74348 : }
74349 : }
74350 :
74351 0 : if ( p_parent != NULL )
74352 : {
74353 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74354 : {
74355 0 : if ( p_parent->isInMemoryPool() == false )
74356 : {
74357 0 : std::cout << "SgOmpTaskgroupStatement :: ";
74358 0 : std::cout << " p_parent is not in memory pool of ";
74359 0 : std::cout << p_parent->class_name() << std::endl;
74360 : }
74361 : }
74362 : else
74363 : {
74364 0 : std::cout << "SgOmpTaskgroupStatement :: " << std::flush;
74365 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
74366 0 : std::cout << " not valid " << std::endl;
74367 : }
74368 : }
74369 :
74370 :
74371 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
74372 :
74373 0 : }
74374 :
74375 :
74376 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
74377 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
74378 : bool
74379 0 : SgOmpTaskgroupStatement::isInMemoryPool ()
74380 : {
74381 0 : typedef unsigned char* TestType;
74382 :
74383 0 : bool found = false;
74384 :
74385 0 : ROSE_ASSERT(this != NULL);
74386 :
74387 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
74388 :
74389 0 : TestType tested = (TestType) ( this ) ;
74390 :
74391 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTaskgroupStatement::pools.begin();
74392 :
74393 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
74394 : // while (found == false && block < Memory_Block_List.end())
74395 0 : while ( (found == false) && (block != SgOmpTaskgroupStatement::pools.end()) )
74396 : {
74397 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTaskgroupStatement::pool_size * sizeof(SgOmpTaskgroupStatement) ) ) ;
74398 0 : ++block;
74399 : }
74400 :
74401 : // Special handling for static data
74402 :
74403 :
74404 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
74405 0 : ROSE_ASSERT(found == true);
74406 :
74407 0 : return found;
74408 : }
74409 : /* #line 74410 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
74410 :
74411 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
74412 :
74413 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
74414 :
74415 : /* #line 74416 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
74416 :
74417 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
74418 :
74419 : void
74420 0 : SgOmpTaskloopStatement::checkDataMemberPointersIfInMemoryPool()
74421 : {
74422 : // ------------ checking pointers of SgOmpTaskloopStatement -------------------
74423 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
74424 :
74425 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
74426 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
74427 : {
74428 0 : if ( (*i_clauses) != NULL )
74429 : {
74430 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74431 : {
74432 0 : if ( (*i_clauses)->isInMemoryPool() == false )
74433 : {
74434 0 : std::cout << "SgOmpTaskloopStatement :: ";
74435 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
74436 0 : std::cout << (*i_clauses)->class_name() << std::endl;
74437 : }
74438 : }
74439 : else
74440 : {
74441 0 : std::cout << "SgOmpTaskloopStatement :: " << std::flush;
74442 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
74443 0 : std::cout << " entry not valid " << std::endl;
74444 : }
74445 : }
74446 : else
74447 : {
74448 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
74449 : }
74450 : }
74451 :
74452 0 : if ( p_body != NULL )
74453 : {
74454 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74455 : {
74456 0 : if ( p_body->isInMemoryPool() == false )
74457 : {
74458 0 : std::cout << "SgOmpTaskloopStatement :: ";
74459 0 : std::cout << " p_body is not in memory pool of ";
74460 0 : std::cout << p_body->class_name() << std::endl;
74461 : }
74462 : }
74463 : else
74464 : {
74465 0 : std::cout << "SgOmpTaskloopStatement :: " << std::flush;
74466 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
74467 0 : std::cout << " not valid " << std::endl;
74468 : }
74469 : }
74470 :
74471 0 : if ( p_upir_parent != NULL )
74472 : {
74473 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74474 : {
74475 0 : if ( p_upir_parent->isInMemoryPool() == false )
74476 : {
74477 0 : std::cout << "SgOmpTaskloopStatement :: ";
74478 0 : std::cout << " p_upir_parent is not in memory pool of ";
74479 0 : std::cout << p_upir_parent->class_name() << std::endl;
74480 : }
74481 : }
74482 : else
74483 : {
74484 0 : std::cout << "SgOmpTaskloopStatement :: " << std::flush;
74485 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
74486 0 : std::cout << " not valid " << std::endl;
74487 : }
74488 : }
74489 :
74490 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
74491 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
74492 : {
74493 0 : if ( (*i_upir_children) != NULL )
74494 : {
74495 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74496 : {
74497 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
74498 : {
74499 0 : std::cout << "SgOmpTaskloopStatement :: ";
74500 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
74501 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
74502 : }
74503 : }
74504 : else
74505 : {
74506 0 : std::cout << "SgOmpTaskloopStatement :: " << std::flush;
74507 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
74508 0 : std::cout << " entry not valid " << std::endl;
74509 : }
74510 : }
74511 : else
74512 : {
74513 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
74514 : }
74515 : }
74516 :
74517 0 : if ( p_numeric_label != NULL )
74518 : {
74519 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74520 : {
74521 0 : if ( p_numeric_label->isInMemoryPool() == false )
74522 : {
74523 0 : std::cout << "SgOmpTaskloopStatement :: ";
74524 0 : std::cout << " p_numeric_label is not in memory pool of ";
74525 0 : std::cout << p_numeric_label->class_name() << std::endl;
74526 : }
74527 : }
74528 : else
74529 : {
74530 0 : std::cout << "SgOmpTaskloopStatement :: " << std::flush;
74531 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
74532 0 : std::cout << " not valid " << std::endl;
74533 : }
74534 : }
74535 :
74536 0 : if ( p_startOfConstruct != NULL )
74537 : {
74538 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74539 : {
74540 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
74541 : {
74542 0 : std::cout << "SgOmpTaskloopStatement :: ";
74543 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
74544 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
74545 : }
74546 : }
74547 : else
74548 : {
74549 0 : std::cout << "SgOmpTaskloopStatement :: " << std::flush;
74550 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
74551 0 : std::cout << " not valid " << std::endl;
74552 : }
74553 : }
74554 :
74555 0 : if ( p_endOfConstruct != NULL )
74556 : {
74557 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74558 : {
74559 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
74560 : {
74561 0 : std::cout << "SgOmpTaskloopStatement :: ";
74562 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
74563 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
74564 : }
74565 : }
74566 : else
74567 : {
74568 0 : std::cout << "SgOmpTaskloopStatement :: " << std::flush;
74569 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
74570 0 : std::cout << " not valid " << std::endl;
74571 : }
74572 : }
74573 :
74574 0 : if ( p_parent != NULL )
74575 : {
74576 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74577 : {
74578 0 : if ( p_parent->isInMemoryPool() == false )
74579 : {
74580 0 : std::cout << "SgOmpTaskloopStatement :: ";
74581 0 : std::cout << " p_parent is not in memory pool of ";
74582 0 : std::cout << p_parent->class_name() << std::endl;
74583 : }
74584 : }
74585 : else
74586 : {
74587 0 : std::cout << "SgOmpTaskloopStatement :: " << std::flush;
74588 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
74589 0 : std::cout << " not valid " << std::endl;
74590 : }
74591 : }
74592 :
74593 :
74594 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
74595 :
74596 0 : }
74597 :
74598 :
74599 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
74600 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
74601 : bool
74602 0 : SgOmpTaskloopStatement::isInMemoryPool ()
74603 : {
74604 0 : typedef unsigned char* TestType;
74605 :
74606 0 : bool found = false;
74607 :
74608 0 : ROSE_ASSERT(this != NULL);
74609 :
74610 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
74611 :
74612 0 : TestType tested = (TestType) ( this ) ;
74613 :
74614 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTaskloopStatement::pools.begin();
74615 :
74616 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
74617 : // while (found == false && block < Memory_Block_List.end())
74618 0 : while ( (found == false) && (block != SgOmpTaskloopStatement::pools.end()) )
74619 : {
74620 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTaskloopStatement::pool_size * sizeof(SgOmpTaskloopStatement) ) ) ;
74621 0 : ++block;
74622 : }
74623 :
74624 : // Special handling for static data
74625 :
74626 :
74627 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
74628 0 : ROSE_ASSERT(found == true);
74629 :
74630 0 : return found;
74631 : }
74632 : /* #line 74633 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
74633 :
74634 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
74635 :
74636 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
74637 :
74638 : /* #line 74639 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
74639 :
74640 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
74641 :
74642 : void
74643 0 : SgOmpDepobjStatement::checkDataMemberPointersIfInMemoryPool()
74644 : {
74645 : // ------------ checking pointers of SgOmpDepobjStatement -------------------
74646 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
74647 :
74648 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
74649 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
74650 : {
74651 0 : if ( (*i_clauses) != NULL )
74652 : {
74653 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74654 : {
74655 0 : if ( (*i_clauses)->isInMemoryPool() == false )
74656 : {
74657 0 : std::cout << "SgOmpDepobjStatement :: ";
74658 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
74659 0 : std::cout << (*i_clauses)->class_name() << std::endl;
74660 : }
74661 : }
74662 : else
74663 : {
74664 0 : std::cout << "SgOmpDepobjStatement :: " << std::flush;
74665 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
74666 0 : std::cout << " entry not valid " << std::endl;
74667 : }
74668 : }
74669 : else
74670 : {
74671 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
74672 : }
74673 : }
74674 :
74675 0 : if ( p_body != NULL )
74676 : {
74677 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74678 : {
74679 0 : if ( p_body->isInMemoryPool() == false )
74680 : {
74681 0 : std::cout << "SgOmpDepobjStatement :: ";
74682 0 : std::cout << " p_body is not in memory pool of ";
74683 0 : std::cout << p_body->class_name() << std::endl;
74684 : }
74685 : }
74686 : else
74687 : {
74688 0 : std::cout << "SgOmpDepobjStatement :: " << std::flush;
74689 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
74690 0 : std::cout << " not valid " << std::endl;
74691 : }
74692 : }
74693 :
74694 0 : if ( p_upir_parent != NULL )
74695 : {
74696 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74697 : {
74698 0 : if ( p_upir_parent->isInMemoryPool() == false )
74699 : {
74700 0 : std::cout << "SgOmpDepobjStatement :: ";
74701 0 : std::cout << " p_upir_parent is not in memory pool of ";
74702 0 : std::cout << p_upir_parent->class_name() << std::endl;
74703 : }
74704 : }
74705 : else
74706 : {
74707 0 : std::cout << "SgOmpDepobjStatement :: " << std::flush;
74708 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
74709 0 : std::cout << " not valid " << std::endl;
74710 : }
74711 : }
74712 :
74713 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
74714 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
74715 : {
74716 0 : if ( (*i_upir_children) != NULL )
74717 : {
74718 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74719 : {
74720 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
74721 : {
74722 0 : std::cout << "SgOmpDepobjStatement :: ";
74723 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
74724 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
74725 : }
74726 : }
74727 : else
74728 : {
74729 0 : std::cout << "SgOmpDepobjStatement :: " << std::flush;
74730 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
74731 0 : std::cout << " entry not valid " << std::endl;
74732 : }
74733 : }
74734 : else
74735 : {
74736 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
74737 : }
74738 : }
74739 :
74740 0 : if ( p_numeric_label != NULL )
74741 : {
74742 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74743 : {
74744 0 : if ( p_numeric_label->isInMemoryPool() == false )
74745 : {
74746 0 : std::cout << "SgOmpDepobjStatement :: ";
74747 0 : std::cout << " p_numeric_label is not in memory pool of ";
74748 0 : std::cout << p_numeric_label->class_name() << std::endl;
74749 : }
74750 : }
74751 : else
74752 : {
74753 0 : std::cout << "SgOmpDepobjStatement :: " << std::flush;
74754 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
74755 0 : std::cout << " not valid " << std::endl;
74756 : }
74757 : }
74758 :
74759 0 : if ( p_startOfConstruct != NULL )
74760 : {
74761 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74762 : {
74763 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
74764 : {
74765 0 : std::cout << "SgOmpDepobjStatement :: ";
74766 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
74767 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
74768 : }
74769 : }
74770 : else
74771 : {
74772 0 : std::cout << "SgOmpDepobjStatement :: " << std::flush;
74773 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
74774 0 : std::cout << " not valid " << std::endl;
74775 : }
74776 : }
74777 :
74778 0 : if ( p_endOfConstruct != NULL )
74779 : {
74780 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74781 : {
74782 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
74783 : {
74784 0 : std::cout << "SgOmpDepobjStatement :: ";
74785 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
74786 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
74787 : }
74788 : }
74789 : else
74790 : {
74791 0 : std::cout << "SgOmpDepobjStatement :: " << std::flush;
74792 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
74793 0 : std::cout << " not valid " << std::endl;
74794 : }
74795 : }
74796 :
74797 0 : if ( p_parent != NULL )
74798 : {
74799 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74800 : {
74801 0 : if ( p_parent->isInMemoryPool() == false )
74802 : {
74803 0 : std::cout << "SgOmpDepobjStatement :: ";
74804 0 : std::cout << " p_parent is not in memory pool of ";
74805 0 : std::cout << p_parent->class_name() << std::endl;
74806 : }
74807 : }
74808 : else
74809 : {
74810 0 : std::cout << "SgOmpDepobjStatement :: " << std::flush;
74811 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
74812 0 : std::cout << " not valid " << std::endl;
74813 : }
74814 : }
74815 :
74816 :
74817 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
74818 :
74819 0 : }
74820 :
74821 :
74822 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
74823 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
74824 : bool
74825 0 : SgOmpDepobjStatement::isInMemoryPool ()
74826 : {
74827 0 : typedef unsigned char* TestType;
74828 :
74829 0 : bool found = false;
74830 :
74831 0 : ROSE_ASSERT(this != NULL);
74832 :
74833 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
74834 :
74835 0 : TestType tested = (TestType) ( this ) ;
74836 :
74837 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDepobjStatement::pools.begin();
74838 :
74839 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
74840 : // while (found == false && block < Memory_Block_List.end())
74841 0 : while ( (found == false) && (block != SgOmpDepobjStatement::pools.end()) )
74842 : {
74843 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDepobjStatement::pool_size * sizeof(SgOmpDepobjStatement) ) ) ;
74844 0 : ++block;
74845 : }
74846 :
74847 : // Special handling for static data
74848 :
74849 :
74850 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
74851 0 : ROSE_ASSERT(found == true);
74852 :
74853 0 : return found;
74854 : }
74855 : /* #line 74856 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
74856 :
74857 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
74858 :
74859 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
74860 :
74861 : /* #line 74862 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
74862 :
74863 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
74864 :
74865 : void
74866 0 : SgOmpTargetEnterDataStatement::checkDataMemberPointersIfInMemoryPool()
74867 : {
74868 : // ------------ checking pointers of SgOmpTargetEnterDataStatement -------------------
74869 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
74870 :
74871 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
74872 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
74873 : {
74874 0 : if ( (*i_clauses) != NULL )
74875 : {
74876 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74877 : {
74878 0 : if ( (*i_clauses)->isInMemoryPool() == false )
74879 : {
74880 0 : std::cout << "SgOmpTargetEnterDataStatement :: ";
74881 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
74882 0 : std::cout << (*i_clauses)->class_name() << std::endl;
74883 : }
74884 : }
74885 : else
74886 : {
74887 0 : std::cout << "SgOmpTargetEnterDataStatement :: " << std::flush;
74888 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
74889 0 : std::cout << " entry not valid " << std::endl;
74890 : }
74891 : }
74892 : else
74893 : {
74894 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
74895 : }
74896 : }
74897 :
74898 0 : if ( p_body != NULL )
74899 : {
74900 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74901 : {
74902 0 : if ( p_body->isInMemoryPool() == false )
74903 : {
74904 0 : std::cout << "SgOmpTargetEnterDataStatement :: ";
74905 0 : std::cout << " p_body is not in memory pool of ";
74906 0 : std::cout << p_body->class_name() << std::endl;
74907 : }
74908 : }
74909 : else
74910 : {
74911 0 : std::cout << "SgOmpTargetEnterDataStatement :: " << std::flush;
74912 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
74913 0 : std::cout << " not valid " << std::endl;
74914 : }
74915 : }
74916 :
74917 0 : if ( p_upir_parent != NULL )
74918 : {
74919 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74920 : {
74921 0 : if ( p_upir_parent->isInMemoryPool() == false )
74922 : {
74923 0 : std::cout << "SgOmpTargetEnterDataStatement :: ";
74924 0 : std::cout << " p_upir_parent is not in memory pool of ";
74925 0 : std::cout << p_upir_parent->class_name() << std::endl;
74926 : }
74927 : }
74928 : else
74929 : {
74930 0 : std::cout << "SgOmpTargetEnterDataStatement :: " << std::flush;
74931 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
74932 0 : std::cout << " not valid " << std::endl;
74933 : }
74934 : }
74935 :
74936 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
74937 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
74938 : {
74939 0 : if ( (*i_upir_children) != NULL )
74940 : {
74941 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74942 : {
74943 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
74944 : {
74945 0 : std::cout << "SgOmpTargetEnterDataStatement :: ";
74946 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
74947 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
74948 : }
74949 : }
74950 : else
74951 : {
74952 0 : std::cout << "SgOmpTargetEnterDataStatement :: " << std::flush;
74953 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
74954 0 : std::cout << " entry not valid " << std::endl;
74955 : }
74956 : }
74957 : else
74958 : {
74959 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
74960 : }
74961 : }
74962 :
74963 0 : if ( p_numeric_label != NULL )
74964 : {
74965 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74966 : {
74967 0 : if ( p_numeric_label->isInMemoryPool() == false )
74968 : {
74969 0 : std::cout << "SgOmpTargetEnterDataStatement :: ";
74970 0 : std::cout << " p_numeric_label is not in memory pool of ";
74971 0 : std::cout << p_numeric_label->class_name() << std::endl;
74972 : }
74973 : }
74974 : else
74975 : {
74976 0 : std::cout << "SgOmpTargetEnterDataStatement :: " << std::flush;
74977 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
74978 0 : std::cout << " not valid " << std::endl;
74979 : }
74980 : }
74981 :
74982 0 : if ( p_startOfConstruct != NULL )
74983 : {
74984 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
74985 : {
74986 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
74987 : {
74988 0 : std::cout << "SgOmpTargetEnterDataStatement :: ";
74989 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
74990 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
74991 : }
74992 : }
74993 : else
74994 : {
74995 0 : std::cout << "SgOmpTargetEnterDataStatement :: " << std::flush;
74996 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
74997 0 : std::cout << " not valid " << std::endl;
74998 : }
74999 : }
75000 :
75001 0 : if ( p_endOfConstruct != NULL )
75002 : {
75003 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75004 : {
75005 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
75006 : {
75007 0 : std::cout << "SgOmpTargetEnterDataStatement :: ";
75008 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
75009 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
75010 : }
75011 : }
75012 : else
75013 : {
75014 0 : std::cout << "SgOmpTargetEnterDataStatement :: " << std::flush;
75015 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
75016 0 : std::cout << " not valid " << std::endl;
75017 : }
75018 : }
75019 :
75020 0 : if ( p_parent != NULL )
75021 : {
75022 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75023 : {
75024 0 : if ( p_parent->isInMemoryPool() == false )
75025 : {
75026 0 : std::cout << "SgOmpTargetEnterDataStatement :: ";
75027 0 : std::cout << " p_parent is not in memory pool of ";
75028 0 : std::cout << p_parent->class_name() << std::endl;
75029 : }
75030 : }
75031 : else
75032 : {
75033 0 : std::cout << "SgOmpTargetEnterDataStatement :: " << std::flush;
75034 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
75035 0 : std::cout << " not valid " << std::endl;
75036 : }
75037 : }
75038 :
75039 :
75040 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
75041 :
75042 0 : }
75043 :
75044 :
75045 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
75046 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
75047 : bool
75048 0 : SgOmpTargetEnterDataStatement::isInMemoryPool ()
75049 : {
75050 0 : typedef unsigned char* TestType;
75051 :
75052 0 : bool found = false;
75053 :
75054 0 : ROSE_ASSERT(this != NULL);
75055 :
75056 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
75057 :
75058 0 : TestType tested = (TestType) ( this ) ;
75059 :
75060 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTargetEnterDataStatement::pools.begin();
75061 :
75062 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
75063 : // while (found == false && block < Memory_Block_List.end())
75064 0 : while ( (found == false) && (block != SgOmpTargetEnterDataStatement::pools.end()) )
75065 : {
75066 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTargetEnterDataStatement::pool_size * sizeof(SgOmpTargetEnterDataStatement) ) ) ;
75067 0 : ++block;
75068 : }
75069 :
75070 : // Special handling for static data
75071 :
75072 :
75073 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
75074 0 : ROSE_ASSERT(found == true);
75075 :
75076 0 : return found;
75077 : }
75078 : /* #line 75079 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
75079 :
75080 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
75081 :
75082 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
75083 :
75084 : /* #line 75085 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
75085 :
75086 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
75087 :
75088 : void
75089 0 : SgOmpTargetExitDataStatement::checkDataMemberPointersIfInMemoryPool()
75090 : {
75091 : // ------------ checking pointers of SgOmpTargetExitDataStatement -------------------
75092 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
75093 :
75094 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
75095 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
75096 : {
75097 0 : if ( (*i_clauses) != NULL )
75098 : {
75099 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75100 : {
75101 0 : if ( (*i_clauses)->isInMemoryPool() == false )
75102 : {
75103 0 : std::cout << "SgOmpTargetExitDataStatement :: ";
75104 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
75105 0 : std::cout << (*i_clauses)->class_name() << std::endl;
75106 : }
75107 : }
75108 : else
75109 : {
75110 0 : std::cout << "SgOmpTargetExitDataStatement :: " << std::flush;
75111 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
75112 0 : std::cout << " entry not valid " << std::endl;
75113 : }
75114 : }
75115 : else
75116 : {
75117 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
75118 : }
75119 : }
75120 :
75121 0 : if ( p_body != NULL )
75122 : {
75123 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75124 : {
75125 0 : if ( p_body->isInMemoryPool() == false )
75126 : {
75127 0 : std::cout << "SgOmpTargetExitDataStatement :: ";
75128 0 : std::cout << " p_body is not in memory pool of ";
75129 0 : std::cout << p_body->class_name() << std::endl;
75130 : }
75131 : }
75132 : else
75133 : {
75134 0 : std::cout << "SgOmpTargetExitDataStatement :: " << std::flush;
75135 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
75136 0 : std::cout << " not valid " << std::endl;
75137 : }
75138 : }
75139 :
75140 0 : if ( p_upir_parent != NULL )
75141 : {
75142 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75143 : {
75144 0 : if ( p_upir_parent->isInMemoryPool() == false )
75145 : {
75146 0 : std::cout << "SgOmpTargetExitDataStatement :: ";
75147 0 : std::cout << " p_upir_parent is not in memory pool of ";
75148 0 : std::cout << p_upir_parent->class_name() << std::endl;
75149 : }
75150 : }
75151 : else
75152 : {
75153 0 : std::cout << "SgOmpTargetExitDataStatement :: " << std::flush;
75154 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
75155 0 : std::cout << " not valid " << std::endl;
75156 : }
75157 : }
75158 :
75159 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
75160 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
75161 : {
75162 0 : if ( (*i_upir_children) != NULL )
75163 : {
75164 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75165 : {
75166 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
75167 : {
75168 0 : std::cout << "SgOmpTargetExitDataStatement :: ";
75169 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
75170 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
75171 : }
75172 : }
75173 : else
75174 : {
75175 0 : std::cout << "SgOmpTargetExitDataStatement :: " << std::flush;
75176 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
75177 0 : std::cout << " entry not valid " << std::endl;
75178 : }
75179 : }
75180 : else
75181 : {
75182 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
75183 : }
75184 : }
75185 :
75186 0 : if ( p_numeric_label != NULL )
75187 : {
75188 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75189 : {
75190 0 : if ( p_numeric_label->isInMemoryPool() == false )
75191 : {
75192 0 : std::cout << "SgOmpTargetExitDataStatement :: ";
75193 0 : std::cout << " p_numeric_label is not in memory pool of ";
75194 0 : std::cout << p_numeric_label->class_name() << std::endl;
75195 : }
75196 : }
75197 : else
75198 : {
75199 0 : std::cout << "SgOmpTargetExitDataStatement :: " << std::flush;
75200 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
75201 0 : std::cout << " not valid " << std::endl;
75202 : }
75203 : }
75204 :
75205 0 : if ( p_startOfConstruct != NULL )
75206 : {
75207 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75208 : {
75209 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
75210 : {
75211 0 : std::cout << "SgOmpTargetExitDataStatement :: ";
75212 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
75213 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
75214 : }
75215 : }
75216 : else
75217 : {
75218 0 : std::cout << "SgOmpTargetExitDataStatement :: " << std::flush;
75219 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
75220 0 : std::cout << " not valid " << std::endl;
75221 : }
75222 : }
75223 :
75224 0 : if ( p_endOfConstruct != NULL )
75225 : {
75226 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75227 : {
75228 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
75229 : {
75230 0 : std::cout << "SgOmpTargetExitDataStatement :: ";
75231 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
75232 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
75233 : }
75234 : }
75235 : else
75236 : {
75237 0 : std::cout << "SgOmpTargetExitDataStatement :: " << std::flush;
75238 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
75239 0 : std::cout << " not valid " << std::endl;
75240 : }
75241 : }
75242 :
75243 0 : if ( p_parent != NULL )
75244 : {
75245 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75246 : {
75247 0 : if ( p_parent->isInMemoryPool() == false )
75248 : {
75249 0 : std::cout << "SgOmpTargetExitDataStatement :: ";
75250 0 : std::cout << " p_parent is not in memory pool of ";
75251 0 : std::cout << p_parent->class_name() << std::endl;
75252 : }
75253 : }
75254 : else
75255 : {
75256 0 : std::cout << "SgOmpTargetExitDataStatement :: " << std::flush;
75257 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
75258 0 : std::cout << " not valid " << std::endl;
75259 : }
75260 : }
75261 :
75262 :
75263 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
75264 :
75265 0 : }
75266 :
75267 :
75268 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
75269 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
75270 : bool
75271 0 : SgOmpTargetExitDataStatement::isInMemoryPool ()
75272 : {
75273 0 : typedef unsigned char* TestType;
75274 :
75275 0 : bool found = false;
75276 :
75277 0 : ROSE_ASSERT(this != NULL);
75278 :
75279 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
75280 :
75281 0 : TestType tested = (TestType) ( this ) ;
75282 :
75283 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTargetExitDataStatement::pools.begin();
75284 :
75285 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
75286 : // while (found == false && block < Memory_Block_List.end())
75287 0 : while ( (found == false) && (block != SgOmpTargetExitDataStatement::pools.end()) )
75288 : {
75289 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTargetExitDataStatement::pool_size * sizeof(SgOmpTargetExitDataStatement) ) ) ;
75290 0 : ++block;
75291 : }
75292 :
75293 : // Special handling for static data
75294 :
75295 :
75296 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
75297 0 : ROSE_ASSERT(found == true);
75298 :
75299 0 : return found;
75300 : }
75301 : /* #line 75302 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
75302 :
75303 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
75304 :
75305 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
75306 :
75307 : /* #line 75308 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
75308 :
75309 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
75310 :
75311 : void
75312 0 : SgOmpParallelMasterStatement::checkDataMemberPointersIfInMemoryPool()
75313 : {
75314 : // ------------ checking pointers of SgOmpParallelMasterStatement -------------------
75315 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
75316 :
75317 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
75318 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
75319 : {
75320 0 : if ( (*i_clauses) != NULL )
75321 : {
75322 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75323 : {
75324 0 : if ( (*i_clauses)->isInMemoryPool() == false )
75325 : {
75326 0 : std::cout << "SgOmpParallelMasterStatement :: ";
75327 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
75328 0 : std::cout << (*i_clauses)->class_name() << std::endl;
75329 : }
75330 : }
75331 : else
75332 : {
75333 0 : std::cout << "SgOmpParallelMasterStatement :: " << std::flush;
75334 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
75335 0 : std::cout << " entry not valid " << std::endl;
75336 : }
75337 : }
75338 : else
75339 : {
75340 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
75341 : }
75342 : }
75343 :
75344 0 : if ( p_body != NULL )
75345 : {
75346 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75347 : {
75348 0 : if ( p_body->isInMemoryPool() == false )
75349 : {
75350 0 : std::cout << "SgOmpParallelMasterStatement :: ";
75351 0 : std::cout << " p_body is not in memory pool of ";
75352 0 : std::cout << p_body->class_name() << std::endl;
75353 : }
75354 : }
75355 : else
75356 : {
75357 0 : std::cout << "SgOmpParallelMasterStatement :: " << std::flush;
75358 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
75359 0 : std::cout << " not valid " << std::endl;
75360 : }
75361 : }
75362 :
75363 0 : if ( p_upir_parent != NULL )
75364 : {
75365 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75366 : {
75367 0 : if ( p_upir_parent->isInMemoryPool() == false )
75368 : {
75369 0 : std::cout << "SgOmpParallelMasterStatement :: ";
75370 0 : std::cout << " p_upir_parent is not in memory pool of ";
75371 0 : std::cout << p_upir_parent->class_name() << std::endl;
75372 : }
75373 : }
75374 : else
75375 : {
75376 0 : std::cout << "SgOmpParallelMasterStatement :: " << std::flush;
75377 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
75378 0 : std::cout << " not valid " << std::endl;
75379 : }
75380 : }
75381 :
75382 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
75383 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
75384 : {
75385 0 : if ( (*i_upir_children) != NULL )
75386 : {
75387 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75388 : {
75389 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
75390 : {
75391 0 : std::cout << "SgOmpParallelMasterStatement :: ";
75392 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
75393 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
75394 : }
75395 : }
75396 : else
75397 : {
75398 0 : std::cout << "SgOmpParallelMasterStatement :: " << std::flush;
75399 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
75400 0 : std::cout << " entry not valid " << std::endl;
75401 : }
75402 : }
75403 : else
75404 : {
75405 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
75406 : }
75407 : }
75408 :
75409 0 : if ( p_numeric_label != NULL )
75410 : {
75411 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75412 : {
75413 0 : if ( p_numeric_label->isInMemoryPool() == false )
75414 : {
75415 0 : std::cout << "SgOmpParallelMasterStatement :: ";
75416 0 : std::cout << " p_numeric_label is not in memory pool of ";
75417 0 : std::cout << p_numeric_label->class_name() << std::endl;
75418 : }
75419 : }
75420 : else
75421 : {
75422 0 : std::cout << "SgOmpParallelMasterStatement :: " << std::flush;
75423 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
75424 0 : std::cout << " not valid " << std::endl;
75425 : }
75426 : }
75427 :
75428 0 : if ( p_startOfConstruct != NULL )
75429 : {
75430 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75431 : {
75432 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
75433 : {
75434 0 : std::cout << "SgOmpParallelMasterStatement :: ";
75435 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
75436 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
75437 : }
75438 : }
75439 : else
75440 : {
75441 0 : std::cout << "SgOmpParallelMasterStatement :: " << std::flush;
75442 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
75443 0 : std::cout << " not valid " << std::endl;
75444 : }
75445 : }
75446 :
75447 0 : if ( p_endOfConstruct != NULL )
75448 : {
75449 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75450 : {
75451 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
75452 : {
75453 0 : std::cout << "SgOmpParallelMasterStatement :: ";
75454 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
75455 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
75456 : }
75457 : }
75458 : else
75459 : {
75460 0 : std::cout << "SgOmpParallelMasterStatement :: " << std::flush;
75461 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
75462 0 : std::cout << " not valid " << std::endl;
75463 : }
75464 : }
75465 :
75466 0 : if ( p_parent != NULL )
75467 : {
75468 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75469 : {
75470 0 : if ( p_parent->isInMemoryPool() == false )
75471 : {
75472 0 : std::cout << "SgOmpParallelMasterStatement :: ";
75473 0 : std::cout << " p_parent is not in memory pool of ";
75474 0 : std::cout << p_parent->class_name() << std::endl;
75475 : }
75476 : }
75477 : else
75478 : {
75479 0 : std::cout << "SgOmpParallelMasterStatement :: " << std::flush;
75480 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
75481 0 : std::cout << " not valid " << std::endl;
75482 : }
75483 : }
75484 :
75485 :
75486 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
75487 :
75488 0 : }
75489 :
75490 :
75491 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
75492 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
75493 : bool
75494 0 : SgOmpParallelMasterStatement::isInMemoryPool ()
75495 : {
75496 0 : typedef unsigned char* TestType;
75497 :
75498 0 : bool found = false;
75499 :
75500 0 : ROSE_ASSERT(this != NULL);
75501 :
75502 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
75503 :
75504 0 : TestType tested = (TestType) ( this ) ;
75505 :
75506 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpParallelMasterStatement::pools.begin();
75507 :
75508 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
75509 : // while (found == false && block < Memory_Block_List.end())
75510 0 : while ( (found == false) && (block != SgOmpParallelMasterStatement::pools.end()) )
75511 : {
75512 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpParallelMasterStatement::pool_size * sizeof(SgOmpParallelMasterStatement) ) ) ;
75513 0 : ++block;
75514 : }
75515 :
75516 : // Special handling for static data
75517 :
75518 :
75519 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
75520 0 : ROSE_ASSERT(found == true);
75521 :
75522 0 : return found;
75523 : }
75524 : /* #line 75525 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
75525 :
75526 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
75527 :
75528 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
75529 :
75530 : /* #line 75531 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
75531 :
75532 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
75533 :
75534 : void
75535 0 : SgOmpMasterTaskloopStatement::checkDataMemberPointersIfInMemoryPool()
75536 : {
75537 : // ------------ checking pointers of SgOmpMasterTaskloopStatement -------------------
75538 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
75539 :
75540 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
75541 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
75542 : {
75543 0 : if ( (*i_clauses) != NULL )
75544 : {
75545 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75546 : {
75547 0 : if ( (*i_clauses)->isInMemoryPool() == false )
75548 : {
75549 0 : std::cout << "SgOmpMasterTaskloopStatement :: ";
75550 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
75551 0 : std::cout << (*i_clauses)->class_name() << std::endl;
75552 : }
75553 : }
75554 : else
75555 : {
75556 0 : std::cout << "SgOmpMasterTaskloopStatement :: " << std::flush;
75557 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
75558 0 : std::cout << " entry not valid " << std::endl;
75559 : }
75560 : }
75561 : else
75562 : {
75563 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
75564 : }
75565 : }
75566 :
75567 0 : if ( p_body != NULL )
75568 : {
75569 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75570 : {
75571 0 : if ( p_body->isInMemoryPool() == false )
75572 : {
75573 0 : std::cout << "SgOmpMasterTaskloopStatement :: ";
75574 0 : std::cout << " p_body is not in memory pool of ";
75575 0 : std::cout << p_body->class_name() << std::endl;
75576 : }
75577 : }
75578 : else
75579 : {
75580 0 : std::cout << "SgOmpMasterTaskloopStatement :: " << std::flush;
75581 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
75582 0 : std::cout << " not valid " << std::endl;
75583 : }
75584 : }
75585 :
75586 0 : if ( p_upir_parent != NULL )
75587 : {
75588 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75589 : {
75590 0 : if ( p_upir_parent->isInMemoryPool() == false )
75591 : {
75592 0 : std::cout << "SgOmpMasterTaskloopStatement :: ";
75593 0 : std::cout << " p_upir_parent is not in memory pool of ";
75594 0 : std::cout << p_upir_parent->class_name() << std::endl;
75595 : }
75596 : }
75597 : else
75598 : {
75599 0 : std::cout << "SgOmpMasterTaskloopStatement :: " << std::flush;
75600 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
75601 0 : std::cout << " not valid " << std::endl;
75602 : }
75603 : }
75604 :
75605 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
75606 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
75607 : {
75608 0 : if ( (*i_upir_children) != NULL )
75609 : {
75610 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75611 : {
75612 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
75613 : {
75614 0 : std::cout << "SgOmpMasterTaskloopStatement :: ";
75615 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
75616 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
75617 : }
75618 : }
75619 : else
75620 : {
75621 0 : std::cout << "SgOmpMasterTaskloopStatement :: " << std::flush;
75622 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
75623 0 : std::cout << " entry not valid " << std::endl;
75624 : }
75625 : }
75626 : else
75627 : {
75628 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
75629 : }
75630 : }
75631 :
75632 0 : if ( p_numeric_label != NULL )
75633 : {
75634 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75635 : {
75636 0 : if ( p_numeric_label->isInMemoryPool() == false )
75637 : {
75638 0 : std::cout << "SgOmpMasterTaskloopStatement :: ";
75639 0 : std::cout << " p_numeric_label is not in memory pool of ";
75640 0 : std::cout << p_numeric_label->class_name() << std::endl;
75641 : }
75642 : }
75643 : else
75644 : {
75645 0 : std::cout << "SgOmpMasterTaskloopStatement :: " << std::flush;
75646 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
75647 0 : std::cout << " not valid " << std::endl;
75648 : }
75649 : }
75650 :
75651 0 : if ( p_startOfConstruct != NULL )
75652 : {
75653 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75654 : {
75655 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
75656 : {
75657 0 : std::cout << "SgOmpMasterTaskloopStatement :: ";
75658 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
75659 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
75660 : }
75661 : }
75662 : else
75663 : {
75664 0 : std::cout << "SgOmpMasterTaskloopStatement :: " << std::flush;
75665 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
75666 0 : std::cout << " not valid " << std::endl;
75667 : }
75668 : }
75669 :
75670 0 : if ( p_endOfConstruct != NULL )
75671 : {
75672 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75673 : {
75674 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
75675 : {
75676 0 : std::cout << "SgOmpMasterTaskloopStatement :: ";
75677 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
75678 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
75679 : }
75680 : }
75681 : else
75682 : {
75683 0 : std::cout << "SgOmpMasterTaskloopStatement :: " << std::flush;
75684 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
75685 0 : std::cout << " not valid " << std::endl;
75686 : }
75687 : }
75688 :
75689 0 : if ( p_parent != NULL )
75690 : {
75691 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75692 : {
75693 0 : if ( p_parent->isInMemoryPool() == false )
75694 : {
75695 0 : std::cout << "SgOmpMasterTaskloopStatement :: ";
75696 0 : std::cout << " p_parent is not in memory pool of ";
75697 0 : std::cout << p_parent->class_name() << std::endl;
75698 : }
75699 : }
75700 : else
75701 : {
75702 0 : std::cout << "SgOmpMasterTaskloopStatement :: " << std::flush;
75703 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
75704 0 : std::cout << " not valid " << std::endl;
75705 : }
75706 : }
75707 :
75708 :
75709 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
75710 :
75711 0 : }
75712 :
75713 :
75714 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
75715 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
75716 : bool
75717 0 : SgOmpMasterTaskloopStatement::isInMemoryPool ()
75718 : {
75719 0 : typedef unsigned char* TestType;
75720 :
75721 0 : bool found = false;
75722 :
75723 0 : ROSE_ASSERT(this != NULL);
75724 :
75725 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
75726 :
75727 0 : TestType tested = (TestType) ( this ) ;
75728 :
75729 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpMasterTaskloopStatement::pools.begin();
75730 :
75731 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
75732 : // while (found == false && block < Memory_Block_List.end())
75733 0 : while ( (found == false) && (block != SgOmpMasterTaskloopStatement::pools.end()) )
75734 : {
75735 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpMasterTaskloopStatement::pool_size * sizeof(SgOmpMasterTaskloopStatement) ) ) ;
75736 0 : ++block;
75737 : }
75738 :
75739 : // Special handling for static data
75740 :
75741 :
75742 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
75743 0 : ROSE_ASSERT(found == true);
75744 :
75745 0 : return found;
75746 : }
75747 : /* #line 75748 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
75748 :
75749 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
75750 :
75751 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
75752 :
75753 : /* #line 75754 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
75754 :
75755 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
75756 :
75757 : void
75758 0 : SgOmpTaskStatement::checkDataMemberPointersIfInMemoryPool()
75759 : {
75760 : // ------------ checking pointers of SgOmpTaskStatement -------------------
75761 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
75762 :
75763 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
75764 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
75765 : {
75766 0 : if ( (*i_clauses) != NULL )
75767 : {
75768 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75769 : {
75770 0 : if ( (*i_clauses)->isInMemoryPool() == false )
75771 : {
75772 0 : std::cout << "SgOmpTaskStatement :: ";
75773 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
75774 0 : std::cout << (*i_clauses)->class_name() << std::endl;
75775 : }
75776 : }
75777 : else
75778 : {
75779 0 : std::cout << "SgOmpTaskStatement :: " << std::flush;
75780 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
75781 0 : std::cout << " entry not valid " << std::endl;
75782 : }
75783 : }
75784 : else
75785 : {
75786 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
75787 : }
75788 : }
75789 :
75790 0 : if ( p_body != NULL )
75791 : {
75792 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75793 : {
75794 0 : if ( p_body->isInMemoryPool() == false )
75795 : {
75796 0 : std::cout << "SgOmpTaskStatement :: ";
75797 0 : std::cout << " p_body is not in memory pool of ";
75798 0 : std::cout << p_body->class_name() << std::endl;
75799 : }
75800 : }
75801 : else
75802 : {
75803 0 : std::cout << "SgOmpTaskStatement :: " << std::flush;
75804 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
75805 0 : std::cout << " not valid " << std::endl;
75806 : }
75807 : }
75808 :
75809 0 : if ( p_upir_parent != NULL )
75810 : {
75811 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75812 : {
75813 0 : if ( p_upir_parent->isInMemoryPool() == false )
75814 : {
75815 0 : std::cout << "SgOmpTaskStatement :: ";
75816 0 : std::cout << " p_upir_parent is not in memory pool of ";
75817 0 : std::cout << p_upir_parent->class_name() << std::endl;
75818 : }
75819 : }
75820 : else
75821 : {
75822 0 : std::cout << "SgOmpTaskStatement :: " << std::flush;
75823 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
75824 0 : std::cout << " not valid " << std::endl;
75825 : }
75826 : }
75827 :
75828 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
75829 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
75830 : {
75831 0 : if ( (*i_upir_children) != NULL )
75832 : {
75833 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75834 : {
75835 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
75836 : {
75837 0 : std::cout << "SgOmpTaskStatement :: ";
75838 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
75839 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
75840 : }
75841 : }
75842 : else
75843 : {
75844 0 : std::cout << "SgOmpTaskStatement :: " << std::flush;
75845 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
75846 0 : std::cout << " entry not valid " << std::endl;
75847 : }
75848 : }
75849 : else
75850 : {
75851 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
75852 : }
75853 : }
75854 :
75855 0 : if ( p_numeric_label != NULL )
75856 : {
75857 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75858 : {
75859 0 : if ( p_numeric_label->isInMemoryPool() == false )
75860 : {
75861 0 : std::cout << "SgOmpTaskStatement :: ";
75862 0 : std::cout << " p_numeric_label is not in memory pool of ";
75863 0 : std::cout << p_numeric_label->class_name() << std::endl;
75864 : }
75865 : }
75866 : else
75867 : {
75868 0 : std::cout << "SgOmpTaskStatement :: " << std::flush;
75869 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
75870 0 : std::cout << " not valid " << std::endl;
75871 : }
75872 : }
75873 :
75874 0 : if ( p_startOfConstruct != NULL )
75875 : {
75876 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75877 : {
75878 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
75879 : {
75880 0 : std::cout << "SgOmpTaskStatement :: ";
75881 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
75882 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
75883 : }
75884 : }
75885 : else
75886 : {
75887 0 : std::cout << "SgOmpTaskStatement :: " << std::flush;
75888 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
75889 0 : std::cout << " not valid " << std::endl;
75890 : }
75891 : }
75892 :
75893 0 : if ( p_endOfConstruct != NULL )
75894 : {
75895 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75896 : {
75897 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
75898 : {
75899 0 : std::cout << "SgOmpTaskStatement :: ";
75900 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
75901 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
75902 : }
75903 : }
75904 : else
75905 : {
75906 0 : std::cout << "SgOmpTaskStatement :: " << std::flush;
75907 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
75908 0 : std::cout << " not valid " << std::endl;
75909 : }
75910 : }
75911 :
75912 0 : if ( p_parent != NULL )
75913 : {
75914 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75915 : {
75916 0 : if ( p_parent->isInMemoryPool() == false )
75917 : {
75918 0 : std::cout << "SgOmpTaskStatement :: ";
75919 0 : std::cout << " p_parent is not in memory pool of ";
75920 0 : std::cout << p_parent->class_name() << std::endl;
75921 : }
75922 : }
75923 : else
75924 : {
75925 0 : std::cout << "SgOmpTaskStatement :: " << std::flush;
75926 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
75927 0 : std::cout << " not valid " << std::endl;
75928 : }
75929 : }
75930 :
75931 :
75932 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
75933 :
75934 0 : }
75935 :
75936 :
75937 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
75938 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
75939 : bool
75940 0 : SgOmpTaskStatement::isInMemoryPool ()
75941 : {
75942 0 : typedef unsigned char* TestType;
75943 :
75944 0 : bool found = false;
75945 :
75946 0 : ROSE_ASSERT(this != NULL);
75947 :
75948 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
75949 :
75950 0 : TestType tested = (TestType) ( this ) ;
75951 :
75952 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTaskStatement::pools.begin();
75953 :
75954 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
75955 : // while (found == false && block < Memory_Block_List.end())
75956 0 : while ( (found == false) && (block != SgOmpTaskStatement::pools.end()) )
75957 : {
75958 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTaskStatement::pool_size * sizeof(SgOmpTaskStatement) ) ) ;
75959 0 : ++block;
75960 : }
75961 :
75962 : // Special handling for static data
75963 :
75964 :
75965 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
75966 0 : ROSE_ASSERT(found == true);
75967 :
75968 0 : return found;
75969 : }
75970 : /* #line 75971 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
75971 :
75972 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
75973 :
75974 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
75975 :
75976 : /* #line 75977 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
75977 :
75978 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
75979 :
75980 : void
75981 0 : SgOmpDoStatement::checkDataMemberPointersIfInMemoryPool()
75982 : {
75983 : // ------------ checking pointers of SgOmpDoStatement -------------------
75984 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
75985 :
75986 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
75987 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
75988 : {
75989 0 : if ( (*i_clauses) != NULL )
75990 : {
75991 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
75992 : {
75993 0 : if ( (*i_clauses)->isInMemoryPool() == false )
75994 : {
75995 0 : std::cout << "SgOmpDoStatement :: ";
75996 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
75997 0 : std::cout << (*i_clauses)->class_name() << std::endl;
75998 : }
75999 : }
76000 : else
76001 : {
76002 0 : std::cout << "SgOmpDoStatement :: " << std::flush;
76003 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
76004 0 : std::cout << " entry not valid " << std::endl;
76005 : }
76006 : }
76007 : else
76008 : {
76009 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
76010 : }
76011 : }
76012 :
76013 0 : if ( p_body != NULL )
76014 : {
76015 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76016 : {
76017 0 : if ( p_body->isInMemoryPool() == false )
76018 : {
76019 0 : std::cout << "SgOmpDoStatement :: ";
76020 0 : std::cout << " p_body is not in memory pool of ";
76021 0 : std::cout << p_body->class_name() << std::endl;
76022 : }
76023 : }
76024 : else
76025 : {
76026 0 : std::cout << "SgOmpDoStatement :: " << std::flush;
76027 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
76028 0 : std::cout << " not valid " << std::endl;
76029 : }
76030 : }
76031 :
76032 0 : if ( p_upir_parent != NULL )
76033 : {
76034 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76035 : {
76036 0 : if ( p_upir_parent->isInMemoryPool() == false )
76037 : {
76038 0 : std::cout << "SgOmpDoStatement :: ";
76039 0 : std::cout << " p_upir_parent is not in memory pool of ";
76040 0 : std::cout << p_upir_parent->class_name() << std::endl;
76041 : }
76042 : }
76043 : else
76044 : {
76045 0 : std::cout << "SgOmpDoStatement :: " << std::flush;
76046 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
76047 0 : std::cout << " not valid " << std::endl;
76048 : }
76049 : }
76050 :
76051 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
76052 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
76053 : {
76054 0 : if ( (*i_upir_children) != NULL )
76055 : {
76056 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76057 : {
76058 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
76059 : {
76060 0 : std::cout << "SgOmpDoStatement :: ";
76061 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
76062 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
76063 : }
76064 : }
76065 : else
76066 : {
76067 0 : std::cout << "SgOmpDoStatement :: " << std::flush;
76068 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
76069 0 : std::cout << " entry not valid " << std::endl;
76070 : }
76071 : }
76072 : else
76073 : {
76074 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
76075 : }
76076 : }
76077 :
76078 0 : if ( p_numeric_label != NULL )
76079 : {
76080 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76081 : {
76082 0 : if ( p_numeric_label->isInMemoryPool() == false )
76083 : {
76084 0 : std::cout << "SgOmpDoStatement :: ";
76085 0 : std::cout << " p_numeric_label is not in memory pool of ";
76086 0 : std::cout << p_numeric_label->class_name() << std::endl;
76087 : }
76088 : }
76089 : else
76090 : {
76091 0 : std::cout << "SgOmpDoStatement :: " << std::flush;
76092 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
76093 0 : std::cout << " not valid " << std::endl;
76094 : }
76095 : }
76096 :
76097 0 : if ( p_startOfConstruct != NULL )
76098 : {
76099 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76100 : {
76101 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
76102 : {
76103 0 : std::cout << "SgOmpDoStatement :: ";
76104 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
76105 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
76106 : }
76107 : }
76108 : else
76109 : {
76110 0 : std::cout << "SgOmpDoStatement :: " << std::flush;
76111 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
76112 0 : std::cout << " not valid " << std::endl;
76113 : }
76114 : }
76115 :
76116 0 : if ( p_endOfConstruct != NULL )
76117 : {
76118 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76119 : {
76120 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
76121 : {
76122 0 : std::cout << "SgOmpDoStatement :: ";
76123 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
76124 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
76125 : }
76126 : }
76127 : else
76128 : {
76129 0 : std::cout << "SgOmpDoStatement :: " << std::flush;
76130 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
76131 0 : std::cout << " not valid " << std::endl;
76132 : }
76133 : }
76134 :
76135 0 : if ( p_parent != NULL )
76136 : {
76137 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76138 : {
76139 0 : if ( p_parent->isInMemoryPool() == false )
76140 : {
76141 0 : std::cout << "SgOmpDoStatement :: ";
76142 0 : std::cout << " p_parent is not in memory pool of ";
76143 0 : std::cout << p_parent->class_name() << std::endl;
76144 : }
76145 : }
76146 : else
76147 : {
76148 0 : std::cout << "SgOmpDoStatement :: " << std::flush;
76149 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
76150 0 : std::cout << " not valid " << std::endl;
76151 : }
76152 : }
76153 :
76154 :
76155 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
76156 :
76157 0 : }
76158 :
76159 :
76160 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
76161 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
76162 : bool
76163 0 : SgOmpDoStatement::isInMemoryPool ()
76164 : {
76165 0 : typedef unsigned char* TestType;
76166 :
76167 0 : bool found = false;
76168 :
76169 0 : ROSE_ASSERT(this != NULL);
76170 :
76171 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
76172 :
76173 0 : TestType tested = (TestType) ( this ) ;
76174 :
76175 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDoStatement::pools.begin();
76176 :
76177 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
76178 : // while (found == false && block < Memory_Block_List.end())
76179 0 : while ( (found == false) && (block != SgOmpDoStatement::pools.end()) )
76180 : {
76181 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDoStatement::pool_size * sizeof(SgOmpDoStatement) ) ) ;
76182 0 : ++block;
76183 : }
76184 :
76185 : // Special handling for static data
76186 :
76187 :
76188 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
76189 0 : ROSE_ASSERT(found == true);
76190 :
76191 0 : return found;
76192 : }
76193 : /* #line 76194 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
76194 :
76195 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
76196 :
76197 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
76198 :
76199 : /* #line 76200 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
76200 :
76201 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
76202 :
76203 : void
76204 0 : SgOmpSectionsStatement::checkDataMemberPointersIfInMemoryPool()
76205 : {
76206 : // ------------ checking pointers of SgOmpSectionsStatement -------------------
76207 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
76208 :
76209 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
76210 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
76211 : {
76212 0 : if ( (*i_clauses) != NULL )
76213 : {
76214 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76215 : {
76216 0 : if ( (*i_clauses)->isInMemoryPool() == false )
76217 : {
76218 0 : std::cout << "SgOmpSectionsStatement :: ";
76219 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
76220 0 : std::cout << (*i_clauses)->class_name() << std::endl;
76221 : }
76222 : }
76223 : else
76224 : {
76225 0 : std::cout << "SgOmpSectionsStatement :: " << std::flush;
76226 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
76227 0 : std::cout << " entry not valid " << std::endl;
76228 : }
76229 : }
76230 : else
76231 : {
76232 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
76233 : }
76234 : }
76235 :
76236 0 : if ( p_body != NULL )
76237 : {
76238 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76239 : {
76240 0 : if ( p_body->isInMemoryPool() == false )
76241 : {
76242 0 : std::cout << "SgOmpSectionsStatement :: ";
76243 0 : std::cout << " p_body is not in memory pool of ";
76244 0 : std::cout << p_body->class_name() << std::endl;
76245 : }
76246 : }
76247 : else
76248 : {
76249 0 : std::cout << "SgOmpSectionsStatement :: " << std::flush;
76250 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
76251 0 : std::cout << " not valid " << std::endl;
76252 : }
76253 : }
76254 :
76255 0 : if ( p_upir_parent != NULL )
76256 : {
76257 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76258 : {
76259 0 : if ( p_upir_parent->isInMemoryPool() == false )
76260 : {
76261 0 : std::cout << "SgOmpSectionsStatement :: ";
76262 0 : std::cout << " p_upir_parent is not in memory pool of ";
76263 0 : std::cout << p_upir_parent->class_name() << std::endl;
76264 : }
76265 : }
76266 : else
76267 : {
76268 0 : std::cout << "SgOmpSectionsStatement :: " << std::flush;
76269 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
76270 0 : std::cout << " not valid " << std::endl;
76271 : }
76272 : }
76273 :
76274 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
76275 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
76276 : {
76277 0 : if ( (*i_upir_children) != NULL )
76278 : {
76279 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76280 : {
76281 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
76282 : {
76283 0 : std::cout << "SgOmpSectionsStatement :: ";
76284 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
76285 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
76286 : }
76287 : }
76288 : else
76289 : {
76290 0 : std::cout << "SgOmpSectionsStatement :: " << std::flush;
76291 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
76292 0 : std::cout << " entry not valid " << std::endl;
76293 : }
76294 : }
76295 : else
76296 : {
76297 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
76298 : }
76299 : }
76300 :
76301 0 : if ( p_numeric_label != NULL )
76302 : {
76303 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76304 : {
76305 0 : if ( p_numeric_label->isInMemoryPool() == false )
76306 : {
76307 0 : std::cout << "SgOmpSectionsStatement :: ";
76308 0 : std::cout << " p_numeric_label is not in memory pool of ";
76309 0 : std::cout << p_numeric_label->class_name() << std::endl;
76310 : }
76311 : }
76312 : else
76313 : {
76314 0 : std::cout << "SgOmpSectionsStatement :: " << std::flush;
76315 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
76316 0 : std::cout << " not valid " << std::endl;
76317 : }
76318 : }
76319 :
76320 0 : if ( p_startOfConstruct != NULL )
76321 : {
76322 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76323 : {
76324 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
76325 : {
76326 0 : std::cout << "SgOmpSectionsStatement :: ";
76327 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
76328 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
76329 : }
76330 : }
76331 : else
76332 : {
76333 0 : std::cout << "SgOmpSectionsStatement :: " << std::flush;
76334 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
76335 0 : std::cout << " not valid " << std::endl;
76336 : }
76337 : }
76338 :
76339 0 : if ( p_endOfConstruct != NULL )
76340 : {
76341 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76342 : {
76343 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
76344 : {
76345 0 : std::cout << "SgOmpSectionsStatement :: ";
76346 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
76347 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
76348 : }
76349 : }
76350 : else
76351 : {
76352 0 : std::cout << "SgOmpSectionsStatement :: " << std::flush;
76353 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
76354 0 : std::cout << " not valid " << std::endl;
76355 : }
76356 : }
76357 :
76358 0 : if ( p_parent != NULL )
76359 : {
76360 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76361 : {
76362 0 : if ( p_parent->isInMemoryPool() == false )
76363 : {
76364 0 : std::cout << "SgOmpSectionsStatement :: ";
76365 0 : std::cout << " p_parent is not in memory pool of ";
76366 0 : std::cout << p_parent->class_name() << std::endl;
76367 : }
76368 : }
76369 : else
76370 : {
76371 0 : std::cout << "SgOmpSectionsStatement :: " << std::flush;
76372 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
76373 0 : std::cout << " not valid " << std::endl;
76374 : }
76375 : }
76376 :
76377 :
76378 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
76379 :
76380 0 : }
76381 :
76382 :
76383 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
76384 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
76385 : bool
76386 0 : SgOmpSectionsStatement::isInMemoryPool ()
76387 : {
76388 0 : typedef unsigned char* TestType;
76389 :
76390 0 : bool found = false;
76391 :
76392 0 : ROSE_ASSERT(this != NULL);
76393 :
76394 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
76395 :
76396 0 : TestType tested = (TestType) ( this ) ;
76397 :
76398 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpSectionsStatement::pools.begin();
76399 :
76400 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
76401 : // while (found == false && block < Memory_Block_List.end())
76402 0 : while ( (found == false) && (block != SgOmpSectionsStatement::pools.end()) )
76403 : {
76404 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpSectionsStatement::pool_size * sizeof(SgOmpSectionsStatement) ) ) ;
76405 0 : ++block;
76406 : }
76407 :
76408 : // Special handling for static data
76409 :
76410 :
76411 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
76412 0 : ROSE_ASSERT(found == true);
76413 :
76414 0 : return found;
76415 : }
76416 : /* #line 76417 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
76417 :
76418 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
76419 :
76420 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
76421 :
76422 : /* #line 76423 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
76423 :
76424 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
76425 :
76426 : void
76427 0 : SgUpirTaskStatement::checkDataMemberPointersIfInMemoryPool()
76428 : {
76429 : // ------------ checking pointers of SgUpirTaskStatement -------------------
76430 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
76431 :
76432 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
76433 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
76434 : {
76435 0 : if ( (*i_clauses) != NULL )
76436 : {
76437 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76438 : {
76439 0 : if ( (*i_clauses)->isInMemoryPool() == false )
76440 : {
76441 0 : std::cout << "SgUpirTaskStatement :: ";
76442 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
76443 0 : std::cout << (*i_clauses)->class_name() << std::endl;
76444 : }
76445 : }
76446 : else
76447 : {
76448 0 : std::cout << "SgUpirTaskStatement :: " << std::flush;
76449 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
76450 0 : std::cout << " entry not valid " << std::endl;
76451 : }
76452 : }
76453 : else
76454 : {
76455 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
76456 : }
76457 : }
76458 :
76459 0 : if ( p_body != NULL )
76460 : {
76461 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76462 : {
76463 0 : if ( p_body->isInMemoryPool() == false )
76464 : {
76465 0 : std::cout << "SgUpirTaskStatement :: ";
76466 0 : std::cout << " p_body is not in memory pool of ";
76467 0 : std::cout << p_body->class_name() << std::endl;
76468 : }
76469 : }
76470 : else
76471 : {
76472 0 : std::cout << "SgUpirTaskStatement :: " << std::flush;
76473 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
76474 0 : std::cout << " not valid " << std::endl;
76475 : }
76476 : }
76477 :
76478 0 : if ( p_upir_parent != NULL )
76479 : {
76480 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76481 : {
76482 0 : if ( p_upir_parent->isInMemoryPool() == false )
76483 : {
76484 0 : std::cout << "SgUpirTaskStatement :: ";
76485 0 : std::cout << " p_upir_parent is not in memory pool of ";
76486 0 : std::cout << p_upir_parent->class_name() << std::endl;
76487 : }
76488 : }
76489 : else
76490 : {
76491 0 : std::cout << "SgUpirTaskStatement :: " << std::flush;
76492 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
76493 0 : std::cout << " not valid " << std::endl;
76494 : }
76495 : }
76496 :
76497 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
76498 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
76499 : {
76500 0 : if ( (*i_upir_children) != NULL )
76501 : {
76502 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76503 : {
76504 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
76505 : {
76506 0 : std::cout << "SgUpirTaskStatement :: ";
76507 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
76508 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
76509 : }
76510 : }
76511 : else
76512 : {
76513 0 : std::cout << "SgUpirTaskStatement :: " << std::flush;
76514 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
76515 0 : std::cout << " entry not valid " << std::endl;
76516 : }
76517 : }
76518 : else
76519 : {
76520 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
76521 : }
76522 : }
76523 :
76524 0 : if ( p_numeric_label != NULL )
76525 : {
76526 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76527 : {
76528 0 : if ( p_numeric_label->isInMemoryPool() == false )
76529 : {
76530 0 : std::cout << "SgUpirTaskStatement :: ";
76531 0 : std::cout << " p_numeric_label is not in memory pool of ";
76532 0 : std::cout << p_numeric_label->class_name() << std::endl;
76533 : }
76534 : }
76535 : else
76536 : {
76537 0 : std::cout << "SgUpirTaskStatement :: " << std::flush;
76538 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
76539 0 : std::cout << " not valid " << std::endl;
76540 : }
76541 : }
76542 :
76543 0 : if ( p_startOfConstruct != NULL )
76544 : {
76545 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76546 : {
76547 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
76548 : {
76549 0 : std::cout << "SgUpirTaskStatement :: ";
76550 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
76551 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
76552 : }
76553 : }
76554 : else
76555 : {
76556 0 : std::cout << "SgUpirTaskStatement :: " << std::flush;
76557 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
76558 0 : std::cout << " not valid " << std::endl;
76559 : }
76560 : }
76561 :
76562 0 : if ( p_endOfConstruct != NULL )
76563 : {
76564 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76565 : {
76566 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
76567 : {
76568 0 : std::cout << "SgUpirTaskStatement :: ";
76569 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
76570 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
76571 : }
76572 : }
76573 : else
76574 : {
76575 0 : std::cout << "SgUpirTaskStatement :: " << std::flush;
76576 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
76577 0 : std::cout << " not valid " << std::endl;
76578 : }
76579 : }
76580 :
76581 0 : if ( p_parent != NULL )
76582 : {
76583 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76584 : {
76585 0 : if ( p_parent->isInMemoryPool() == false )
76586 : {
76587 0 : std::cout << "SgUpirTaskStatement :: ";
76588 0 : std::cout << " p_parent is not in memory pool of ";
76589 0 : std::cout << p_parent->class_name() << std::endl;
76590 : }
76591 : }
76592 : else
76593 : {
76594 0 : std::cout << "SgUpirTaskStatement :: " << std::flush;
76595 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
76596 0 : std::cout << " not valid " << std::endl;
76597 : }
76598 : }
76599 :
76600 :
76601 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
76602 :
76603 0 : }
76604 :
76605 :
76606 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
76607 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
76608 : bool
76609 0 : SgUpirTaskStatement::isInMemoryPool ()
76610 : {
76611 0 : typedef unsigned char* TestType;
76612 :
76613 0 : bool found = false;
76614 :
76615 0 : ROSE_ASSERT(this != NULL);
76616 :
76617 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
76618 :
76619 0 : TestType tested = (TestType) ( this ) ;
76620 :
76621 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirTaskStatement::pools.begin();
76622 :
76623 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
76624 : // while (found == false && block < Memory_Block_List.end())
76625 0 : while ( (found == false) && (block != SgUpirTaskStatement::pools.end()) )
76626 : {
76627 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirTaskStatement::pool_size * sizeof(SgUpirTaskStatement) ) ) ;
76628 0 : ++block;
76629 : }
76630 :
76631 : // Special handling for static data
76632 :
76633 :
76634 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
76635 0 : ROSE_ASSERT(found == true);
76636 :
76637 0 : return found;
76638 : }
76639 : /* #line 76640 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
76640 :
76641 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
76642 :
76643 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
76644 :
76645 : /* #line 76646 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
76646 :
76647 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
76648 :
76649 : void
76650 0 : SgOmpTargetDataStatement::checkDataMemberPointersIfInMemoryPool()
76651 : {
76652 : // ------------ checking pointers of SgOmpTargetDataStatement -------------------
76653 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
76654 :
76655 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
76656 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
76657 : {
76658 0 : if ( (*i_clauses) != NULL )
76659 : {
76660 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76661 : {
76662 0 : if ( (*i_clauses)->isInMemoryPool() == false )
76663 : {
76664 0 : std::cout << "SgOmpTargetDataStatement :: ";
76665 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
76666 0 : std::cout << (*i_clauses)->class_name() << std::endl;
76667 : }
76668 : }
76669 : else
76670 : {
76671 0 : std::cout << "SgOmpTargetDataStatement :: " << std::flush;
76672 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
76673 0 : std::cout << " entry not valid " << std::endl;
76674 : }
76675 : }
76676 : else
76677 : {
76678 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
76679 : }
76680 : }
76681 :
76682 0 : if ( p_body != NULL )
76683 : {
76684 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76685 : {
76686 0 : if ( p_body->isInMemoryPool() == false )
76687 : {
76688 0 : std::cout << "SgOmpTargetDataStatement :: ";
76689 0 : std::cout << " p_body is not in memory pool of ";
76690 0 : std::cout << p_body->class_name() << std::endl;
76691 : }
76692 : }
76693 : else
76694 : {
76695 0 : std::cout << "SgOmpTargetDataStatement :: " << std::flush;
76696 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
76697 0 : std::cout << " not valid " << std::endl;
76698 : }
76699 : }
76700 :
76701 0 : if ( p_upir_parent != NULL )
76702 : {
76703 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76704 : {
76705 0 : if ( p_upir_parent->isInMemoryPool() == false )
76706 : {
76707 0 : std::cout << "SgOmpTargetDataStatement :: ";
76708 0 : std::cout << " p_upir_parent is not in memory pool of ";
76709 0 : std::cout << p_upir_parent->class_name() << std::endl;
76710 : }
76711 : }
76712 : else
76713 : {
76714 0 : std::cout << "SgOmpTargetDataStatement :: " << std::flush;
76715 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
76716 0 : std::cout << " not valid " << std::endl;
76717 : }
76718 : }
76719 :
76720 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
76721 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
76722 : {
76723 0 : if ( (*i_upir_children) != NULL )
76724 : {
76725 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76726 : {
76727 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
76728 : {
76729 0 : std::cout << "SgOmpTargetDataStatement :: ";
76730 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
76731 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
76732 : }
76733 : }
76734 : else
76735 : {
76736 0 : std::cout << "SgOmpTargetDataStatement :: " << std::flush;
76737 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
76738 0 : std::cout << " entry not valid " << std::endl;
76739 : }
76740 : }
76741 : else
76742 : {
76743 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
76744 : }
76745 : }
76746 :
76747 0 : if ( p_numeric_label != NULL )
76748 : {
76749 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76750 : {
76751 0 : if ( p_numeric_label->isInMemoryPool() == false )
76752 : {
76753 0 : std::cout << "SgOmpTargetDataStatement :: ";
76754 0 : std::cout << " p_numeric_label is not in memory pool of ";
76755 0 : std::cout << p_numeric_label->class_name() << std::endl;
76756 : }
76757 : }
76758 : else
76759 : {
76760 0 : std::cout << "SgOmpTargetDataStatement :: " << std::flush;
76761 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
76762 0 : std::cout << " not valid " << std::endl;
76763 : }
76764 : }
76765 :
76766 0 : if ( p_startOfConstruct != NULL )
76767 : {
76768 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76769 : {
76770 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
76771 : {
76772 0 : std::cout << "SgOmpTargetDataStatement :: ";
76773 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
76774 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
76775 : }
76776 : }
76777 : else
76778 : {
76779 0 : std::cout << "SgOmpTargetDataStatement :: " << std::flush;
76780 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
76781 0 : std::cout << " not valid " << std::endl;
76782 : }
76783 : }
76784 :
76785 0 : if ( p_endOfConstruct != NULL )
76786 : {
76787 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76788 : {
76789 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
76790 : {
76791 0 : std::cout << "SgOmpTargetDataStatement :: ";
76792 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
76793 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
76794 : }
76795 : }
76796 : else
76797 : {
76798 0 : std::cout << "SgOmpTargetDataStatement :: " << std::flush;
76799 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
76800 0 : std::cout << " not valid " << std::endl;
76801 : }
76802 : }
76803 :
76804 0 : if ( p_parent != NULL )
76805 : {
76806 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76807 : {
76808 0 : if ( p_parent->isInMemoryPool() == false )
76809 : {
76810 0 : std::cout << "SgOmpTargetDataStatement :: ";
76811 0 : std::cout << " p_parent is not in memory pool of ";
76812 0 : std::cout << p_parent->class_name() << std::endl;
76813 : }
76814 : }
76815 : else
76816 : {
76817 0 : std::cout << "SgOmpTargetDataStatement :: " << std::flush;
76818 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
76819 0 : std::cout << " not valid " << std::endl;
76820 : }
76821 : }
76822 :
76823 :
76824 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
76825 :
76826 0 : }
76827 :
76828 :
76829 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
76830 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
76831 : bool
76832 0 : SgOmpTargetDataStatement::isInMemoryPool ()
76833 : {
76834 0 : typedef unsigned char* TestType;
76835 :
76836 0 : bool found = false;
76837 :
76838 0 : ROSE_ASSERT(this != NULL);
76839 :
76840 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
76841 :
76842 0 : TestType tested = (TestType) ( this ) ;
76843 :
76844 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTargetDataStatement::pools.begin();
76845 :
76846 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
76847 : // while (found == false && block < Memory_Block_List.end())
76848 0 : while ( (found == false) && (block != SgOmpTargetDataStatement::pools.end()) )
76849 : {
76850 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTargetDataStatement::pool_size * sizeof(SgOmpTargetDataStatement) ) ) ;
76851 0 : ++block;
76852 : }
76853 :
76854 : // Special handling for static data
76855 :
76856 :
76857 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
76858 0 : ROSE_ASSERT(found == true);
76859 :
76860 0 : return found;
76861 : }
76862 : /* #line 76863 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
76863 :
76864 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
76865 :
76866 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
76867 :
76868 : /* #line 76869 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
76869 :
76870 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
76871 :
76872 : void
76873 0 : SgOmpTargetParallelForStatement::checkDataMemberPointersIfInMemoryPool()
76874 : {
76875 : // ------------ checking pointers of SgOmpTargetParallelForStatement -------------------
76876 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
76877 :
76878 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
76879 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
76880 : {
76881 0 : if ( (*i_clauses) != NULL )
76882 : {
76883 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76884 : {
76885 0 : if ( (*i_clauses)->isInMemoryPool() == false )
76886 : {
76887 0 : std::cout << "SgOmpTargetParallelForStatement :: ";
76888 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
76889 0 : std::cout << (*i_clauses)->class_name() << std::endl;
76890 : }
76891 : }
76892 : else
76893 : {
76894 0 : std::cout << "SgOmpTargetParallelForStatement :: " << std::flush;
76895 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
76896 0 : std::cout << " entry not valid " << std::endl;
76897 : }
76898 : }
76899 : else
76900 : {
76901 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
76902 : }
76903 : }
76904 :
76905 0 : if ( p_body != NULL )
76906 : {
76907 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76908 : {
76909 0 : if ( p_body->isInMemoryPool() == false )
76910 : {
76911 0 : std::cout << "SgOmpTargetParallelForStatement :: ";
76912 0 : std::cout << " p_body is not in memory pool of ";
76913 0 : std::cout << p_body->class_name() << std::endl;
76914 : }
76915 : }
76916 : else
76917 : {
76918 0 : std::cout << "SgOmpTargetParallelForStatement :: " << std::flush;
76919 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
76920 0 : std::cout << " not valid " << std::endl;
76921 : }
76922 : }
76923 :
76924 0 : if ( p_upir_parent != NULL )
76925 : {
76926 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76927 : {
76928 0 : if ( p_upir_parent->isInMemoryPool() == false )
76929 : {
76930 0 : std::cout << "SgOmpTargetParallelForStatement :: ";
76931 0 : std::cout << " p_upir_parent is not in memory pool of ";
76932 0 : std::cout << p_upir_parent->class_name() << std::endl;
76933 : }
76934 : }
76935 : else
76936 : {
76937 0 : std::cout << "SgOmpTargetParallelForStatement :: " << std::flush;
76938 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
76939 0 : std::cout << " not valid " << std::endl;
76940 : }
76941 : }
76942 :
76943 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
76944 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
76945 : {
76946 0 : if ( (*i_upir_children) != NULL )
76947 : {
76948 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76949 : {
76950 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
76951 : {
76952 0 : std::cout << "SgOmpTargetParallelForStatement :: ";
76953 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
76954 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
76955 : }
76956 : }
76957 : else
76958 : {
76959 0 : std::cout << "SgOmpTargetParallelForStatement :: " << std::flush;
76960 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
76961 0 : std::cout << " entry not valid " << std::endl;
76962 : }
76963 : }
76964 : else
76965 : {
76966 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
76967 : }
76968 : }
76969 :
76970 0 : if ( p_numeric_label != NULL )
76971 : {
76972 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76973 : {
76974 0 : if ( p_numeric_label->isInMemoryPool() == false )
76975 : {
76976 0 : std::cout << "SgOmpTargetParallelForStatement :: ";
76977 0 : std::cout << " p_numeric_label is not in memory pool of ";
76978 0 : std::cout << p_numeric_label->class_name() << std::endl;
76979 : }
76980 : }
76981 : else
76982 : {
76983 0 : std::cout << "SgOmpTargetParallelForStatement :: " << std::flush;
76984 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
76985 0 : std::cout << " not valid " << std::endl;
76986 : }
76987 : }
76988 :
76989 0 : if ( p_startOfConstruct != NULL )
76990 : {
76991 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
76992 : {
76993 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
76994 : {
76995 0 : std::cout << "SgOmpTargetParallelForStatement :: ";
76996 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
76997 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
76998 : }
76999 : }
77000 : else
77001 : {
77002 0 : std::cout << "SgOmpTargetParallelForStatement :: " << std::flush;
77003 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
77004 0 : std::cout << " not valid " << std::endl;
77005 : }
77006 : }
77007 :
77008 0 : if ( p_endOfConstruct != NULL )
77009 : {
77010 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77011 : {
77012 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
77013 : {
77014 0 : std::cout << "SgOmpTargetParallelForStatement :: ";
77015 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
77016 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
77017 : }
77018 : }
77019 : else
77020 : {
77021 0 : std::cout << "SgOmpTargetParallelForStatement :: " << std::flush;
77022 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
77023 0 : std::cout << " not valid " << std::endl;
77024 : }
77025 : }
77026 :
77027 0 : if ( p_parent != NULL )
77028 : {
77029 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77030 : {
77031 0 : if ( p_parent->isInMemoryPool() == false )
77032 : {
77033 0 : std::cout << "SgOmpTargetParallelForStatement :: ";
77034 0 : std::cout << " p_parent is not in memory pool of ";
77035 0 : std::cout << p_parent->class_name() << std::endl;
77036 : }
77037 : }
77038 : else
77039 : {
77040 0 : std::cout << "SgOmpTargetParallelForStatement :: " << std::flush;
77041 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
77042 0 : std::cout << " not valid " << std::endl;
77043 : }
77044 : }
77045 :
77046 :
77047 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
77048 :
77049 0 : }
77050 :
77051 :
77052 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
77053 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
77054 : bool
77055 0 : SgOmpTargetParallelForStatement::isInMemoryPool ()
77056 : {
77057 0 : typedef unsigned char* TestType;
77058 :
77059 0 : bool found = false;
77060 :
77061 0 : ROSE_ASSERT(this != NULL);
77062 :
77063 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
77064 :
77065 0 : TestType tested = (TestType) ( this ) ;
77066 :
77067 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTargetParallelForStatement::pools.begin();
77068 :
77069 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
77070 : // while (found == false && block < Memory_Block_List.end())
77071 0 : while ( (found == false) && (block != SgOmpTargetParallelForStatement::pools.end()) )
77072 : {
77073 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTargetParallelForStatement::pool_size * sizeof(SgOmpTargetParallelForStatement) ) ) ;
77074 0 : ++block;
77075 : }
77076 :
77077 : // Special handling for static data
77078 :
77079 :
77080 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
77081 0 : ROSE_ASSERT(found == true);
77082 :
77083 0 : return found;
77084 : }
77085 : /* #line 77086 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
77086 :
77087 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
77088 :
77089 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
77090 :
77091 : /* #line 77092 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
77092 :
77093 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
77094 :
77095 : void
77096 0 : SgOmpParallelLoopStatement::checkDataMemberPointersIfInMemoryPool()
77097 : {
77098 : // ------------ checking pointers of SgOmpParallelLoopStatement -------------------
77099 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
77100 :
77101 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
77102 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
77103 : {
77104 0 : if ( (*i_clauses) != NULL )
77105 : {
77106 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77107 : {
77108 0 : if ( (*i_clauses)->isInMemoryPool() == false )
77109 : {
77110 0 : std::cout << "SgOmpParallelLoopStatement :: ";
77111 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
77112 0 : std::cout << (*i_clauses)->class_name() << std::endl;
77113 : }
77114 : }
77115 : else
77116 : {
77117 0 : std::cout << "SgOmpParallelLoopStatement :: " << std::flush;
77118 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
77119 0 : std::cout << " entry not valid " << std::endl;
77120 : }
77121 : }
77122 : else
77123 : {
77124 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
77125 : }
77126 : }
77127 :
77128 0 : if ( p_body != NULL )
77129 : {
77130 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77131 : {
77132 0 : if ( p_body->isInMemoryPool() == false )
77133 : {
77134 0 : std::cout << "SgOmpParallelLoopStatement :: ";
77135 0 : std::cout << " p_body is not in memory pool of ";
77136 0 : std::cout << p_body->class_name() << std::endl;
77137 : }
77138 : }
77139 : else
77140 : {
77141 0 : std::cout << "SgOmpParallelLoopStatement :: " << std::flush;
77142 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
77143 0 : std::cout << " not valid " << std::endl;
77144 : }
77145 : }
77146 :
77147 0 : if ( p_upir_parent != NULL )
77148 : {
77149 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77150 : {
77151 0 : if ( p_upir_parent->isInMemoryPool() == false )
77152 : {
77153 0 : std::cout << "SgOmpParallelLoopStatement :: ";
77154 0 : std::cout << " p_upir_parent is not in memory pool of ";
77155 0 : std::cout << p_upir_parent->class_name() << std::endl;
77156 : }
77157 : }
77158 : else
77159 : {
77160 0 : std::cout << "SgOmpParallelLoopStatement :: " << std::flush;
77161 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
77162 0 : std::cout << " not valid " << std::endl;
77163 : }
77164 : }
77165 :
77166 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
77167 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
77168 : {
77169 0 : if ( (*i_upir_children) != NULL )
77170 : {
77171 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77172 : {
77173 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
77174 : {
77175 0 : std::cout << "SgOmpParallelLoopStatement :: ";
77176 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
77177 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
77178 : }
77179 : }
77180 : else
77181 : {
77182 0 : std::cout << "SgOmpParallelLoopStatement :: " << std::flush;
77183 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
77184 0 : std::cout << " entry not valid " << std::endl;
77185 : }
77186 : }
77187 : else
77188 : {
77189 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
77190 : }
77191 : }
77192 :
77193 0 : if ( p_numeric_label != NULL )
77194 : {
77195 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77196 : {
77197 0 : if ( p_numeric_label->isInMemoryPool() == false )
77198 : {
77199 0 : std::cout << "SgOmpParallelLoopStatement :: ";
77200 0 : std::cout << " p_numeric_label is not in memory pool of ";
77201 0 : std::cout << p_numeric_label->class_name() << std::endl;
77202 : }
77203 : }
77204 : else
77205 : {
77206 0 : std::cout << "SgOmpParallelLoopStatement :: " << std::flush;
77207 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
77208 0 : std::cout << " not valid " << std::endl;
77209 : }
77210 : }
77211 :
77212 0 : if ( p_startOfConstruct != NULL )
77213 : {
77214 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77215 : {
77216 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
77217 : {
77218 0 : std::cout << "SgOmpParallelLoopStatement :: ";
77219 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
77220 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
77221 : }
77222 : }
77223 : else
77224 : {
77225 0 : std::cout << "SgOmpParallelLoopStatement :: " << std::flush;
77226 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
77227 0 : std::cout << " not valid " << std::endl;
77228 : }
77229 : }
77230 :
77231 0 : if ( p_endOfConstruct != NULL )
77232 : {
77233 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77234 : {
77235 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
77236 : {
77237 0 : std::cout << "SgOmpParallelLoopStatement :: ";
77238 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
77239 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
77240 : }
77241 : }
77242 : else
77243 : {
77244 0 : std::cout << "SgOmpParallelLoopStatement :: " << std::flush;
77245 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
77246 0 : std::cout << " not valid " << std::endl;
77247 : }
77248 : }
77249 :
77250 0 : if ( p_parent != NULL )
77251 : {
77252 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77253 : {
77254 0 : if ( p_parent->isInMemoryPool() == false )
77255 : {
77256 0 : std::cout << "SgOmpParallelLoopStatement :: ";
77257 0 : std::cout << " p_parent is not in memory pool of ";
77258 0 : std::cout << p_parent->class_name() << std::endl;
77259 : }
77260 : }
77261 : else
77262 : {
77263 0 : std::cout << "SgOmpParallelLoopStatement :: " << std::flush;
77264 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
77265 0 : std::cout << " not valid " << std::endl;
77266 : }
77267 : }
77268 :
77269 :
77270 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
77271 :
77272 0 : }
77273 :
77274 :
77275 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
77276 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
77277 : bool
77278 0 : SgOmpParallelLoopStatement::isInMemoryPool ()
77279 : {
77280 0 : typedef unsigned char* TestType;
77281 :
77282 0 : bool found = false;
77283 :
77284 0 : ROSE_ASSERT(this != NULL);
77285 :
77286 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
77287 :
77288 0 : TestType tested = (TestType) ( this ) ;
77289 :
77290 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpParallelLoopStatement::pools.begin();
77291 :
77292 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
77293 : // while (found == false && block < Memory_Block_List.end())
77294 0 : while ( (found == false) && (block != SgOmpParallelLoopStatement::pools.end()) )
77295 : {
77296 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpParallelLoopStatement::pool_size * sizeof(SgOmpParallelLoopStatement) ) ) ;
77297 0 : ++block;
77298 : }
77299 :
77300 : // Special handling for static data
77301 :
77302 :
77303 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
77304 0 : ROSE_ASSERT(found == true);
77305 :
77306 0 : return found;
77307 : }
77308 : /* #line 77309 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
77309 :
77310 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
77311 :
77312 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
77313 :
77314 : /* #line 77315 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
77315 :
77316 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
77317 :
77318 : void
77319 0 : SgOmpTargetParallelStatement::checkDataMemberPointersIfInMemoryPool()
77320 : {
77321 : // ------------ checking pointers of SgOmpTargetParallelStatement -------------------
77322 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
77323 :
77324 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
77325 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
77326 : {
77327 0 : if ( (*i_clauses) != NULL )
77328 : {
77329 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77330 : {
77331 0 : if ( (*i_clauses)->isInMemoryPool() == false )
77332 : {
77333 0 : std::cout << "SgOmpTargetParallelStatement :: ";
77334 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
77335 0 : std::cout << (*i_clauses)->class_name() << std::endl;
77336 : }
77337 : }
77338 : else
77339 : {
77340 0 : std::cout << "SgOmpTargetParallelStatement :: " << std::flush;
77341 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
77342 0 : std::cout << " entry not valid " << std::endl;
77343 : }
77344 : }
77345 : else
77346 : {
77347 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
77348 : }
77349 : }
77350 :
77351 0 : if ( p_body != NULL )
77352 : {
77353 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77354 : {
77355 0 : if ( p_body->isInMemoryPool() == false )
77356 : {
77357 0 : std::cout << "SgOmpTargetParallelStatement :: ";
77358 0 : std::cout << " p_body is not in memory pool of ";
77359 0 : std::cout << p_body->class_name() << std::endl;
77360 : }
77361 : }
77362 : else
77363 : {
77364 0 : std::cout << "SgOmpTargetParallelStatement :: " << std::flush;
77365 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
77366 0 : std::cout << " not valid " << std::endl;
77367 : }
77368 : }
77369 :
77370 0 : if ( p_upir_parent != NULL )
77371 : {
77372 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77373 : {
77374 0 : if ( p_upir_parent->isInMemoryPool() == false )
77375 : {
77376 0 : std::cout << "SgOmpTargetParallelStatement :: ";
77377 0 : std::cout << " p_upir_parent is not in memory pool of ";
77378 0 : std::cout << p_upir_parent->class_name() << std::endl;
77379 : }
77380 : }
77381 : else
77382 : {
77383 0 : std::cout << "SgOmpTargetParallelStatement :: " << std::flush;
77384 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
77385 0 : std::cout << " not valid " << std::endl;
77386 : }
77387 : }
77388 :
77389 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
77390 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
77391 : {
77392 0 : if ( (*i_upir_children) != NULL )
77393 : {
77394 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77395 : {
77396 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
77397 : {
77398 0 : std::cout << "SgOmpTargetParallelStatement :: ";
77399 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
77400 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
77401 : }
77402 : }
77403 : else
77404 : {
77405 0 : std::cout << "SgOmpTargetParallelStatement :: " << std::flush;
77406 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
77407 0 : std::cout << " entry not valid " << std::endl;
77408 : }
77409 : }
77410 : else
77411 : {
77412 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
77413 : }
77414 : }
77415 :
77416 0 : if ( p_numeric_label != NULL )
77417 : {
77418 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77419 : {
77420 0 : if ( p_numeric_label->isInMemoryPool() == false )
77421 : {
77422 0 : std::cout << "SgOmpTargetParallelStatement :: ";
77423 0 : std::cout << " p_numeric_label is not in memory pool of ";
77424 0 : std::cout << p_numeric_label->class_name() << std::endl;
77425 : }
77426 : }
77427 : else
77428 : {
77429 0 : std::cout << "SgOmpTargetParallelStatement :: " << std::flush;
77430 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
77431 0 : std::cout << " not valid " << std::endl;
77432 : }
77433 : }
77434 :
77435 0 : if ( p_startOfConstruct != NULL )
77436 : {
77437 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77438 : {
77439 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
77440 : {
77441 0 : std::cout << "SgOmpTargetParallelStatement :: ";
77442 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
77443 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
77444 : }
77445 : }
77446 : else
77447 : {
77448 0 : std::cout << "SgOmpTargetParallelStatement :: " << std::flush;
77449 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
77450 0 : std::cout << " not valid " << std::endl;
77451 : }
77452 : }
77453 :
77454 0 : if ( p_endOfConstruct != NULL )
77455 : {
77456 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77457 : {
77458 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
77459 : {
77460 0 : std::cout << "SgOmpTargetParallelStatement :: ";
77461 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
77462 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
77463 : }
77464 : }
77465 : else
77466 : {
77467 0 : std::cout << "SgOmpTargetParallelStatement :: " << std::flush;
77468 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
77469 0 : std::cout << " not valid " << std::endl;
77470 : }
77471 : }
77472 :
77473 0 : if ( p_parent != NULL )
77474 : {
77475 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77476 : {
77477 0 : if ( p_parent->isInMemoryPool() == false )
77478 : {
77479 0 : std::cout << "SgOmpTargetParallelStatement :: ";
77480 0 : std::cout << " p_parent is not in memory pool of ";
77481 0 : std::cout << p_parent->class_name() << std::endl;
77482 : }
77483 : }
77484 : else
77485 : {
77486 0 : std::cout << "SgOmpTargetParallelStatement :: " << std::flush;
77487 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
77488 0 : std::cout << " not valid " << std::endl;
77489 : }
77490 : }
77491 :
77492 :
77493 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
77494 :
77495 0 : }
77496 :
77497 :
77498 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
77499 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
77500 : bool
77501 0 : SgOmpTargetParallelStatement::isInMemoryPool ()
77502 : {
77503 0 : typedef unsigned char* TestType;
77504 :
77505 0 : bool found = false;
77506 :
77507 0 : ROSE_ASSERT(this != NULL);
77508 :
77509 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
77510 :
77511 0 : TestType tested = (TestType) ( this ) ;
77512 :
77513 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTargetParallelStatement::pools.begin();
77514 :
77515 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
77516 : // while (found == false && block < Memory_Block_List.end())
77517 0 : while ( (found == false) && (block != SgOmpTargetParallelStatement::pools.end()) )
77518 : {
77519 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTargetParallelStatement::pool_size * sizeof(SgOmpTargetParallelStatement) ) ) ;
77520 0 : ++block;
77521 : }
77522 :
77523 : // Special handling for static data
77524 :
77525 :
77526 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
77527 0 : ROSE_ASSERT(found == true);
77528 :
77529 0 : return found;
77530 : }
77531 : /* #line 77532 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
77532 :
77533 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
77534 :
77535 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
77536 :
77537 : /* #line 77538 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
77538 :
77539 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
77540 :
77541 : void
77542 0 : SgOmpTargetParallelForSimdStatement::checkDataMemberPointersIfInMemoryPool()
77543 : {
77544 : // ------------ checking pointers of SgOmpTargetParallelForSimdStatement -------------------
77545 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
77546 :
77547 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
77548 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
77549 : {
77550 0 : if ( (*i_clauses) != NULL )
77551 : {
77552 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77553 : {
77554 0 : if ( (*i_clauses)->isInMemoryPool() == false )
77555 : {
77556 0 : std::cout << "SgOmpTargetParallelForSimdStatement :: ";
77557 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
77558 0 : std::cout << (*i_clauses)->class_name() << std::endl;
77559 : }
77560 : }
77561 : else
77562 : {
77563 0 : std::cout << "SgOmpTargetParallelForSimdStatement :: " << std::flush;
77564 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
77565 0 : std::cout << " entry not valid " << std::endl;
77566 : }
77567 : }
77568 : else
77569 : {
77570 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
77571 : }
77572 : }
77573 :
77574 0 : if ( p_body != NULL )
77575 : {
77576 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77577 : {
77578 0 : if ( p_body->isInMemoryPool() == false )
77579 : {
77580 0 : std::cout << "SgOmpTargetParallelForSimdStatement :: ";
77581 0 : std::cout << " p_body is not in memory pool of ";
77582 0 : std::cout << p_body->class_name() << std::endl;
77583 : }
77584 : }
77585 : else
77586 : {
77587 0 : std::cout << "SgOmpTargetParallelForSimdStatement :: " << std::flush;
77588 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
77589 0 : std::cout << " not valid " << std::endl;
77590 : }
77591 : }
77592 :
77593 0 : if ( p_upir_parent != NULL )
77594 : {
77595 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77596 : {
77597 0 : if ( p_upir_parent->isInMemoryPool() == false )
77598 : {
77599 0 : std::cout << "SgOmpTargetParallelForSimdStatement :: ";
77600 0 : std::cout << " p_upir_parent is not in memory pool of ";
77601 0 : std::cout << p_upir_parent->class_name() << std::endl;
77602 : }
77603 : }
77604 : else
77605 : {
77606 0 : std::cout << "SgOmpTargetParallelForSimdStatement :: " << std::flush;
77607 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
77608 0 : std::cout << " not valid " << std::endl;
77609 : }
77610 : }
77611 :
77612 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
77613 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
77614 : {
77615 0 : if ( (*i_upir_children) != NULL )
77616 : {
77617 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77618 : {
77619 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
77620 : {
77621 0 : std::cout << "SgOmpTargetParallelForSimdStatement :: ";
77622 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
77623 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
77624 : }
77625 : }
77626 : else
77627 : {
77628 0 : std::cout << "SgOmpTargetParallelForSimdStatement :: " << std::flush;
77629 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
77630 0 : std::cout << " entry not valid " << std::endl;
77631 : }
77632 : }
77633 : else
77634 : {
77635 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
77636 : }
77637 : }
77638 :
77639 0 : if ( p_numeric_label != NULL )
77640 : {
77641 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77642 : {
77643 0 : if ( p_numeric_label->isInMemoryPool() == false )
77644 : {
77645 0 : std::cout << "SgOmpTargetParallelForSimdStatement :: ";
77646 0 : std::cout << " p_numeric_label is not in memory pool of ";
77647 0 : std::cout << p_numeric_label->class_name() << std::endl;
77648 : }
77649 : }
77650 : else
77651 : {
77652 0 : std::cout << "SgOmpTargetParallelForSimdStatement :: " << std::flush;
77653 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
77654 0 : std::cout << " not valid " << std::endl;
77655 : }
77656 : }
77657 :
77658 0 : if ( p_startOfConstruct != NULL )
77659 : {
77660 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77661 : {
77662 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
77663 : {
77664 0 : std::cout << "SgOmpTargetParallelForSimdStatement :: ";
77665 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
77666 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
77667 : }
77668 : }
77669 : else
77670 : {
77671 0 : std::cout << "SgOmpTargetParallelForSimdStatement :: " << std::flush;
77672 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
77673 0 : std::cout << " not valid " << std::endl;
77674 : }
77675 : }
77676 :
77677 0 : if ( p_endOfConstruct != NULL )
77678 : {
77679 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77680 : {
77681 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
77682 : {
77683 0 : std::cout << "SgOmpTargetParallelForSimdStatement :: ";
77684 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
77685 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
77686 : }
77687 : }
77688 : else
77689 : {
77690 0 : std::cout << "SgOmpTargetParallelForSimdStatement :: " << std::flush;
77691 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
77692 0 : std::cout << " not valid " << std::endl;
77693 : }
77694 : }
77695 :
77696 0 : if ( p_parent != NULL )
77697 : {
77698 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77699 : {
77700 0 : if ( p_parent->isInMemoryPool() == false )
77701 : {
77702 0 : std::cout << "SgOmpTargetParallelForSimdStatement :: ";
77703 0 : std::cout << " p_parent is not in memory pool of ";
77704 0 : std::cout << p_parent->class_name() << std::endl;
77705 : }
77706 : }
77707 : else
77708 : {
77709 0 : std::cout << "SgOmpTargetParallelForSimdStatement :: " << std::flush;
77710 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
77711 0 : std::cout << " not valid " << std::endl;
77712 : }
77713 : }
77714 :
77715 :
77716 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
77717 :
77718 0 : }
77719 :
77720 :
77721 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
77722 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
77723 : bool
77724 0 : SgOmpTargetParallelForSimdStatement::isInMemoryPool ()
77725 : {
77726 0 : typedef unsigned char* TestType;
77727 :
77728 0 : bool found = false;
77729 :
77730 0 : ROSE_ASSERT(this != NULL);
77731 :
77732 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
77733 :
77734 0 : TestType tested = (TestType) ( this ) ;
77735 :
77736 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTargetParallelForSimdStatement::pools.begin();
77737 :
77738 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
77739 : // while (found == false && block < Memory_Block_List.end())
77740 0 : while ( (found == false) && (block != SgOmpTargetParallelForSimdStatement::pools.end()) )
77741 : {
77742 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTargetParallelForSimdStatement::pool_size * sizeof(SgOmpTargetParallelForSimdStatement) ) ) ;
77743 0 : ++block;
77744 : }
77745 :
77746 : // Special handling for static data
77747 :
77748 :
77749 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
77750 0 : ROSE_ASSERT(found == true);
77751 :
77752 0 : return found;
77753 : }
77754 : /* #line 77755 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
77755 :
77756 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
77757 :
77758 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
77759 :
77760 : /* #line 77761 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
77761 :
77762 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
77763 :
77764 : void
77765 0 : SgOmpTargetParallelLoopStatement::checkDataMemberPointersIfInMemoryPool()
77766 : {
77767 : // ------------ checking pointers of SgOmpTargetParallelLoopStatement -------------------
77768 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
77769 :
77770 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
77771 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
77772 : {
77773 0 : if ( (*i_clauses) != NULL )
77774 : {
77775 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77776 : {
77777 0 : if ( (*i_clauses)->isInMemoryPool() == false )
77778 : {
77779 0 : std::cout << "SgOmpTargetParallelLoopStatement :: ";
77780 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
77781 0 : std::cout << (*i_clauses)->class_name() << std::endl;
77782 : }
77783 : }
77784 : else
77785 : {
77786 0 : std::cout << "SgOmpTargetParallelLoopStatement :: " << std::flush;
77787 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
77788 0 : std::cout << " entry not valid " << std::endl;
77789 : }
77790 : }
77791 : else
77792 : {
77793 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
77794 : }
77795 : }
77796 :
77797 0 : if ( p_body != NULL )
77798 : {
77799 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77800 : {
77801 0 : if ( p_body->isInMemoryPool() == false )
77802 : {
77803 0 : std::cout << "SgOmpTargetParallelLoopStatement :: ";
77804 0 : std::cout << " p_body is not in memory pool of ";
77805 0 : std::cout << p_body->class_name() << std::endl;
77806 : }
77807 : }
77808 : else
77809 : {
77810 0 : std::cout << "SgOmpTargetParallelLoopStatement :: " << std::flush;
77811 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
77812 0 : std::cout << " not valid " << std::endl;
77813 : }
77814 : }
77815 :
77816 0 : if ( p_upir_parent != NULL )
77817 : {
77818 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77819 : {
77820 0 : if ( p_upir_parent->isInMemoryPool() == false )
77821 : {
77822 0 : std::cout << "SgOmpTargetParallelLoopStatement :: ";
77823 0 : std::cout << " p_upir_parent is not in memory pool of ";
77824 0 : std::cout << p_upir_parent->class_name() << std::endl;
77825 : }
77826 : }
77827 : else
77828 : {
77829 0 : std::cout << "SgOmpTargetParallelLoopStatement :: " << std::flush;
77830 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
77831 0 : std::cout << " not valid " << std::endl;
77832 : }
77833 : }
77834 :
77835 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
77836 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
77837 : {
77838 0 : if ( (*i_upir_children) != NULL )
77839 : {
77840 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77841 : {
77842 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
77843 : {
77844 0 : std::cout << "SgOmpTargetParallelLoopStatement :: ";
77845 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
77846 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
77847 : }
77848 : }
77849 : else
77850 : {
77851 0 : std::cout << "SgOmpTargetParallelLoopStatement :: " << std::flush;
77852 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
77853 0 : std::cout << " entry not valid " << std::endl;
77854 : }
77855 : }
77856 : else
77857 : {
77858 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
77859 : }
77860 : }
77861 :
77862 0 : if ( p_numeric_label != NULL )
77863 : {
77864 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77865 : {
77866 0 : if ( p_numeric_label->isInMemoryPool() == false )
77867 : {
77868 0 : std::cout << "SgOmpTargetParallelLoopStatement :: ";
77869 0 : std::cout << " p_numeric_label is not in memory pool of ";
77870 0 : std::cout << p_numeric_label->class_name() << std::endl;
77871 : }
77872 : }
77873 : else
77874 : {
77875 0 : std::cout << "SgOmpTargetParallelLoopStatement :: " << std::flush;
77876 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
77877 0 : std::cout << " not valid " << std::endl;
77878 : }
77879 : }
77880 :
77881 0 : if ( p_startOfConstruct != NULL )
77882 : {
77883 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77884 : {
77885 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
77886 : {
77887 0 : std::cout << "SgOmpTargetParallelLoopStatement :: ";
77888 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
77889 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
77890 : }
77891 : }
77892 : else
77893 : {
77894 0 : std::cout << "SgOmpTargetParallelLoopStatement :: " << std::flush;
77895 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
77896 0 : std::cout << " not valid " << std::endl;
77897 : }
77898 : }
77899 :
77900 0 : if ( p_endOfConstruct != NULL )
77901 : {
77902 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77903 : {
77904 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
77905 : {
77906 0 : std::cout << "SgOmpTargetParallelLoopStatement :: ";
77907 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
77908 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
77909 : }
77910 : }
77911 : else
77912 : {
77913 0 : std::cout << "SgOmpTargetParallelLoopStatement :: " << std::flush;
77914 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
77915 0 : std::cout << " not valid " << std::endl;
77916 : }
77917 : }
77918 :
77919 0 : if ( p_parent != NULL )
77920 : {
77921 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77922 : {
77923 0 : if ( p_parent->isInMemoryPool() == false )
77924 : {
77925 0 : std::cout << "SgOmpTargetParallelLoopStatement :: ";
77926 0 : std::cout << " p_parent is not in memory pool of ";
77927 0 : std::cout << p_parent->class_name() << std::endl;
77928 : }
77929 : }
77930 : else
77931 : {
77932 0 : std::cout << "SgOmpTargetParallelLoopStatement :: " << std::flush;
77933 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
77934 0 : std::cout << " not valid " << std::endl;
77935 : }
77936 : }
77937 :
77938 :
77939 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
77940 :
77941 0 : }
77942 :
77943 :
77944 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
77945 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
77946 : bool
77947 0 : SgOmpTargetParallelLoopStatement::isInMemoryPool ()
77948 : {
77949 0 : typedef unsigned char* TestType;
77950 :
77951 0 : bool found = false;
77952 :
77953 0 : ROSE_ASSERT(this != NULL);
77954 :
77955 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
77956 :
77957 0 : TestType tested = (TestType) ( this ) ;
77958 :
77959 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTargetParallelLoopStatement::pools.begin();
77960 :
77961 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
77962 : // while (found == false && block < Memory_Block_List.end())
77963 0 : while ( (found == false) && (block != SgOmpTargetParallelLoopStatement::pools.end()) )
77964 : {
77965 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTargetParallelLoopStatement::pool_size * sizeof(SgOmpTargetParallelLoopStatement) ) ) ;
77966 0 : ++block;
77967 : }
77968 :
77969 : // Special handling for static data
77970 :
77971 :
77972 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
77973 0 : ROSE_ASSERT(found == true);
77974 :
77975 0 : return found;
77976 : }
77977 : /* #line 77978 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
77978 :
77979 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
77980 :
77981 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
77982 :
77983 : /* #line 77984 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
77984 :
77985 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
77986 :
77987 : void
77988 0 : SgOmpTargetSimdStatement::checkDataMemberPointersIfInMemoryPool()
77989 : {
77990 : // ------------ checking pointers of SgOmpTargetSimdStatement -------------------
77991 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
77992 :
77993 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
77994 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
77995 : {
77996 0 : if ( (*i_clauses) != NULL )
77997 : {
77998 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
77999 : {
78000 0 : if ( (*i_clauses)->isInMemoryPool() == false )
78001 : {
78002 0 : std::cout << "SgOmpTargetSimdStatement :: ";
78003 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
78004 0 : std::cout << (*i_clauses)->class_name() << std::endl;
78005 : }
78006 : }
78007 : else
78008 : {
78009 0 : std::cout << "SgOmpTargetSimdStatement :: " << std::flush;
78010 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
78011 0 : std::cout << " entry not valid " << std::endl;
78012 : }
78013 : }
78014 : else
78015 : {
78016 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
78017 : }
78018 : }
78019 :
78020 0 : if ( p_body != NULL )
78021 : {
78022 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78023 : {
78024 0 : if ( p_body->isInMemoryPool() == false )
78025 : {
78026 0 : std::cout << "SgOmpTargetSimdStatement :: ";
78027 0 : std::cout << " p_body is not in memory pool of ";
78028 0 : std::cout << p_body->class_name() << std::endl;
78029 : }
78030 : }
78031 : else
78032 : {
78033 0 : std::cout << "SgOmpTargetSimdStatement :: " << std::flush;
78034 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
78035 0 : std::cout << " not valid " << std::endl;
78036 : }
78037 : }
78038 :
78039 0 : if ( p_upir_parent != NULL )
78040 : {
78041 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78042 : {
78043 0 : if ( p_upir_parent->isInMemoryPool() == false )
78044 : {
78045 0 : std::cout << "SgOmpTargetSimdStatement :: ";
78046 0 : std::cout << " p_upir_parent is not in memory pool of ";
78047 0 : std::cout << p_upir_parent->class_name() << std::endl;
78048 : }
78049 : }
78050 : else
78051 : {
78052 0 : std::cout << "SgOmpTargetSimdStatement :: " << std::flush;
78053 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
78054 0 : std::cout << " not valid " << std::endl;
78055 : }
78056 : }
78057 :
78058 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
78059 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
78060 : {
78061 0 : if ( (*i_upir_children) != NULL )
78062 : {
78063 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78064 : {
78065 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
78066 : {
78067 0 : std::cout << "SgOmpTargetSimdStatement :: ";
78068 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
78069 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
78070 : }
78071 : }
78072 : else
78073 : {
78074 0 : std::cout << "SgOmpTargetSimdStatement :: " << std::flush;
78075 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
78076 0 : std::cout << " entry not valid " << std::endl;
78077 : }
78078 : }
78079 : else
78080 : {
78081 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
78082 : }
78083 : }
78084 :
78085 0 : if ( p_numeric_label != NULL )
78086 : {
78087 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78088 : {
78089 0 : if ( p_numeric_label->isInMemoryPool() == false )
78090 : {
78091 0 : std::cout << "SgOmpTargetSimdStatement :: ";
78092 0 : std::cout << " p_numeric_label is not in memory pool of ";
78093 0 : std::cout << p_numeric_label->class_name() << std::endl;
78094 : }
78095 : }
78096 : else
78097 : {
78098 0 : std::cout << "SgOmpTargetSimdStatement :: " << std::flush;
78099 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
78100 0 : std::cout << " not valid " << std::endl;
78101 : }
78102 : }
78103 :
78104 0 : if ( p_startOfConstruct != NULL )
78105 : {
78106 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78107 : {
78108 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
78109 : {
78110 0 : std::cout << "SgOmpTargetSimdStatement :: ";
78111 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
78112 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
78113 : }
78114 : }
78115 : else
78116 : {
78117 0 : std::cout << "SgOmpTargetSimdStatement :: " << std::flush;
78118 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
78119 0 : std::cout << " not valid " << std::endl;
78120 : }
78121 : }
78122 :
78123 0 : if ( p_endOfConstruct != NULL )
78124 : {
78125 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78126 : {
78127 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
78128 : {
78129 0 : std::cout << "SgOmpTargetSimdStatement :: ";
78130 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
78131 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
78132 : }
78133 : }
78134 : else
78135 : {
78136 0 : std::cout << "SgOmpTargetSimdStatement :: " << std::flush;
78137 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
78138 0 : std::cout << " not valid " << std::endl;
78139 : }
78140 : }
78141 :
78142 0 : if ( p_parent != NULL )
78143 : {
78144 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78145 : {
78146 0 : if ( p_parent->isInMemoryPool() == false )
78147 : {
78148 0 : std::cout << "SgOmpTargetSimdStatement :: ";
78149 0 : std::cout << " p_parent is not in memory pool of ";
78150 0 : std::cout << p_parent->class_name() << std::endl;
78151 : }
78152 : }
78153 : else
78154 : {
78155 0 : std::cout << "SgOmpTargetSimdStatement :: " << std::flush;
78156 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
78157 0 : std::cout << " not valid " << std::endl;
78158 : }
78159 : }
78160 :
78161 :
78162 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
78163 :
78164 0 : }
78165 :
78166 :
78167 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
78168 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
78169 : bool
78170 0 : SgOmpTargetSimdStatement::isInMemoryPool ()
78171 : {
78172 0 : typedef unsigned char* TestType;
78173 :
78174 0 : bool found = false;
78175 :
78176 0 : ROSE_ASSERT(this != NULL);
78177 :
78178 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
78179 :
78180 0 : TestType tested = (TestType) ( this ) ;
78181 :
78182 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTargetSimdStatement::pools.begin();
78183 :
78184 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
78185 : // while (found == false && block < Memory_Block_List.end())
78186 0 : while ( (found == false) && (block != SgOmpTargetSimdStatement::pools.end()) )
78187 : {
78188 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTargetSimdStatement::pool_size * sizeof(SgOmpTargetSimdStatement) ) ) ;
78189 0 : ++block;
78190 : }
78191 :
78192 : // Special handling for static data
78193 :
78194 :
78195 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
78196 0 : ROSE_ASSERT(found == true);
78197 :
78198 0 : return found;
78199 : }
78200 : /* #line 78201 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
78201 :
78202 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
78203 :
78204 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
78205 :
78206 : /* #line 78207 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
78207 :
78208 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
78209 :
78210 : void
78211 0 : SgOmpTargetTeamsStatement::checkDataMemberPointersIfInMemoryPool()
78212 : {
78213 : // ------------ checking pointers of SgOmpTargetTeamsStatement -------------------
78214 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
78215 :
78216 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
78217 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
78218 : {
78219 0 : if ( (*i_clauses) != NULL )
78220 : {
78221 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78222 : {
78223 0 : if ( (*i_clauses)->isInMemoryPool() == false )
78224 : {
78225 0 : std::cout << "SgOmpTargetTeamsStatement :: ";
78226 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
78227 0 : std::cout << (*i_clauses)->class_name() << std::endl;
78228 : }
78229 : }
78230 : else
78231 : {
78232 0 : std::cout << "SgOmpTargetTeamsStatement :: " << std::flush;
78233 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
78234 0 : std::cout << " entry not valid " << std::endl;
78235 : }
78236 : }
78237 : else
78238 : {
78239 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
78240 : }
78241 : }
78242 :
78243 0 : if ( p_body != NULL )
78244 : {
78245 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78246 : {
78247 0 : if ( p_body->isInMemoryPool() == false )
78248 : {
78249 0 : std::cout << "SgOmpTargetTeamsStatement :: ";
78250 0 : std::cout << " p_body is not in memory pool of ";
78251 0 : std::cout << p_body->class_name() << std::endl;
78252 : }
78253 : }
78254 : else
78255 : {
78256 0 : std::cout << "SgOmpTargetTeamsStatement :: " << std::flush;
78257 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
78258 0 : std::cout << " not valid " << std::endl;
78259 : }
78260 : }
78261 :
78262 0 : if ( p_upir_parent != NULL )
78263 : {
78264 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78265 : {
78266 0 : if ( p_upir_parent->isInMemoryPool() == false )
78267 : {
78268 0 : std::cout << "SgOmpTargetTeamsStatement :: ";
78269 0 : std::cout << " p_upir_parent is not in memory pool of ";
78270 0 : std::cout << p_upir_parent->class_name() << std::endl;
78271 : }
78272 : }
78273 : else
78274 : {
78275 0 : std::cout << "SgOmpTargetTeamsStatement :: " << std::flush;
78276 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
78277 0 : std::cout << " not valid " << std::endl;
78278 : }
78279 : }
78280 :
78281 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
78282 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
78283 : {
78284 0 : if ( (*i_upir_children) != NULL )
78285 : {
78286 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78287 : {
78288 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
78289 : {
78290 0 : std::cout << "SgOmpTargetTeamsStatement :: ";
78291 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
78292 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
78293 : }
78294 : }
78295 : else
78296 : {
78297 0 : std::cout << "SgOmpTargetTeamsStatement :: " << std::flush;
78298 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
78299 0 : std::cout << " entry not valid " << std::endl;
78300 : }
78301 : }
78302 : else
78303 : {
78304 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
78305 : }
78306 : }
78307 :
78308 0 : if ( p_numeric_label != NULL )
78309 : {
78310 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78311 : {
78312 0 : if ( p_numeric_label->isInMemoryPool() == false )
78313 : {
78314 0 : std::cout << "SgOmpTargetTeamsStatement :: ";
78315 0 : std::cout << " p_numeric_label is not in memory pool of ";
78316 0 : std::cout << p_numeric_label->class_name() << std::endl;
78317 : }
78318 : }
78319 : else
78320 : {
78321 0 : std::cout << "SgOmpTargetTeamsStatement :: " << std::flush;
78322 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
78323 0 : std::cout << " not valid " << std::endl;
78324 : }
78325 : }
78326 :
78327 0 : if ( p_startOfConstruct != NULL )
78328 : {
78329 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78330 : {
78331 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
78332 : {
78333 0 : std::cout << "SgOmpTargetTeamsStatement :: ";
78334 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
78335 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
78336 : }
78337 : }
78338 : else
78339 : {
78340 0 : std::cout << "SgOmpTargetTeamsStatement :: " << std::flush;
78341 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
78342 0 : std::cout << " not valid " << std::endl;
78343 : }
78344 : }
78345 :
78346 0 : if ( p_endOfConstruct != NULL )
78347 : {
78348 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78349 : {
78350 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
78351 : {
78352 0 : std::cout << "SgOmpTargetTeamsStatement :: ";
78353 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
78354 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
78355 : }
78356 : }
78357 : else
78358 : {
78359 0 : std::cout << "SgOmpTargetTeamsStatement :: " << std::flush;
78360 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
78361 0 : std::cout << " not valid " << std::endl;
78362 : }
78363 : }
78364 :
78365 0 : if ( p_parent != NULL )
78366 : {
78367 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78368 : {
78369 0 : if ( p_parent->isInMemoryPool() == false )
78370 : {
78371 0 : std::cout << "SgOmpTargetTeamsStatement :: ";
78372 0 : std::cout << " p_parent is not in memory pool of ";
78373 0 : std::cout << p_parent->class_name() << std::endl;
78374 : }
78375 : }
78376 : else
78377 : {
78378 0 : std::cout << "SgOmpTargetTeamsStatement :: " << std::flush;
78379 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
78380 0 : std::cout << " not valid " << std::endl;
78381 : }
78382 : }
78383 :
78384 :
78385 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
78386 :
78387 0 : }
78388 :
78389 :
78390 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
78391 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
78392 : bool
78393 0 : SgOmpTargetTeamsStatement::isInMemoryPool ()
78394 : {
78395 0 : typedef unsigned char* TestType;
78396 :
78397 0 : bool found = false;
78398 :
78399 0 : ROSE_ASSERT(this != NULL);
78400 :
78401 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
78402 :
78403 0 : TestType tested = (TestType) ( this ) ;
78404 :
78405 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTargetTeamsStatement::pools.begin();
78406 :
78407 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
78408 : // while (found == false && block < Memory_Block_List.end())
78409 0 : while ( (found == false) && (block != SgOmpTargetTeamsStatement::pools.end()) )
78410 : {
78411 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTargetTeamsStatement::pool_size * sizeof(SgOmpTargetTeamsStatement) ) ) ;
78412 0 : ++block;
78413 : }
78414 :
78415 : // Special handling for static data
78416 :
78417 :
78418 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
78419 0 : ROSE_ASSERT(found == true);
78420 :
78421 0 : return found;
78422 : }
78423 : /* #line 78424 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
78424 :
78425 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
78426 :
78427 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
78428 :
78429 : /* #line 78430 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
78430 :
78431 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
78432 :
78433 : void
78434 0 : SgOmpTargetTeamsDistributeStatement::checkDataMemberPointersIfInMemoryPool()
78435 : {
78436 : // ------------ checking pointers of SgOmpTargetTeamsDistributeStatement -------------------
78437 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
78438 :
78439 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
78440 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
78441 : {
78442 0 : if ( (*i_clauses) != NULL )
78443 : {
78444 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78445 : {
78446 0 : if ( (*i_clauses)->isInMemoryPool() == false )
78447 : {
78448 0 : std::cout << "SgOmpTargetTeamsDistributeStatement :: ";
78449 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
78450 0 : std::cout << (*i_clauses)->class_name() << std::endl;
78451 : }
78452 : }
78453 : else
78454 : {
78455 0 : std::cout << "SgOmpTargetTeamsDistributeStatement :: " << std::flush;
78456 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
78457 0 : std::cout << " entry not valid " << std::endl;
78458 : }
78459 : }
78460 : else
78461 : {
78462 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
78463 : }
78464 : }
78465 :
78466 0 : if ( p_body != NULL )
78467 : {
78468 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78469 : {
78470 0 : if ( p_body->isInMemoryPool() == false )
78471 : {
78472 0 : std::cout << "SgOmpTargetTeamsDistributeStatement :: ";
78473 0 : std::cout << " p_body is not in memory pool of ";
78474 0 : std::cout << p_body->class_name() << std::endl;
78475 : }
78476 : }
78477 : else
78478 : {
78479 0 : std::cout << "SgOmpTargetTeamsDistributeStatement :: " << std::flush;
78480 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
78481 0 : std::cout << " not valid " << std::endl;
78482 : }
78483 : }
78484 :
78485 0 : if ( p_upir_parent != NULL )
78486 : {
78487 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78488 : {
78489 0 : if ( p_upir_parent->isInMemoryPool() == false )
78490 : {
78491 0 : std::cout << "SgOmpTargetTeamsDistributeStatement :: ";
78492 0 : std::cout << " p_upir_parent is not in memory pool of ";
78493 0 : std::cout << p_upir_parent->class_name() << std::endl;
78494 : }
78495 : }
78496 : else
78497 : {
78498 0 : std::cout << "SgOmpTargetTeamsDistributeStatement :: " << std::flush;
78499 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
78500 0 : std::cout << " not valid " << std::endl;
78501 : }
78502 : }
78503 :
78504 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
78505 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
78506 : {
78507 0 : if ( (*i_upir_children) != NULL )
78508 : {
78509 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78510 : {
78511 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
78512 : {
78513 0 : std::cout << "SgOmpTargetTeamsDistributeStatement :: ";
78514 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
78515 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
78516 : }
78517 : }
78518 : else
78519 : {
78520 0 : std::cout << "SgOmpTargetTeamsDistributeStatement :: " << std::flush;
78521 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
78522 0 : std::cout << " entry not valid " << std::endl;
78523 : }
78524 : }
78525 : else
78526 : {
78527 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
78528 : }
78529 : }
78530 :
78531 0 : if ( p_numeric_label != NULL )
78532 : {
78533 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78534 : {
78535 0 : if ( p_numeric_label->isInMemoryPool() == false )
78536 : {
78537 0 : std::cout << "SgOmpTargetTeamsDistributeStatement :: ";
78538 0 : std::cout << " p_numeric_label is not in memory pool of ";
78539 0 : std::cout << p_numeric_label->class_name() << std::endl;
78540 : }
78541 : }
78542 : else
78543 : {
78544 0 : std::cout << "SgOmpTargetTeamsDistributeStatement :: " << std::flush;
78545 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
78546 0 : std::cout << " not valid " << std::endl;
78547 : }
78548 : }
78549 :
78550 0 : if ( p_startOfConstruct != NULL )
78551 : {
78552 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78553 : {
78554 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
78555 : {
78556 0 : std::cout << "SgOmpTargetTeamsDistributeStatement :: ";
78557 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
78558 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
78559 : }
78560 : }
78561 : else
78562 : {
78563 0 : std::cout << "SgOmpTargetTeamsDistributeStatement :: " << std::flush;
78564 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
78565 0 : std::cout << " not valid " << std::endl;
78566 : }
78567 : }
78568 :
78569 0 : if ( p_endOfConstruct != NULL )
78570 : {
78571 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78572 : {
78573 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
78574 : {
78575 0 : std::cout << "SgOmpTargetTeamsDistributeStatement :: ";
78576 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
78577 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
78578 : }
78579 : }
78580 : else
78581 : {
78582 0 : std::cout << "SgOmpTargetTeamsDistributeStatement :: " << std::flush;
78583 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
78584 0 : std::cout << " not valid " << std::endl;
78585 : }
78586 : }
78587 :
78588 0 : if ( p_parent != NULL )
78589 : {
78590 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78591 : {
78592 0 : if ( p_parent->isInMemoryPool() == false )
78593 : {
78594 0 : std::cout << "SgOmpTargetTeamsDistributeStatement :: ";
78595 0 : std::cout << " p_parent is not in memory pool of ";
78596 0 : std::cout << p_parent->class_name() << std::endl;
78597 : }
78598 : }
78599 : else
78600 : {
78601 0 : std::cout << "SgOmpTargetTeamsDistributeStatement :: " << std::flush;
78602 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
78603 0 : std::cout << " not valid " << std::endl;
78604 : }
78605 : }
78606 :
78607 :
78608 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
78609 :
78610 0 : }
78611 :
78612 :
78613 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
78614 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
78615 : bool
78616 0 : SgOmpTargetTeamsDistributeStatement::isInMemoryPool ()
78617 : {
78618 0 : typedef unsigned char* TestType;
78619 :
78620 0 : bool found = false;
78621 :
78622 0 : ROSE_ASSERT(this != NULL);
78623 :
78624 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
78625 :
78626 0 : TestType tested = (TestType) ( this ) ;
78627 :
78628 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTargetTeamsDistributeStatement::pools.begin();
78629 :
78630 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
78631 : // while (found == false && block < Memory_Block_List.end())
78632 0 : while ( (found == false) && (block != SgOmpTargetTeamsDistributeStatement::pools.end()) )
78633 : {
78634 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTargetTeamsDistributeStatement::pool_size * sizeof(SgOmpTargetTeamsDistributeStatement) ) ) ;
78635 0 : ++block;
78636 : }
78637 :
78638 : // Special handling for static data
78639 :
78640 :
78641 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
78642 0 : ROSE_ASSERT(found == true);
78643 :
78644 0 : return found;
78645 : }
78646 : /* #line 78647 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
78647 :
78648 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
78649 :
78650 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
78651 :
78652 : /* #line 78653 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
78653 :
78654 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
78655 :
78656 : void
78657 0 : SgOmpTargetTeamsDistributeSimdStatement::checkDataMemberPointersIfInMemoryPool()
78658 : {
78659 : // ------------ checking pointers of SgOmpTargetTeamsDistributeSimdStatement -------------------
78660 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
78661 :
78662 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
78663 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
78664 : {
78665 0 : if ( (*i_clauses) != NULL )
78666 : {
78667 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78668 : {
78669 0 : if ( (*i_clauses)->isInMemoryPool() == false )
78670 : {
78671 0 : std::cout << "SgOmpTargetTeamsDistributeSimdStatement :: ";
78672 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
78673 0 : std::cout << (*i_clauses)->class_name() << std::endl;
78674 : }
78675 : }
78676 : else
78677 : {
78678 0 : std::cout << "SgOmpTargetTeamsDistributeSimdStatement :: " << std::flush;
78679 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
78680 0 : std::cout << " entry not valid " << std::endl;
78681 : }
78682 : }
78683 : else
78684 : {
78685 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
78686 : }
78687 : }
78688 :
78689 0 : if ( p_body != NULL )
78690 : {
78691 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78692 : {
78693 0 : if ( p_body->isInMemoryPool() == false )
78694 : {
78695 0 : std::cout << "SgOmpTargetTeamsDistributeSimdStatement :: ";
78696 0 : std::cout << " p_body is not in memory pool of ";
78697 0 : std::cout << p_body->class_name() << std::endl;
78698 : }
78699 : }
78700 : else
78701 : {
78702 0 : std::cout << "SgOmpTargetTeamsDistributeSimdStatement :: " << std::flush;
78703 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
78704 0 : std::cout << " not valid " << std::endl;
78705 : }
78706 : }
78707 :
78708 0 : if ( p_upir_parent != NULL )
78709 : {
78710 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78711 : {
78712 0 : if ( p_upir_parent->isInMemoryPool() == false )
78713 : {
78714 0 : std::cout << "SgOmpTargetTeamsDistributeSimdStatement :: ";
78715 0 : std::cout << " p_upir_parent is not in memory pool of ";
78716 0 : std::cout << p_upir_parent->class_name() << std::endl;
78717 : }
78718 : }
78719 : else
78720 : {
78721 0 : std::cout << "SgOmpTargetTeamsDistributeSimdStatement :: " << std::flush;
78722 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
78723 0 : std::cout << " not valid " << std::endl;
78724 : }
78725 : }
78726 :
78727 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
78728 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
78729 : {
78730 0 : if ( (*i_upir_children) != NULL )
78731 : {
78732 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78733 : {
78734 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
78735 : {
78736 0 : std::cout << "SgOmpTargetTeamsDistributeSimdStatement :: ";
78737 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
78738 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
78739 : }
78740 : }
78741 : else
78742 : {
78743 0 : std::cout << "SgOmpTargetTeamsDistributeSimdStatement :: " << std::flush;
78744 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
78745 0 : std::cout << " entry not valid " << std::endl;
78746 : }
78747 : }
78748 : else
78749 : {
78750 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
78751 : }
78752 : }
78753 :
78754 0 : if ( p_numeric_label != NULL )
78755 : {
78756 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78757 : {
78758 0 : if ( p_numeric_label->isInMemoryPool() == false )
78759 : {
78760 0 : std::cout << "SgOmpTargetTeamsDistributeSimdStatement :: ";
78761 0 : std::cout << " p_numeric_label is not in memory pool of ";
78762 0 : std::cout << p_numeric_label->class_name() << std::endl;
78763 : }
78764 : }
78765 : else
78766 : {
78767 0 : std::cout << "SgOmpTargetTeamsDistributeSimdStatement :: " << std::flush;
78768 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
78769 0 : std::cout << " not valid " << std::endl;
78770 : }
78771 : }
78772 :
78773 0 : if ( p_startOfConstruct != NULL )
78774 : {
78775 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78776 : {
78777 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
78778 : {
78779 0 : std::cout << "SgOmpTargetTeamsDistributeSimdStatement :: ";
78780 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
78781 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
78782 : }
78783 : }
78784 : else
78785 : {
78786 0 : std::cout << "SgOmpTargetTeamsDistributeSimdStatement :: " << std::flush;
78787 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
78788 0 : std::cout << " not valid " << std::endl;
78789 : }
78790 : }
78791 :
78792 0 : if ( p_endOfConstruct != NULL )
78793 : {
78794 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78795 : {
78796 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
78797 : {
78798 0 : std::cout << "SgOmpTargetTeamsDistributeSimdStatement :: ";
78799 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
78800 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
78801 : }
78802 : }
78803 : else
78804 : {
78805 0 : std::cout << "SgOmpTargetTeamsDistributeSimdStatement :: " << std::flush;
78806 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
78807 0 : std::cout << " not valid " << std::endl;
78808 : }
78809 : }
78810 :
78811 0 : if ( p_parent != NULL )
78812 : {
78813 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78814 : {
78815 0 : if ( p_parent->isInMemoryPool() == false )
78816 : {
78817 0 : std::cout << "SgOmpTargetTeamsDistributeSimdStatement :: ";
78818 0 : std::cout << " p_parent is not in memory pool of ";
78819 0 : std::cout << p_parent->class_name() << std::endl;
78820 : }
78821 : }
78822 : else
78823 : {
78824 0 : std::cout << "SgOmpTargetTeamsDistributeSimdStatement :: " << std::flush;
78825 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
78826 0 : std::cout << " not valid " << std::endl;
78827 : }
78828 : }
78829 :
78830 :
78831 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
78832 :
78833 0 : }
78834 :
78835 :
78836 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
78837 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
78838 : bool
78839 0 : SgOmpTargetTeamsDistributeSimdStatement::isInMemoryPool ()
78840 : {
78841 0 : typedef unsigned char* TestType;
78842 :
78843 0 : bool found = false;
78844 :
78845 0 : ROSE_ASSERT(this != NULL);
78846 :
78847 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
78848 :
78849 0 : TestType tested = (TestType) ( this ) ;
78850 :
78851 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTargetTeamsDistributeSimdStatement::pools.begin();
78852 :
78853 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
78854 : // while (found == false && block < Memory_Block_List.end())
78855 0 : while ( (found == false) && (block != SgOmpTargetTeamsDistributeSimdStatement::pools.end()) )
78856 : {
78857 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTargetTeamsDistributeSimdStatement::pool_size * sizeof(SgOmpTargetTeamsDistributeSimdStatement) ) ) ;
78858 0 : ++block;
78859 : }
78860 :
78861 : // Special handling for static data
78862 :
78863 :
78864 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
78865 0 : ROSE_ASSERT(found == true);
78866 :
78867 0 : return found;
78868 : }
78869 : /* #line 78870 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
78870 :
78871 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
78872 :
78873 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
78874 :
78875 : /* #line 78876 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
78876 :
78877 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
78878 :
78879 : void
78880 0 : SgOmpTargetTeamsLoopStatement::checkDataMemberPointersIfInMemoryPool()
78881 : {
78882 : // ------------ checking pointers of SgOmpTargetTeamsLoopStatement -------------------
78883 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
78884 :
78885 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
78886 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
78887 : {
78888 0 : if ( (*i_clauses) != NULL )
78889 : {
78890 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78891 : {
78892 0 : if ( (*i_clauses)->isInMemoryPool() == false )
78893 : {
78894 0 : std::cout << "SgOmpTargetTeamsLoopStatement :: ";
78895 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
78896 0 : std::cout << (*i_clauses)->class_name() << std::endl;
78897 : }
78898 : }
78899 : else
78900 : {
78901 0 : std::cout << "SgOmpTargetTeamsLoopStatement :: " << std::flush;
78902 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
78903 0 : std::cout << " entry not valid " << std::endl;
78904 : }
78905 : }
78906 : else
78907 : {
78908 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
78909 : }
78910 : }
78911 :
78912 0 : if ( p_body != NULL )
78913 : {
78914 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78915 : {
78916 0 : if ( p_body->isInMemoryPool() == false )
78917 : {
78918 0 : std::cout << "SgOmpTargetTeamsLoopStatement :: ";
78919 0 : std::cout << " p_body is not in memory pool of ";
78920 0 : std::cout << p_body->class_name() << std::endl;
78921 : }
78922 : }
78923 : else
78924 : {
78925 0 : std::cout << "SgOmpTargetTeamsLoopStatement :: " << std::flush;
78926 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
78927 0 : std::cout << " not valid " << std::endl;
78928 : }
78929 : }
78930 :
78931 0 : if ( p_upir_parent != NULL )
78932 : {
78933 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78934 : {
78935 0 : if ( p_upir_parent->isInMemoryPool() == false )
78936 : {
78937 0 : std::cout << "SgOmpTargetTeamsLoopStatement :: ";
78938 0 : std::cout << " p_upir_parent is not in memory pool of ";
78939 0 : std::cout << p_upir_parent->class_name() << std::endl;
78940 : }
78941 : }
78942 : else
78943 : {
78944 0 : std::cout << "SgOmpTargetTeamsLoopStatement :: " << std::flush;
78945 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
78946 0 : std::cout << " not valid " << std::endl;
78947 : }
78948 : }
78949 :
78950 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
78951 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
78952 : {
78953 0 : if ( (*i_upir_children) != NULL )
78954 : {
78955 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78956 : {
78957 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
78958 : {
78959 0 : std::cout << "SgOmpTargetTeamsLoopStatement :: ";
78960 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
78961 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
78962 : }
78963 : }
78964 : else
78965 : {
78966 0 : std::cout << "SgOmpTargetTeamsLoopStatement :: " << std::flush;
78967 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
78968 0 : std::cout << " entry not valid " << std::endl;
78969 : }
78970 : }
78971 : else
78972 : {
78973 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
78974 : }
78975 : }
78976 :
78977 0 : if ( p_numeric_label != NULL )
78978 : {
78979 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78980 : {
78981 0 : if ( p_numeric_label->isInMemoryPool() == false )
78982 : {
78983 0 : std::cout << "SgOmpTargetTeamsLoopStatement :: ";
78984 0 : std::cout << " p_numeric_label is not in memory pool of ";
78985 0 : std::cout << p_numeric_label->class_name() << std::endl;
78986 : }
78987 : }
78988 : else
78989 : {
78990 0 : std::cout << "SgOmpTargetTeamsLoopStatement :: " << std::flush;
78991 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
78992 0 : std::cout << " not valid " << std::endl;
78993 : }
78994 : }
78995 :
78996 0 : if ( p_startOfConstruct != NULL )
78997 : {
78998 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
78999 : {
79000 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
79001 : {
79002 0 : std::cout << "SgOmpTargetTeamsLoopStatement :: ";
79003 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
79004 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
79005 : }
79006 : }
79007 : else
79008 : {
79009 0 : std::cout << "SgOmpTargetTeamsLoopStatement :: " << std::flush;
79010 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
79011 0 : std::cout << " not valid " << std::endl;
79012 : }
79013 : }
79014 :
79015 0 : if ( p_endOfConstruct != NULL )
79016 : {
79017 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79018 : {
79019 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
79020 : {
79021 0 : std::cout << "SgOmpTargetTeamsLoopStatement :: ";
79022 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
79023 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
79024 : }
79025 : }
79026 : else
79027 : {
79028 0 : std::cout << "SgOmpTargetTeamsLoopStatement :: " << std::flush;
79029 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
79030 0 : std::cout << " not valid " << std::endl;
79031 : }
79032 : }
79033 :
79034 0 : if ( p_parent != NULL )
79035 : {
79036 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79037 : {
79038 0 : if ( p_parent->isInMemoryPool() == false )
79039 : {
79040 0 : std::cout << "SgOmpTargetTeamsLoopStatement :: ";
79041 0 : std::cout << " p_parent is not in memory pool of ";
79042 0 : std::cout << p_parent->class_name() << std::endl;
79043 : }
79044 : }
79045 : else
79046 : {
79047 0 : std::cout << "SgOmpTargetTeamsLoopStatement :: " << std::flush;
79048 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
79049 0 : std::cout << " not valid " << std::endl;
79050 : }
79051 : }
79052 :
79053 :
79054 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
79055 :
79056 0 : }
79057 :
79058 :
79059 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
79060 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
79061 : bool
79062 0 : SgOmpTargetTeamsLoopStatement::isInMemoryPool ()
79063 : {
79064 0 : typedef unsigned char* TestType;
79065 :
79066 0 : bool found = false;
79067 :
79068 0 : ROSE_ASSERT(this != NULL);
79069 :
79070 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
79071 :
79072 0 : TestType tested = (TestType) ( this ) ;
79073 :
79074 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTargetTeamsLoopStatement::pools.begin();
79075 :
79076 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
79077 : // while (found == false && block < Memory_Block_List.end())
79078 0 : while ( (found == false) && (block != SgOmpTargetTeamsLoopStatement::pools.end()) )
79079 : {
79080 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTargetTeamsLoopStatement::pool_size * sizeof(SgOmpTargetTeamsLoopStatement) ) ) ;
79081 0 : ++block;
79082 : }
79083 :
79084 : // Special handling for static data
79085 :
79086 :
79087 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
79088 0 : ROSE_ASSERT(found == true);
79089 :
79090 0 : return found;
79091 : }
79092 : /* #line 79093 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
79093 :
79094 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
79095 :
79096 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
79097 :
79098 : /* #line 79099 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
79099 :
79100 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
79101 :
79102 : void
79103 0 : SgOmpTargetTeamsDistributeParallelForStatement::checkDataMemberPointersIfInMemoryPool()
79104 : {
79105 : // ------------ checking pointers of SgOmpTargetTeamsDistributeParallelForStatement -------------------
79106 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
79107 :
79108 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
79109 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
79110 : {
79111 0 : if ( (*i_clauses) != NULL )
79112 : {
79113 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79114 : {
79115 0 : if ( (*i_clauses)->isInMemoryPool() == false )
79116 : {
79117 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForStatement :: ";
79118 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
79119 0 : std::cout << (*i_clauses)->class_name() << std::endl;
79120 : }
79121 : }
79122 : else
79123 : {
79124 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForStatement :: " << std::flush;
79125 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
79126 0 : std::cout << " entry not valid " << std::endl;
79127 : }
79128 : }
79129 : else
79130 : {
79131 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
79132 : }
79133 : }
79134 :
79135 0 : if ( p_body != NULL )
79136 : {
79137 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79138 : {
79139 0 : if ( p_body->isInMemoryPool() == false )
79140 : {
79141 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForStatement :: ";
79142 0 : std::cout << " p_body is not in memory pool of ";
79143 0 : std::cout << p_body->class_name() << std::endl;
79144 : }
79145 : }
79146 : else
79147 : {
79148 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForStatement :: " << std::flush;
79149 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
79150 0 : std::cout << " not valid " << std::endl;
79151 : }
79152 : }
79153 :
79154 0 : if ( p_upir_parent != NULL )
79155 : {
79156 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79157 : {
79158 0 : if ( p_upir_parent->isInMemoryPool() == false )
79159 : {
79160 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForStatement :: ";
79161 0 : std::cout << " p_upir_parent is not in memory pool of ";
79162 0 : std::cout << p_upir_parent->class_name() << std::endl;
79163 : }
79164 : }
79165 : else
79166 : {
79167 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForStatement :: " << std::flush;
79168 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
79169 0 : std::cout << " not valid " << std::endl;
79170 : }
79171 : }
79172 :
79173 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
79174 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
79175 : {
79176 0 : if ( (*i_upir_children) != NULL )
79177 : {
79178 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79179 : {
79180 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
79181 : {
79182 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForStatement :: ";
79183 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
79184 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
79185 : }
79186 : }
79187 : else
79188 : {
79189 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForStatement :: " << std::flush;
79190 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
79191 0 : std::cout << " entry not valid " << std::endl;
79192 : }
79193 : }
79194 : else
79195 : {
79196 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
79197 : }
79198 : }
79199 :
79200 0 : if ( p_numeric_label != NULL )
79201 : {
79202 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79203 : {
79204 0 : if ( p_numeric_label->isInMemoryPool() == false )
79205 : {
79206 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForStatement :: ";
79207 0 : std::cout << " p_numeric_label is not in memory pool of ";
79208 0 : std::cout << p_numeric_label->class_name() << std::endl;
79209 : }
79210 : }
79211 : else
79212 : {
79213 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForStatement :: " << std::flush;
79214 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
79215 0 : std::cout << " not valid " << std::endl;
79216 : }
79217 : }
79218 :
79219 0 : if ( p_startOfConstruct != NULL )
79220 : {
79221 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79222 : {
79223 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
79224 : {
79225 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForStatement :: ";
79226 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
79227 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
79228 : }
79229 : }
79230 : else
79231 : {
79232 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForStatement :: " << std::flush;
79233 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
79234 0 : std::cout << " not valid " << std::endl;
79235 : }
79236 : }
79237 :
79238 0 : if ( p_endOfConstruct != NULL )
79239 : {
79240 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79241 : {
79242 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
79243 : {
79244 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForStatement :: ";
79245 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
79246 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
79247 : }
79248 : }
79249 : else
79250 : {
79251 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForStatement :: " << std::flush;
79252 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
79253 0 : std::cout << " not valid " << std::endl;
79254 : }
79255 : }
79256 :
79257 0 : if ( p_parent != NULL )
79258 : {
79259 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79260 : {
79261 0 : if ( p_parent->isInMemoryPool() == false )
79262 : {
79263 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForStatement :: ";
79264 0 : std::cout << " p_parent is not in memory pool of ";
79265 0 : std::cout << p_parent->class_name() << std::endl;
79266 : }
79267 : }
79268 : else
79269 : {
79270 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForStatement :: " << std::flush;
79271 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
79272 0 : std::cout << " not valid " << std::endl;
79273 : }
79274 : }
79275 :
79276 :
79277 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
79278 :
79279 0 : }
79280 :
79281 :
79282 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
79283 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
79284 : bool
79285 0 : SgOmpTargetTeamsDistributeParallelForStatement::isInMemoryPool ()
79286 : {
79287 0 : typedef unsigned char* TestType;
79288 :
79289 0 : bool found = false;
79290 :
79291 0 : ROSE_ASSERT(this != NULL);
79292 :
79293 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
79294 :
79295 0 : TestType tested = (TestType) ( this ) ;
79296 :
79297 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTargetTeamsDistributeParallelForStatement::pools.begin();
79298 :
79299 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
79300 : // while (found == false && block < Memory_Block_List.end())
79301 0 : while ( (found == false) && (block != SgOmpTargetTeamsDistributeParallelForStatement::pools.end()) )
79302 : {
79303 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTargetTeamsDistributeParallelForStatement::pool_size * sizeof(SgOmpTargetTeamsDistributeParallelForStatement) ) ) ;
79304 0 : ++block;
79305 : }
79306 :
79307 : // Special handling for static data
79308 :
79309 :
79310 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
79311 0 : ROSE_ASSERT(found == true);
79312 :
79313 0 : return found;
79314 : }
79315 : /* #line 79316 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
79316 :
79317 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
79318 :
79319 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
79320 :
79321 : /* #line 79322 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
79322 :
79323 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
79324 :
79325 : void
79326 0 : SgOmpTargetTeamsDistributeParallelForSimdStatement::checkDataMemberPointersIfInMemoryPool()
79327 : {
79328 : // ------------ checking pointers of SgOmpTargetTeamsDistributeParallelForSimdStatement -------------------
79329 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
79330 :
79331 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
79332 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
79333 : {
79334 0 : if ( (*i_clauses) != NULL )
79335 : {
79336 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79337 : {
79338 0 : if ( (*i_clauses)->isInMemoryPool() == false )
79339 : {
79340 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForSimdStatement :: ";
79341 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
79342 0 : std::cout << (*i_clauses)->class_name() << std::endl;
79343 : }
79344 : }
79345 : else
79346 : {
79347 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForSimdStatement :: " << std::flush;
79348 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
79349 0 : std::cout << " entry not valid " << std::endl;
79350 : }
79351 : }
79352 : else
79353 : {
79354 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
79355 : }
79356 : }
79357 :
79358 0 : if ( p_body != NULL )
79359 : {
79360 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79361 : {
79362 0 : if ( p_body->isInMemoryPool() == false )
79363 : {
79364 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForSimdStatement :: ";
79365 0 : std::cout << " p_body is not in memory pool of ";
79366 0 : std::cout << p_body->class_name() << std::endl;
79367 : }
79368 : }
79369 : else
79370 : {
79371 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForSimdStatement :: " << std::flush;
79372 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
79373 0 : std::cout << " not valid " << std::endl;
79374 : }
79375 : }
79376 :
79377 0 : if ( p_upir_parent != NULL )
79378 : {
79379 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79380 : {
79381 0 : if ( p_upir_parent->isInMemoryPool() == false )
79382 : {
79383 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForSimdStatement :: ";
79384 0 : std::cout << " p_upir_parent is not in memory pool of ";
79385 0 : std::cout << p_upir_parent->class_name() << std::endl;
79386 : }
79387 : }
79388 : else
79389 : {
79390 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForSimdStatement :: " << std::flush;
79391 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
79392 0 : std::cout << " not valid " << std::endl;
79393 : }
79394 : }
79395 :
79396 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
79397 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
79398 : {
79399 0 : if ( (*i_upir_children) != NULL )
79400 : {
79401 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79402 : {
79403 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
79404 : {
79405 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForSimdStatement :: ";
79406 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
79407 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
79408 : }
79409 : }
79410 : else
79411 : {
79412 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForSimdStatement :: " << std::flush;
79413 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
79414 0 : std::cout << " entry not valid " << std::endl;
79415 : }
79416 : }
79417 : else
79418 : {
79419 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
79420 : }
79421 : }
79422 :
79423 0 : if ( p_numeric_label != NULL )
79424 : {
79425 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79426 : {
79427 0 : if ( p_numeric_label->isInMemoryPool() == false )
79428 : {
79429 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForSimdStatement :: ";
79430 0 : std::cout << " p_numeric_label is not in memory pool of ";
79431 0 : std::cout << p_numeric_label->class_name() << std::endl;
79432 : }
79433 : }
79434 : else
79435 : {
79436 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForSimdStatement :: " << std::flush;
79437 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
79438 0 : std::cout << " not valid " << std::endl;
79439 : }
79440 : }
79441 :
79442 0 : if ( p_startOfConstruct != NULL )
79443 : {
79444 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79445 : {
79446 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
79447 : {
79448 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForSimdStatement :: ";
79449 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
79450 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
79451 : }
79452 : }
79453 : else
79454 : {
79455 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForSimdStatement :: " << std::flush;
79456 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
79457 0 : std::cout << " not valid " << std::endl;
79458 : }
79459 : }
79460 :
79461 0 : if ( p_endOfConstruct != NULL )
79462 : {
79463 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79464 : {
79465 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
79466 : {
79467 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForSimdStatement :: ";
79468 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
79469 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
79470 : }
79471 : }
79472 : else
79473 : {
79474 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForSimdStatement :: " << std::flush;
79475 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
79476 0 : std::cout << " not valid " << std::endl;
79477 : }
79478 : }
79479 :
79480 0 : if ( p_parent != NULL )
79481 : {
79482 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79483 : {
79484 0 : if ( p_parent->isInMemoryPool() == false )
79485 : {
79486 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForSimdStatement :: ";
79487 0 : std::cout << " p_parent is not in memory pool of ";
79488 0 : std::cout << p_parent->class_name() << std::endl;
79489 : }
79490 : }
79491 : else
79492 : {
79493 0 : std::cout << "SgOmpTargetTeamsDistributeParallelForSimdStatement :: " << std::flush;
79494 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
79495 0 : std::cout << " not valid " << std::endl;
79496 : }
79497 : }
79498 :
79499 :
79500 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
79501 :
79502 0 : }
79503 :
79504 :
79505 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
79506 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
79507 : bool
79508 0 : SgOmpTargetTeamsDistributeParallelForSimdStatement::isInMemoryPool ()
79509 : {
79510 0 : typedef unsigned char* TestType;
79511 :
79512 0 : bool found = false;
79513 :
79514 0 : ROSE_ASSERT(this != NULL);
79515 :
79516 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
79517 :
79518 0 : TestType tested = (TestType) ( this ) ;
79519 :
79520 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTargetTeamsDistributeParallelForSimdStatement::pools.begin();
79521 :
79522 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
79523 : // while (found == false && block < Memory_Block_List.end())
79524 0 : while ( (found == false) && (block != SgOmpTargetTeamsDistributeParallelForSimdStatement::pools.end()) )
79525 : {
79526 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTargetTeamsDistributeParallelForSimdStatement::pool_size * sizeof(SgOmpTargetTeamsDistributeParallelForSimdStatement) ) ) ;
79527 0 : ++block;
79528 : }
79529 :
79530 : // Special handling for static data
79531 :
79532 :
79533 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
79534 0 : ROSE_ASSERT(found == true);
79535 :
79536 0 : return found;
79537 : }
79538 : /* #line 79539 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
79539 :
79540 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
79541 :
79542 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
79543 :
79544 : /* #line 79545 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
79545 :
79546 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
79547 :
79548 : void
79549 0 : SgOmpDistributeSimdStatement::checkDataMemberPointersIfInMemoryPool()
79550 : {
79551 : // ------------ checking pointers of SgOmpDistributeSimdStatement -------------------
79552 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
79553 :
79554 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
79555 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
79556 : {
79557 0 : if ( (*i_clauses) != NULL )
79558 : {
79559 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79560 : {
79561 0 : if ( (*i_clauses)->isInMemoryPool() == false )
79562 : {
79563 0 : std::cout << "SgOmpDistributeSimdStatement :: ";
79564 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
79565 0 : std::cout << (*i_clauses)->class_name() << std::endl;
79566 : }
79567 : }
79568 : else
79569 : {
79570 0 : std::cout << "SgOmpDistributeSimdStatement :: " << std::flush;
79571 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
79572 0 : std::cout << " entry not valid " << std::endl;
79573 : }
79574 : }
79575 : else
79576 : {
79577 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
79578 : }
79579 : }
79580 :
79581 0 : if ( p_body != NULL )
79582 : {
79583 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79584 : {
79585 0 : if ( p_body->isInMemoryPool() == false )
79586 : {
79587 0 : std::cout << "SgOmpDistributeSimdStatement :: ";
79588 0 : std::cout << " p_body is not in memory pool of ";
79589 0 : std::cout << p_body->class_name() << std::endl;
79590 : }
79591 : }
79592 : else
79593 : {
79594 0 : std::cout << "SgOmpDistributeSimdStatement :: " << std::flush;
79595 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
79596 0 : std::cout << " not valid " << std::endl;
79597 : }
79598 : }
79599 :
79600 0 : if ( p_upir_parent != NULL )
79601 : {
79602 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79603 : {
79604 0 : if ( p_upir_parent->isInMemoryPool() == false )
79605 : {
79606 0 : std::cout << "SgOmpDistributeSimdStatement :: ";
79607 0 : std::cout << " p_upir_parent is not in memory pool of ";
79608 0 : std::cout << p_upir_parent->class_name() << std::endl;
79609 : }
79610 : }
79611 : else
79612 : {
79613 0 : std::cout << "SgOmpDistributeSimdStatement :: " << std::flush;
79614 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
79615 0 : std::cout << " not valid " << std::endl;
79616 : }
79617 : }
79618 :
79619 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
79620 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
79621 : {
79622 0 : if ( (*i_upir_children) != NULL )
79623 : {
79624 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79625 : {
79626 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
79627 : {
79628 0 : std::cout << "SgOmpDistributeSimdStatement :: ";
79629 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
79630 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
79631 : }
79632 : }
79633 : else
79634 : {
79635 0 : std::cout << "SgOmpDistributeSimdStatement :: " << std::flush;
79636 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
79637 0 : std::cout << " entry not valid " << std::endl;
79638 : }
79639 : }
79640 : else
79641 : {
79642 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
79643 : }
79644 : }
79645 :
79646 0 : if ( p_numeric_label != NULL )
79647 : {
79648 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79649 : {
79650 0 : if ( p_numeric_label->isInMemoryPool() == false )
79651 : {
79652 0 : std::cout << "SgOmpDistributeSimdStatement :: ";
79653 0 : std::cout << " p_numeric_label is not in memory pool of ";
79654 0 : std::cout << p_numeric_label->class_name() << std::endl;
79655 : }
79656 : }
79657 : else
79658 : {
79659 0 : std::cout << "SgOmpDistributeSimdStatement :: " << std::flush;
79660 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
79661 0 : std::cout << " not valid " << std::endl;
79662 : }
79663 : }
79664 :
79665 0 : if ( p_startOfConstruct != NULL )
79666 : {
79667 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79668 : {
79669 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
79670 : {
79671 0 : std::cout << "SgOmpDistributeSimdStatement :: ";
79672 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
79673 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
79674 : }
79675 : }
79676 : else
79677 : {
79678 0 : std::cout << "SgOmpDistributeSimdStatement :: " << std::flush;
79679 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
79680 0 : std::cout << " not valid " << std::endl;
79681 : }
79682 : }
79683 :
79684 0 : if ( p_endOfConstruct != NULL )
79685 : {
79686 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79687 : {
79688 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
79689 : {
79690 0 : std::cout << "SgOmpDistributeSimdStatement :: ";
79691 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
79692 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
79693 : }
79694 : }
79695 : else
79696 : {
79697 0 : std::cout << "SgOmpDistributeSimdStatement :: " << std::flush;
79698 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
79699 0 : std::cout << " not valid " << std::endl;
79700 : }
79701 : }
79702 :
79703 0 : if ( p_parent != NULL )
79704 : {
79705 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79706 : {
79707 0 : if ( p_parent->isInMemoryPool() == false )
79708 : {
79709 0 : std::cout << "SgOmpDistributeSimdStatement :: ";
79710 0 : std::cout << " p_parent is not in memory pool of ";
79711 0 : std::cout << p_parent->class_name() << std::endl;
79712 : }
79713 : }
79714 : else
79715 : {
79716 0 : std::cout << "SgOmpDistributeSimdStatement :: " << std::flush;
79717 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
79718 0 : std::cout << " not valid " << std::endl;
79719 : }
79720 : }
79721 :
79722 :
79723 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
79724 :
79725 0 : }
79726 :
79727 :
79728 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
79729 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
79730 : bool
79731 0 : SgOmpDistributeSimdStatement::isInMemoryPool ()
79732 : {
79733 0 : typedef unsigned char* TestType;
79734 :
79735 0 : bool found = false;
79736 :
79737 0 : ROSE_ASSERT(this != NULL);
79738 :
79739 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
79740 :
79741 0 : TestType tested = (TestType) ( this ) ;
79742 :
79743 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDistributeSimdStatement::pools.begin();
79744 :
79745 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
79746 : // while (found == false && block < Memory_Block_List.end())
79747 0 : while ( (found == false) && (block != SgOmpDistributeSimdStatement::pools.end()) )
79748 : {
79749 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDistributeSimdStatement::pool_size * sizeof(SgOmpDistributeSimdStatement) ) ) ;
79750 0 : ++block;
79751 : }
79752 :
79753 : // Special handling for static data
79754 :
79755 :
79756 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
79757 0 : ROSE_ASSERT(found == true);
79758 :
79759 0 : return found;
79760 : }
79761 : /* #line 79762 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
79762 :
79763 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
79764 :
79765 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
79766 :
79767 : /* #line 79768 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
79768 :
79769 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
79770 :
79771 : void
79772 0 : SgOmpDistributeParallelForStatement::checkDataMemberPointersIfInMemoryPool()
79773 : {
79774 : // ------------ checking pointers of SgOmpDistributeParallelForStatement -------------------
79775 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
79776 :
79777 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
79778 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
79779 : {
79780 0 : if ( (*i_clauses) != NULL )
79781 : {
79782 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79783 : {
79784 0 : if ( (*i_clauses)->isInMemoryPool() == false )
79785 : {
79786 0 : std::cout << "SgOmpDistributeParallelForStatement :: ";
79787 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
79788 0 : std::cout << (*i_clauses)->class_name() << std::endl;
79789 : }
79790 : }
79791 : else
79792 : {
79793 0 : std::cout << "SgOmpDistributeParallelForStatement :: " << std::flush;
79794 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
79795 0 : std::cout << " entry not valid " << std::endl;
79796 : }
79797 : }
79798 : else
79799 : {
79800 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
79801 : }
79802 : }
79803 :
79804 0 : if ( p_body != NULL )
79805 : {
79806 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79807 : {
79808 0 : if ( p_body->isInMemoryPool() == false )
79809 : {
79810 0 : std::cout << "SgOmpDistributeParallelForStatement :: ";
79811 0 : std::cout << " p_body is not in memory pool of ";
79812 0 : std::cout << p_body->class_name() << std::endl;
79813 : }
79814 : }
79815 : else
79816 : {
79817 0 : std::cout << "SgOmpDistributeParallelForStatement :: " << std::flush;
79818 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
79819 0 : std::cout << " not valid " << std::endl;
79820 : }
79821 : }
79822 :
79823 0 : if ( p_upir_parent != NULL )
79824 : {
79825 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79826 : {
79827 0 : if ( p_upir_parent->isInMemoryPool() == false )
79828 : {
79829 0 : std::cout << "SgOmpDistributeParallelForStatement :: ";
79830 0 : std::cout << " p_upir_parent is not in memory pool of ";
79831 0 : std::cout << p_upir_parent->class_name() << std::endl;
79832 : }
79833 : }
79834 : else
79835 : {
79836 0 : std::cout << "SgOmpDistributeParallelForStatement :: " << std::flush;
79837 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
79838 0 : std::cout << " not valid " << std::endl;
79839 : }
79840 : }
79841 :
79842 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
79843 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
79844 : {
79845 0 : if ( (*i_upir_children) != NULL )
79846 : {
79847 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79848 : {
79849 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
79850 : {
79851 0 : std::cout << "SgOmpDistributeParallelForStatement :: ";
79852 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
79853 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
79854 : }
79855 : }
79856 : else
79857 : {
79858 0 : std::cout << "SgOmpDistributeParallelForStatement :: " << std::flush;
79859 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
79860 0 : std::cout << " entry not valid " << std::endl;
79861 : }
79862 : }
79863 : else
79864 : {
79865 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
79866 : }
79867 : }
79868 :
79869 0 : if ( p_numeric_label != NULL )
79870 : {
79871 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79872 : {
79873 0 : if ( p_numeric_label->isInMemoryPool() == false )
79874 : {
79875 0 : std::cout << "SgOmpDistributeParallelForStatement :: ";
79876 0 : std::cout << " p_numeric_label is not in memory pool of ";
79877 0 : std::cout << p_numeric_label->class_name() << std::endl;
79878 : }
79879 : }
79880 : else
79881 : {
79882 0 : std::cout << "SgOmpDistributeParallelForStatement :: " << std::flush;
79883 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
79884 0 : std::cout << " not valid " << std::endl;
79885 : }
79886 : }
79887 :
79888 0 : if ( p_startOfConstruct != NULL )
79889 : {
79890 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79891 : {
79892 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
79893 : {
79894 0 : std::cout << "SgOmpDistributeParallelForStatement :: ";
79895 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
79896 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
79897 : }
79898 : }
79899 : else
79900 : {
79901 0 : std::cout << "SgOmpDistributeParallelForStatement :: " << std::flush;
79902 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
79903 0 : std::cout << " not valid " << std::endl;
79904 : }
79905 : }
79906 :
79907 0 : if ( p_endOfConstruct != NULL )
79908 : {
79909 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79910 : {
79911 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
79912 : {
79913 0 : std::cout << "SgOmpDistributeParallelForStatement :: ";
79914 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
79915 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
79916 : }
79917 : }
79918 : else
79919 : {
79920 0 : std::cout << "SgOmpDistributeParallelForStatement :: " << std::flush;
79921 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
79922 0 : std::cout << " not valid " << std::endl;
79923 : }
79924 : }
79925 :
79926 0 : if ( p_parent != NULL )
79927 : {
79928 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
79929 : {
79930 0 : if ( p_parent->isInMemoryPool() == false )
79931 : {
79932 0 : std::cout << "SgOmpDistributeParallelForStatement :: ";
79933 0 : std::cout << " p_parent is not in memory pool of ";
79934 0 : std::cout << p_parent->class_name() << std::endl;
79935 : }
79936 : }
79937 : else
79938 : {
79939 0 : std::cout << "SgOmpDistributeParallelForStatement :: " << std::flush;
79940 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
79941 0 : std::cout << " not valid " << std::endl;
79942 : }
79943 : }
79944 :
79945 :
79946 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
79947 :
79948 0 : }
79949 :
79950 :
79951 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
79952 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
79953 : bool
79954 0 : SgOmpDistributeParallelForStatement::isInMemoryPool ()
79955 : {
79956 0 : typedef unsigned char* TestType;
79957 :
79958 0 : bool found = false;
79959 :
79960 0 : ROSE_ASSERT(this != NULL);
79961 :
79962 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
79963 :
79964 0 : TestType tested = (TestType) ( this ) ;
79965 :
79966 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDistributeParallelForStatement::pools.begin();
79967 :
79968 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
79969 : // while (found == false && block < Memory_Block_List.end())
79970 0 : while ( (found == false) && (block != SgOmpDistributeParallelForStatement::pools.end()) )
79971 : {
79972 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDistributeParallelForStatement::pool_size * sizeof(SgOmpDistributeParallelForStatement) ) ) ;
79973 0 : ++block;
79974 : }
79975 :
79976 : // Special handling for static data
79977 :
79978 :
79979 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
79980 0 : ROSE_ASSERT(found == true);
79981 :
79982 0 : return found;
79983 : }
79984 : /* #line 79985 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
79985 :
79986 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
79987 :
79988 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
79989 :
79990 : /* #line 79991 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
79991 :
79992 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
79993 :
79994 : void
79995 0 : SgOmpDistributeParallelForSimdStatement::checkDataMemberPointersIfInMemoryPool()
79996 : {
79997 : // ------------ checking pointers of SgOmpDistributeParallelForSimdStatement -------------------
79998 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
79999 :
80000 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
80001 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
80002 : {
80003 0 : if ( (*i_clauses) != NULL )
80004 : {
80005 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80006 : {
80007 0 : if ( (*i_clauses)->isInMemoryPool() == false )
80008 : {
80009 0 : std::cout << "SgOmpDistributeParallelForSimdStatement :: ";
80010 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
80011 0 : std::cout << (*i_clauses)->class_name() << std::endl;
80012 : }
80013 : }
80014 : else
80015 : {
80016 0 : std::cout << "SgOmpDistributeParallelForSimdStatement :: " << std::flush;
80017 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
80018 0 : std::cout << " entry not valid " << std::endl;
80019 : }
80020 : }
80021 : else
80022 : {
80023 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
80024 : }
80025 : }
80026 :
80027 0 : if ( p_body != NULL )
80028 : {
80029 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80030 : {
80031 0 : if ( p_body->isInMemoryPool() == false )
80032 : {
80033 0 : std::cout << "SgOmpDistributeParallelForSimdStatement :: ";
80034 0 : std::cout << " p_body is not in memory pool of ";
80035 0 : std::cout << p_body->class_name() << std::endl;
80036 : }
80037 : }
80038 : else
80039 : {
80040 0 : std::cout << "SgOmpDistributeParallelForSimdStatement :: " << std::flush;
80041 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
80042 0 : std::cout << " not valid " << std::endl;
80043 : }
80044 : }
80045 :
80046 0 : if ( p_upir_parent != NULL )
80047 : {
80048 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80049 : {
80050 0 : if ( p_upir_parent->isInMemoryPool() == false )
80051 : {
80052 0 : std::cout << "SgOmpDistributeParallelForSimdStatement :: ";
80053 0 : std::cout << " p_upir_parent is not in memory pool of ";
80054 0 : std::cout << p_upir_parent->class_name() << std::endl;
80055 : }
80056 : }
80057 : else
80058 : {
80059 0 : std::cout << "SgOmpDistributeParallelForSimdStatement :: " << std::flush;
80060 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
80061 0 : std::cout << " not valid " << std::endl;
80062 : }
80063 : }
80064 :
80065 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
80066 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
80067 : {
80068 0 : if ( (*i_upir_children) != NULL )
80069 : {
80070 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80071 : {
80072 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
80073 : {
80074 0 : std::cout << "SgOmpDistributeParallelForSimdStatement :: ";
80075 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
80076 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
80077 : }
80078 : }
80079 : else
80080 : {
80081 0 : std::cout << "SgOmpDistributeParallelForSimdStatement :: " << std::flush;
80082 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
80083 0 : std::cout << " entry not valid " << std::endl;
80084 : }
80085 : }
80086 : else
80087 : {
80088 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
80089 : }
80090 : }
80091 :
80092 0 : if ( p_numeric_label != NULL )
80093 : {
80094 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80095 : {
80096 0 : if ( p_numeric_label->isInMemoryPool() == false )
80097 : {
80098 0 : std::cout << "SgOmpDistributeParallelForSimdStatement :: ";
80099 0 : std::cout << " p_numeric_label is not in memory pool of ";
80100 0 : std::cout << p_numeric_label->class_name() << std::endl;
80101 : }
80102 : }
80103 : else
80104 : {
80105 0 : std::cout << "SgOmpDistributeParallelForSimdStatement :: " << std::flush;
80106 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
80107 0 : std::cout << " not valid " << std::endl;
80108 : }
80109 : }
80110 :
80111 0 : if ( p_startOfConstruct != NULL )
80112 : {
80113 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80114 : {
80115 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
80116 : {
80117 0 : std::cout << "SgOmpDistributeParallelForSimdStatement :: ";
80118 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
80119 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
80120 : }
80121 : }
80122 : else
80123 : {
80124 0 : std::cout << "SgOmpDistributeParallelForSimdStatement :: " << std::flush;
80125 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
80126 0 : std::cout << " not valid " << std::endl;
80127 : }
80128 : }
80129 :
80130 0 : if ( p_endOfConstruct != NULL )
80131 : {
80132 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80133 : {
80134 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
80135 : {
80136 0 : std::cout << "SgOmpDistributeParallelForSimdStatement :: ";
80137 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
80138 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
80139 : }
80140 : }
80141 : else
80142 : {
80143 0 : std::cout << "SgOmpDistributeParallelForSimdStatement :: " << std::flush;
80144 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
80145 0 : std::cout << " not valid " << std::endl;
80146 : }
80147 : }
80148 :
80149 0 : if ( p_parent != NULL )
80150 : {
80151 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80152 : {
80153 0 : if ( p_parent->isInMemoryPool() == false )
80154 : {
80155 0 : std::cout << "SgOmpDistributeParallelForSimdStatement :: ";
80156 0 : std::cout << " p_parent is not in memory pool of ";
80157 0 : std::cout << p_parent->class_name() << std::endl;
80158 : }
80159 : }
80160 : else
80161 : {
80162 0 : std::cout << "SgOmpDistributeParallelForSimdStatement :: " << std::flush;
80163 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
80164 0 : std::cout << " not valid " << std::endl;
80165 : }
80166 : }
80167 :
80168 :
80169 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
80170 :
80171 0 : }
80172 :
80173 :
80174 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
80175 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
80176 : bool
80177 0 : SgOmpDistributeParallelForSimdStatement::isInMemoryPool ()
80178 : {
80179 0 : typedef unsigned char* TestType;
80180 :
80181 0 : bool found = false;
80182 :
80183 0 : ROSE_ASSERT(this != NULL);
80184 :
80185 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
80186 :
80187 0 : TestType tested = (TestType) ( this ) ;
80188 :
80189 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDistributeParallelForSimdStatement::pools.begin();
80190 :
80191 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
80192 : // while (found == false && block < Memory_Block_List.end())
80193 0 : while ( (found == false) && (block != SgOmpDistributeParallelForSimdStatement::pools.end()) )
80194 : {
80195 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDistributeParallelForSimdStatement::pool_size * sizeof(SgOmpDistributeParallelForSimdStatement) ) ) ;
80196 0 : ++block;
80197 : }
80198 :
80199 : // Special handling for static data
80200 :
80201 :
80202 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
80203 0 : ROSE_ASSERT(found == true);
80204 :
80205 0 : return found;
80206 : }
80207 : /* #line 80208 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
80208 :
80209 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
80210 :
80211 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
80212 :
80213 : /* #line 80214 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
80214 :
80215 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
80216 :
80217 : void
80218 0 : SgOmpTaskloopSimdStatement::checkDataMemberPointersIfInMemoryPool()
80219 : {
80220 : // ------------ checking pointers of SgOmpTaskloopSimdStatement -------------------
80221 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
80222 :
80223 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
80224 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
80225 : {
80226 0 : if ( (*i_clauses) != NULL )
80227 : {
80228 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80229 : {
80230 0 : if ( (*i_clauses)->isInMemoryPool() == false )
80231 : {
80232 0 : std::cout << "SgOmpTaskloopSimdStatement :: ";
80233 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
80234 0 : std::cout << (*i_clauses)->class_name() << std::endl;
80235 : }
80236 : }
80237 : else
80238 : {
80239 0 : std::cout << "SgOmpTaskloopSimdStatement :: " << std::flush;
80240 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
80241 0 : std::cout << " entry not valid " << std::endl;
80242 : }
80243 : }
80244 : else
80245 : {
80246 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
80247 : }
80248 : }
80249 :
80250 0 : if ( p_body != NULL )
80251 : {
80252 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80253 : {
80254 0 : if ( p_body->isInMemoryPool() == false )
80255 : {
80256 0 : std::cout << "SgOmpTaskloopSimdStatement :: ";
80257 0 : std::cout << " p_body is not in memory pool of ";
80258 0 : std::cout << p_body->class_name() << std::endl;
80259 : }
80260 : }
80261 : else
80262 : {
80263 0 : std::cout << "SgOmpTaskloopSimdStatement :: " << std::flush;
80264 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
80265 0 : std::cout << " not valid " << std::endl;
80266 : }
80267 : }
80268 :
80269 0 : if ( p_upir_parent != NULL )
80270 : {
80271 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80272 : {
80273 0 : if ( p_upir_parent->isInMemoryPool() == false )
80274 : {
80275 0 : std::cout << "SgOmpTaskloopSimdStatement :: ";
80276 0 : std::cout << " p_upir_parent is not in memory pool of ";
80277 0 : std::cout << p_upir_parent->class_name() << std::endl;
80278 : }
80279 : }
80280 : else
80281 : {
80282 0 : std::cout << "SgOmpTaskloopSimdStatement :: " << std::flush;
80283 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
80284 0 : std::cout << " not valid " << std::endl;
80285 : }
80286 : }
80287 :
80288 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
80289 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
80290 : {
80291 0 : if ( (*i_upir_children) != NULL )
80292 : {
80293 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80294 : {
80295 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
80296 : {
80297 0 : std::cout << "SgOmpTaskloopSimdStatement :: ";
80298 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
80299 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
80300 : }
80301 : }
80302 : else
80303 : {
80304 0 : std::cout << "SgOmpTaskloopSimdStatement :: " << std::flush;
80305 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
80306 0 : std::cout << " entry not valid " << std::endl;
80307 : }
80308 : }
80309 : else
80310 : {
80311 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
80312 : }
80313 : }
80314 :
80315 0 : if ( p_numeric_label != NULL )
80316 : {
80317 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80318 : {
80319 0 : if ( p_numeric_label->isInMemoryPool() == false )
80320 : {
80321 0 : std::cout << "SgOmpTaskloopSimdStatement :: ";
80322 0 : std::cout << " p_numeric_label is not in memory pool of ";
80323 0 : std::cout << p_numeric_label->class_name() << std::endl;
80324 : }
80325 : }
80326 : else
80327 : {
80328 0 : std::cout << "SgOmpTaskloopSimdStatement :: " << std::flush;
80329 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
80330 0 : std::cout << " not valid " << std::endl;
80331 : }
80332 : }
80333 :
80334 0 : if ( p_startOfConstruct != NULL )
80335 : {
80336 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80337 : {
80338 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
80339 : {
80340 0 : std::cout << "SgOmpTaskloopSimdStatement :: ";
80341 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
80342 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
80343 : }
80344 : }
80345 : else
80346 : {
80347 0 : std::cout << "SgOmpTaskloopSimdStatement :: " << std::flush;
80348 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
80349 0 : std::cout << " not valid " << std::endl;
80350 : }
80351 : }
80352 :
80353 0 : if ( p_endOfConstruct != NULL )
80354 : {
80355 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80356 : {
80357 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
80358 : {
80359 0 : std::cout << "SgOmpTaskloopSimdStatement :: ";
80360 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
80361 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
80362 : }
80363 : }
80364 : else
80365 : {
80366 0 : std::cout << "SgOmpTaskloopSimdStatement :: " << std::flush;
80367 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
80368 0 : std::cout << " not valid " << std::endl;
80369 : }
80370 : }
80371 :
80372 0 : if ( p_parent != NULL )
80373 : {
80374 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80375 : {
80376 0 : if ( p_parent->isInMemoryPool() == false )
80377 : {
80378 0 : std::cout << "SgOmpTaskloopSimdStatement :: ";
80379 0 : std::cout << " p_parent is not in memory pool of ";
80380 0 : std::cout << p_parent->class_name() << std::endl;
80381 : }
80382 : }
80383 : else
80384 : {
80385 0 : std::cout << "SgOmpTaskloopSimdStatement :: " << std::flush;
80386 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
80387 0 : std::cout << " not valid " << std::endl;
80388 : }
80389 : }
80390 :
80391 :
80392 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
80393 :
80394 0 : }
80395 :
80396 :
80397 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
80398 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
80399 : bool
80400 0 : SgOmpTaskloopSimdStatement::isInMemoryPool ()
80401 : {
80402 0 : typedef unsigned char* TestType;
80403 :
80404 0 : bool found = false;
80405 :
80406 0 : ROSE_ASSERT(this != NULL);
80407 :
80408 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
80409 :
80410 0 : TestType tested = (TestType) ( this ) ;
80411 :
80412 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTaskloopSimdStatement::pools.begin();
80413 :
80414 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
80415 : // while (found == false && block < Memory_Block_List.end())
80416 0 : while ( (found == false) && (block != SgOmpTaskloopSimdStatement::pools.end()) )
80417 : {
80418 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTaskloopSimdStatement::pool_size * sizeof(SgOmpTaskloopSimdStatement) ) ) ;
80419 0 : ++block;
80420 : }
80421 :
80422 : // Special handling for static data
80423 :
80424 :
80425 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
80426 0 : ROSE_ASSERT(found == true);
80427 :
80428 0 : return found;
80429 : }
80430 : /* #line 80431 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
80431 :
80432 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
80433 :
80434 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
80435 :
80436 : /* #line 80437 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
80437 :
80438 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
80439 :
80440 : void
80441 0 : SgOmpMasterTaskloopSimdStatement::checkDataMemberPointersIfInMemoryPool()
80442 : {
80443 : // ------------ checking pointers of SgOmpMasterTaskloopSimdStatement -------------------
80444 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
80445 :
80446 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
80447 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
80448 : {
80449 0 : if ( (*i_clauses) != NULL )
80450 : {
80451 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80452 : {
80453 0 : if ( (*i_clauses)->isInMemoryPool() == false )
80454 : {
80455 0 : std::cout << "SgOmpMasterTaskloopSimdStatement :: ";
80456 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
80457 0 : std::cout << (*i_clauses)->class_name() << std::endl;
80458 : }
80459 : }
80460 : else
80461 : {
80462 0 : std::cout << "SgOmpMasterTaskloopSimdStatement :: " << std::flush;
80463 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
80464 0 : std::cout << " entry not valid " << std::endl;
80465 : }
80466 : }
80467 : else
80468 : {
80469 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
80470 : }
80471 : }
80472 :
80473 0 : if ( p_body != NULL )
80474 : {
80475 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80476 : {
80477 0 : if ( p_body->isInMemoryPool() == false )
80478 : {
80479 0 : std::cout << "SgOmpMasterTaskloopSimdStatement :: ";
80480 0 : std::cout << " p_body is not in memory pool of ";
80481 0 : std::cout << p_body->class_name() << std::endl;
80482 : }
80483 : }
80484 : else
80485 : {
80486 0 : std::cout << "SgOmpMasterTaskloopSimdStatement :: " << std::flush;
80487 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
80488 0 : std::cout << " not valid " << std::endl;
80489 : }
80490 : }
80491 :
80492 0 : if ( p_upir_parent != NULL )
80493 : {
80494 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80495 : {
80496 0 : if ( p_upir_parent->isInMemoryPool() == false )
80497 : {
80498 0 : std::cout << "SgOmpMasterTaskloopSimdStatement :: ";
80499 0 : std::cout << " p_upir_parent is not in memory pool of ";
80500 0 : std::cout << p_upir_parent->class_name() << std::endl;
80501 : }
80502 : }
80503 : else
80504 : {
80505 0 : std::cout << "SgOmpMasterTaskloopSimdStatement :: " << std::flush;
80506 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
80507 0 : std::cout << " not valid " << std::endl;
80508 : }
80509 : }
80510 :
80511 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
80512 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
80513 : {
80514 0 : if ( (*i_upir_children) != NULL )
80515 : {
80516 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80517 : {
80518 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
80519 : {
80520 0 : std::cout << "SgOmpMasterTaskloopSimdStatement :: ";
80521 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
80522 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
80523 : }
80524 : }
80525 : else
80526 : {
80527 0 : std::cout << "SgOmpMasterTaskloopSimdStatement :: " << std::flush;
80528 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
80529 0 : std::cout << " entry not valid " << std::endl;
80530 : }
80531 : }
80532 : else
80533 : {
80534 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
80535 : }
80536 : }
80537 :
80538 0 : if ( p_numeric_label != NULL )
80539 : {
80540 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80541 : {
80542 0 : if ( p_numeric_label->isInMemoryPool() == false )
80543 : {
80544 0 : std::cout << "SgOmpMasterTaskloopSimdStatement :: ";
80545 0 : std::cout << " p_numeric_label is not in memory pool of ";
80546 0 : std::cout << p_numeric_label->class_name() << std::endl;
80547 : }
80548 : }
80549 : else
80550 : {
80551 0 : std::cout << "SgOmpMasterTaskloopSimdStatement :: " << std::flush;
80552 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
80553 0 : std::cout << " not valid " << std::endl;
80554 : }
80555 : }
80556 :
80557 0 : if ( p_startOfConstruct != NULL )
80558 : {
80559 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80560 : {
80561 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
80562 : {
80563 0 : std::cout << "SgOmpMasterTaskloopSimdStatement :: ";
80564 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
80565 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
80566 : }
80567 : }
80568 : else
80569 : {
80570 0 : std::cout << "SgOmpMasterTaskloopSimdStatement :: " << std::flush;
80571 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
80572 0 : std::cout << " not valid " << std::endl;
80573 : }
80574 : }
80575 :
80576 0 : if ( p_endOfConstruct != NULL )
80577 : {
80578 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80579 : {
80580 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
80581 : {
80582 0 : std::cout << "SgOmpMasterTaskloopSimdStatement :: ";
80583 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
80584 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
80585 : }
80586 : }
80587 : else
80588 : {
80589 0 : std::cout << "SgOmpMasterTaskloopSimdStatement :: " << std::flush;
80590 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
80591 0 : std::cout << " not valid " << std::endl;
80592 : }
80593 : }
80594 :
80595 0 : if ( p_parent != NULL )
80596 : {
80597 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80598 : {
80599 0 : if ( p_parent->isInMemoryPool() == false )
80600 : {
80601 0 : std::cout << "SgOmpMasterTaskloopSimdStatement :: ";
80602 0 : std::cout << " p_parent is not in memory pool of ";
80603 0 : std::cout << p_parent->class_name() << std::endl;
80604 : }
80605 : }
80606 : else
80607 : {
80608 0 : std::cout << "SgOmpMasterTaskloopSimdStatement :: " << std::flush;
80609 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
80610 0 : std::cout << " not valid " << std::endl;
80611 : }
80612 : }
80613 :
80614 :
80615 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
80616 :
80617 0 : }
80618 :
80619 :
80620 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
80621 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
80622 : bool
80623 0 : SgOmpMasterTaskloopSimdStatement::isInMemoryPool ()
80624 : {
80625 0 : typedef unsigned char* TestType;
80626 :
80627 0 : bool found = false;
80628 :
80629 0 : ROSE_ASSERT(this != NULL);
80630 :
80631 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
80632 :
80633 0 : TestType tested = (TestType) ( this ) ;
80634 :
80635 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpMasterTaskloopSimdStatement::pools.begin();
80636 :
80637 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
80638 : // while (found == false && block < Memory_Block_List.end())
80639 0 : while ( (found == false) && (block != SgOmpMasterTaskloopSimdStatement::pools.end()) )
80640 : {
80641 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpMasterTaskloopSimdStatement::pool_size * sizeof(SgOmpMasterTaskloopSimdStatement) ) ) ;
80642 0 : ++block;
80643 : }
80644 :
80645 : // Special handling for static data
80646 :
80647 :
80648 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
80649 0 : ROSE_ASSERT(found == true);
80650 :
80651 0 : return found;
80652 : }
80653 : /* #line 80654 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
80654 :
80655 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
80656 :
80657 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
80658 :
80659 : /* #line 80660 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
80660 :
80661 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
80662 :
80663 : void
80664 0 : SgOmpParallelMasterTaskloopStatement::checkDataMemberPointersIfInMemoryPool()
80665 : {
80666 : // ------------ checking pointers of SgOmpParallelMasterTaskloopStatement -------------------
80667 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
80668 :
80669 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
80670 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
80671 : {
80672 0 : if ( (*i_clauses) != NULL )
80673 : {
80674 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80675 : {
80676 0 : if ( (*i_clauses)->isInMemoryPool() == false )
80677 : {
80678 0 : std::cout << "SgOmpParallelMasterTaskloopStatement :: ";
80679 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
80680 0 : std::cout << (*i_clauses)->class_name() << std::endl;
80681 : }
80682 : }
80683 : else
80684 : {
80685 0 : std::cout << "SgOmpParallelMasterTaskloopStatement :: " << std::flush;
80686 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
80687 0 : std::cout << " entry not valid " << std::endl;
80688 : }
80689 : }
80690 : else
80691 : {
80692 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
80693 : }
80694 : }
80695 :
80696 0 : if ( p_body != NULL )
80697 : {
80698 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80699 : {
80700 0 : if ( p_body->isInMemoryPool() == false )
80701 : {
80702 0 : std::cout << "SgOmpParallelMasterTaskloopStatement :: ";
80703 0 : std::cout << " p_body is not in memory pool of ";
80704 0 : std::cout << p_body->class_name() << std::endl;
80705 : }
80706 : }
80707 : else
80708 : {
80709 0 : std::cout << "SgOmpParallelMasterTaskloopStatement :: " << std::flush;
80710 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
80711 0 : std::cout << " not valid " << std::endl;
80712 : }
80713 : }
80714 :
80715 0 : if ( p_upir_parent != NULL )
80716 : {
80717 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80718 : {
80719 0 : if ( p_upir_parent->isInMemoryPool() == false )
80720 : {
80721 0 : std::cout << "SgOmpParallelMasterTaskloopStatement :: ";
80722 0 : std::cout << " p_upir_parent is not in memory pool of ";
80723 0 : std::cout << p_upir_parent->class_name() << std::endl;
80724 : }
80725 : }
80726 : else
80727 : {
80728 0 : std::cout << "SgOmpParallelMasterTaskloopStatement :: " << std::flush;
80729 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
80730 0 : std::cout << " not valid " << std::endl;
80731 : }
80732 : }
80733 :
80734 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
80735 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
80736 : {
80737 0 : if ( (*i_upir_children) != NULL )
80738 : {
80739 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80740 : {
80741 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
80742 : {
80743 0 : std::cout << "SgOmpParallelMasterTaskloopStatement :: ";
80744 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
80745 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
80746 : }
80747 : }
80748 : else
80749 : {
80750 0 : std::cout << "SgOmpParallelMasterTaskloopStatement :: " << std::flush;
80751 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
80752 0 : std::cout << " entry not valid " << std::endl;
80753 : }
80754 : }
80755 : else
80756 : {
80757 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
80758 : }
80759 : }
80760 :
80761 0 : if ( p_numeric_label != NULL )
80762 : {
80763 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80764 : {
80765 0 : if ( p_numeric_label->isInMemoryPool() == false )
80766 : {
80767 0 : std::cout << "SgOmpParallelMasterTaskloopStatement :: ";
80768 0 : std::cout << " p_numeric_label is not in memory pool of ";
80769 0 : std::cout << p_numeric_label->class_name() << std::endl;
80770 : }
80771 : }
80772 : else
80773 : {
80774 0 : std::cout << "SgOmpParallelMasterTaskloopStatement :: " << std::flush;
80775 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
80776 0 : std::cout << " not valid " << std::endl;
80777 : }
80778 : }
80779 :
80780 0 : if ( p_startOfConstruct != NULL )
80781 : {
80782 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80783 : {
80784 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
80785 : {
80786 0 : std::cout << "SgOmpParallelMasterTaskloopStatement :: ";
80787 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
80788 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
80789 : }
80790 : }
80791 : else
80792 : {
80793 0 : std::cout << "SgOmpParallelMasterTaskloopStatement :: " << std::flush;
80794 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
80795 0 : std::cout << " not valid " << std::endl;
80796 : }
80797 : }
80798 :
80799 0 : if ( p_endOfConstruct != NULL )
80800 : {
80801 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80802 : {
80803 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
80804 : {
80805 0 : std::cout << "SgOmpParallelMasterTaskloopStatement :: ";
80806 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
80807 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
80808 : }
80809 : }
80810 : else
80811 : {
80812 0 : std::cout << "SgOmpParallelMasterTaskloopStatement :: " << std::flush;
80813 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
80814 0 : std::cout << " not valid " << std::endl;
80815 : }
80816 : }
80817 :
80818 0 : if ( p_parent != NULL )
80819 : {
80820 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80821 : {
80822 0 : if ( p_parent->isInMemoryPool() == false )
80823 : {
80824 0 : std::cout << "SgOmpParallelMasterTaskloopStatement :: ";
80825 0 : std::cout << " p_parent is not in memory pool of ";
80826 0 : std::cout << p_parent->class_name() << std::endl;
80827 : }
80828 : }
80829 : else
80830 : {
80831 0 : std::cout << "SgOmpParallelMasterTaskloopStatement :: " << std::flush;
80832 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
80833 0 : std::cout << " not valid " << std::endl;
80834 : }
80835 : }
80836 :
80837 :
80838 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
80839 :
80840 0 : }
80841 :
80842 :
80843 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
80844 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
80845 : bool
80846 0 : SgOmpParallelMasterTaskloopStatement::isInMemoryPool ()
80847 : {
80848 0 : typedef unsigned char* TestType;
80849 :
80850 0 : bool found = false;
80851 :
80852 0 : ROSE_ASSERT(this != NULL);
80853 :
80854 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
80855 :
80856 0 : TestType tested = (TestType) ( this ) ;
80857 :
80858 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpParallelMasterTaskloopStatement::pools.begin();
80859 :
80860 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
80861 : // while (found == false && block < Memory_Block_List.end())
80862 0 : while ( (found == false) && (block != SgOmpParallelMasterTaskloopStatement::pools.end()) )
80863 : {
80864 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpParallelMasterTaskloopStatement::pool_size * sizeof(SgOmpParallelMasterTaskloopStatement) ) ) ;
80865 0 : ++block;
80866 : }
80867 :
80868 : // Special handling for static data
80869 :
80870 :
80871 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
80872 0 : ROSE_ASSERT(found == true);
80873 :
80874 0 : return found;
80875 : }
80876 : /* #line 80877 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
80877 :
80878 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
80879 :
80880 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
80881 :
80882 : /* #line 80883 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
80883 :
80884 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
80885 :
80886 : void
80887 0 : SgOmpParallelMasterTaskloopSimdStatement::checkDataMemberPointersIfInMemoryPool()
80888 : {
80889 : // ------------ checking pointers of SgOmpParallelMasterTaskloopSimdStatement -------------------
80890 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
80891 :
80892 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
80893 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
80894 : {
80895 0 : if ( (*i_clauses) != NULL )
80896 : {
80897 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80898 : {
80899 0 : if ( (*i_clauses)->isInMemoryPool() == false )
80900 : {
80901 0 : std::cout << "SgOmpParallelMasterTaskloopSimdStatement :: ";
80902 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
80903 0 : std::cout << (*i_clauses)->class_name() << std::endl;
80904 : }
80905 : }
80906 : else
80907 : {
80908 0 : std::cout << "SgOmpParallelMasterTaskloopSimdStatement :: " << std::flush;
80909 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
80910 0 : std::cout << " entry not valid " << std::endl;
80911 : }
80912 : }
80913 : else
80914 : {
80915 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
80916 : }
80917 : }
80918 :
80919 0 : if ( p_body != NULL )
80920 : {
80921 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80922 : {
80923 0 : if ( p_body->isInMemoryPool() == false )
80924 : {
80925 0 : std::cout << "SgOmpParallelMasterTaskloopSimdStatement :: ";
80926 0 : std::cout << " p_body is not in memory pool of ";
80927 0 : std::cout << p_body->class_name() << std::endl;
80928 : }
80929 : }
80930 : else
80931 : {
80932 0 : std::cout << "SgOmpParallelMasterTaskloopSimdStatement :: " << std::flush;
80933 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
80934 0 : std::cout << " not valid " << std::endl;
80935 : }
80936 : }
80937 :
80938 0 : if ( p_upir_parent != NULL )
80939 : {
80940 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80941 : {
80942 0 : if ( p_upir_parent->isInMemoryPool() == false )
80943 : {
80944 0 : std::cout << "SgOmpParallelMasterTaskloopSimdStatement :: ";
80945 0 : std::cout << " p_upir_parent is not in memory pool of ";
80946 0 : std::cout << p_upir_parent->class_name() << std::endl;
80947 : }
80948 : }
80949 : else
80950 : {
80951 0 : std::cout << "SgOmpParallelMasterTaskloopSimdStatement :: " << std::flush;
80952 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
80953 0 : std::cout << " not valid " << std::endl;
80954 : }
80955 : }
80956 :
80957 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
80958 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
80959 : {
80960 0 : if ( (*i_upir_children) != NULL )
80961 : {
80962 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80963 : {
80964 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
80965 : {
80966 0 : std::cout << "SgOmpParallelMasterTaskloopSimdStatement :: ";
80967 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
80968 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
80969 : }
80970 : }
80971 : else
80972 : {
80973 0 : std::cout << "SgOmpParallelMasterTaskloopSimdStatement :: " << std::flush;
80974 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
80975 0 : std::cout << " entry not valid " << std::endl;
80976 : }
80977 : }
80978 : else
80979 : {
80980 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
80981 : }
80982 : }
80983 :
80984 0 : if ( p_numeric_label != NULL )
80985 : {
80986 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
80987 : {
80988 0 : if ( p_numeric_label->isInMemoryPool() == false )
80989 : {
80990 0 : std::cout << "SgOmpParallelMasterTaskloopSimdStatement :: ";
80991 0 : std::cout << " p_numeric_label is not in memory pool of ";
80992 0 : std::cout << p_numeric_label->class_name() << std::endl;
80993 : }
80994 : }
80995 : else
80996 : {
80997 0 : std::cout << "SgOmpParallelMasterTaskloopSimdStatement :: " << std::flush;
80998 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
80999 0 : std::cout << " not valid " << std::endl;
81000 : }
81001 : }
81002 :
81003 0 : if ( p_startOfConstruct != NULL )
81004 : {
81005 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81006 : {
81007 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
81008 : {
81009 0 : std::cout << "SgOmpParallelMasterTaskloopSimdStatement :: ";
81010 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
81011 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
81012 : }
81013 : }
81014 : else
81015 : {
81016 0 : std::cout << "SgOmpParallelMasterTaskloopSimdStatement :: " << std::flush;
81017 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
81018 0 : std::cout << " not valid " << std::endl;
81019 : }
81020 : }
81021 :
81022 0 : if ( p_endOfConstruct != NULL )
81023 : {
81024 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81025 : {
81026 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
81027 : {
81028 0 : std::cout << "SgOmpParallelMasterTaskloopSimdStatement :: ";
81029 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
81030 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
81031 : }
81032 : }
81033 : else
81034 : {
81035 0 : std::cout << "SgOmpParallelMasterTaskloopSimdStatement :: " << std::flush;
81036 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
81037 0 : std::cout << " not valid " << std::endl;
81038 : }
81039 : }
81040 :
81041 0 : if ( p_parent != NULL )
81042 : {
81043 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81044 : {
81045 0 : if ( p_parent->isInMemoryPool() == false )
81046 : {
81047 0 : std::cout << "SgOmpParallelMasterTaskloopSimdStatement :: ";
81048 0 : std::cout << " p_parent is not in memory pool of ";
81049 0 : std::cout << p_parent->class_name() << std::endl;
81050 : }
81051 : }
81052 : else
81053 : {
81054 0 : std::cout << "SgOmpParallelMasterTaskloopSimdStatement :: " << std::flush;
81055 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
81056 0 : std::cout << " not valid " << std::endl;
81057 : }
81058 : }
81059 :
81060 :
81061 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
81062 :
81063 0 : }
81064 :
81065 :
81066 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
81067 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
81068 : bool
81069 0 : SgOmpParallelMasterTaskloopSimdStatement::isInMemoryPool ()
81070 : {
81071 0 : typedef unsigned char* TestType;
81072 :
81073 0 : bool found = false;
81074 :
81075 0 : ROSE_ASSERT(this != NULL);
81076 :
81077 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
81078 :
81079 0 : TestType tested = (TestType) ( this ) ;
81080 :
81081 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpParallelMasterTaskloopSimdStatement::pools.begin();
81082 :
81083 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
81084 : // while (found == false && block < Memory_Block_List.end())
81085 0 : while ( (found == false) && (block != SgOmpParallelMasterTaskloopSimdStatement::pools.end()) )
81086 : {
81087 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpParallelMasterTaskloopSimdStatement::pool_size * sizeof(SgOmpParallelMasterTaskloopSimdStatement) ) ) ;
81088 0 : ++block;
81089 : }
81090 :
81091 : // Special handling for static data
81092 :
81093 :
81094 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
81095 0 : ROSE_ASSERT(found == true);
81096 :
81097 0 : return found;
81098 : }
81099 : /* #line 81100 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
81100 :
81101 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
81102 :
81103 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
81104 :
81105 : /* #line 81106 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
81106 :
81107 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
81108 :
81109 : void
81110 0 : SgOmpTeamsDistributeStatement::checkDataMemberPointersIfInMemoryPool()
81111 : {
81112 : // ------------ checking pointers of SgOmpTeamsDistributeStatement -------------------
81113 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
81114 :
81115 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
81116 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
81117 : {
81118 0 : if ( (*i_clauses) != NULL )
81119 : {
81120 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81121 : {
81122 0 : if ( (*i_clauses)->isInMemoryPool() == false )
81123 : {
81124 0 : std::cout << "SgOmpTeamsDistributeStatement :: ";
81125 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
81126 0 : std::cout << (*i_clauses)->class_name() << std::endl;
81127 : }
81128 : }
81129 : else
81130 : {
81131 0 : std::cout << "SgOmpTeamsDistributeStatement :: " << std::flush;
81132 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
81133 0 : std::cout << " entry not valid " << std::endl;
81134 : }
81135 : }
81136 : else
81137 : {
81138 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
81139 : }
81140 : }
81141 :
81142 0 : if ( p_body != NULL )
81143 : {
81144 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81145 : {
81146 0 : if ( p_body->isInMemoryPool() == false )
81147 : {
81148 0 : std::cout << "SgOmpTeamsDistributeStatement :: ";
81149 0 : std::cout << " p_body is not in memory pool of ";
81150 0 : std::cout << p_body->class_name() << std::endl;
81151 : }
81152 : }
81153 : else
81154 : {
81155 0 : std::cout << "SgOmpTeamsDistributeStatement :: " << std::flush;
81156 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
81157 0 : std::cout << " not valid " << std::endl;
81158 : }
81159 : }
81160 :
81161 0 : if ( p_upir_parent != NULL )
81162 : {
81163 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81164 : {
81165 0 : if ( p_upir_parent->isInMemoryPool() == false )
81166 : {
81167 0 : std::cout << "SgOmpTeamsDistributeStatement :: ";
81168 0 : std::cout << " p_upir_parent is not in memory pool of ";
81169 0 : std::cout << p_upir_parent->class_name() << std::endl;
81170 : }
81171 : }
81172 : else
81173 : {
81174 0 : std::cout << "SgOmpTeamsDistributeStatement :: " << std::flush;
81175 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
81176 0 : std::cout << " not valid " << std::endl;
81177 : }
81178 : }
81179 :
81180 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
81181 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
81182 : {
81183 0 : if ( (*i_upir_children) != NULL )
81184 : {
81185 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81186 : {
81187 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
81188 : {
81189 0 : std::cout << "SgOmpTeamsDistributeStatement :: ";
81190 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
81191 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
81192 : }
81193 : }
81194 : else
81195 : {
81196 0 : std::cout << "SgOmpTeamsDistributeStatement :: " << std::flush;
81197 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
81198 0 : std::cout << " entry not valid " << std::endl;
81199 : }
81200 : }
81201 : else
81202 : {
81203 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
81204 : }
81205 : }
81206 :
81207 0 : if ( p_numeric_label != NULL )
81208 : {
81209 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81210 : {
81211 0 : if ( p_numeric_label->isInMemoryPool() == false )
81212 : {
81213 0 : std::cout << "SgOmpTeamsDistributeStatement :: ";
81214 0 : std::cout << " p_numeric_label is not in memory pool of ";
81215 0 : std::cout << p_numeric_label->class_name() << std::endl;
81216 : }
81217 : }
81218 : else
81219 : {
81220 0 : std::cout << "SgOmpTeamsDistributeStatement :: " << std::flush;
81221 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
81222 0 : std::cout << " not valid " << std::endl;
81223 : }
81224 : }
81225 :
81226 0 : if ( p_startOfConstruct != NULL )
81227 : {
81228 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81229 : {
81230 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
81231 : {
81232 0 : std::cout << "SgOmpTeamsDistributeStatement :: ";
81233 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
81234 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
81235 : }
81236 : }
81237 : else
81238 : {
81239 0 : std::cout << "SgOmpTeamsDistributeStatement :: " << std::flush;
81240 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
81241 0 : std::cout << " not valid " << std::endl;
81242 : }
81243 : }
81244 :
81245 0 : if ( p_endOfConstruct != NULL )
81246 : {
81247 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81248 : {
81249 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
81250 : {
81251 0 : std::cout << "SgOmpTeamsDistributeStatement :: ";
81252 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
81253 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
81254 : }
81255 : }
81256 : else
81257 : {
81258 0 : std::cout << "SgOmpTeamsDistributeStatement :: " << std::flush;
81259 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
81260 0 : std::cout << " not valid " << std::endl;
81261 : }
81262 : }
81263 :
81264 0 : if ( p_parent != NULL )
81265 : {
81266 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81267 : {
81268 0 : if ( p_parent->isInMemoryPool() == false )
81269 : {
81270 0 : std::cout << "SgOmpTeamsDistributeStatement :: ";
81271 0 : std::cout << " p_parent is not in memory pool of ";
81272 0 : std::cout << p_parent->class_name() << std::endl;
81273 : }
81274 : }
81275 : else
81276 : {
81277 0 : std::cout << "SgOmpTeamsDistributeStatement :: " << std::flush;
81278 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
81279 0 : std::cout << " not valid " << std::endl;
81280 : }
81281 : }
81282 :
81283 :
81284 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
81285 :
81286 0 : }
81287 :
81288 :
81289 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
81290 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
81291 : bool
81292 0 : SgOmpTeamsDistributeStatement::isInMemoryPool ()
81293 : {
81294 0 : typedef unsigned char* TestType;
81295 :
81296 0 : bool found = false;
81297 :
81298 0 : ROSE_ASSERT(this != NULL);
81299 :
81300 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
81301 :
81302 0 : TestType tested = (TestType) ( this ) ;
81303 :
81304 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTeamsDistributeStatement::pools.begin();
81305 :
81306 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
81307 : // while (found == false && block < Memory_Block_List.end())
81308 0 : while ( (found == false) && (block != SgOmpTeamsDistributeStatement::pools.end()) )
81309 : {
81310 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTeamsDistributeStatement::pool_size * sizeof(SgOmpTeamsDistributeStatement) ) ) ;
81311 0 : ++block;
81312 : }
81313 :
81314 : // Special handling for static data
81315 :
81316 :
81317 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
81318 0 : ROSE_ASSERT(found == true);
81319 :
81320 0 : return found;
81321 : }
81322 : /* #line 81323 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
81323 :
81324 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
81325 :
81326 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
81327 :
81328 : /* #line 81329 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
81329 :
81330 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
81331 :
81332 : void
81333 0 : SgOmpTeamsDistributeSimdStatement::checkDataMemberPointersIfInMemoryPool()
81334 : {
81335 : // ------------ checking pointers of SgOmpTeamsDistributeSimdStatement -------------------
81336 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
81337 :
81338 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
81339 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
81340 : {
81341 0 : if ( (*i_clauses) != NULL )
81342 : {
81343 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81344 : {
81345 0 : if ( (*i_clauses)->isInMemoryPool() == false )
81346 : {
81347 0 : std::cout << "SgOmpTeamsDistributeSimdStatement :: ";
81348 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
81349 0 : std::cout << (*i_clauses)->class_name() << std::endl;
81350 : }
81351 : }
81352 : else
81353 : {
81354 0 : std::cout << "SgOmpTeamsDistributeSimdStatement :: " << std::flush;
81355 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
81356 0 : std::cout << " entry not valid " << std::endl;
81357 : }
81358 : }
81359 : else
81360 : {
81361 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
81362 : }
81363 : }
81364 :
81365 0 : if ( p_body != NULL )
81366 : {
81367 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81368 : {
81369 0 : if ( p_body->isInMemoryPool() == false )
81370 : {
81371 0 : std::cout << "SgOmpTeamsDistributeSimdStatement :: ";
81372 0 : std::cout << " p_body is not in memory pool of ";
81373 0 : std::cout << p_body->class_name() << std::endl;
81374 : }
81375 : }
81376 : else
81377 : {
81378 0 : std::cout << "SgOmpTeamsDistributeSimdStatement :: " << std::flush;
81379 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
81380 0 : std::cout << " not valid " << std::endl;
81381 : }
81382 : }
81383 :
81384 0 : if ( p_upir_parent != NULL )
81385 : {
81386 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81387 : {
81388 0 : if ( p_upir_parent->isInMemoryPool() == false )
81389 : {
81390 0 : std::cout << "SgOmpTeamsDistributeSimdStatement :: ";
81391 0 : std::cout << " p_upir_parent is not in memory pool of ";
81392 0 : std::cout << p_upir_parent->class_name() << std::endl;
81393 : }
81394 : }
81395 : else
81396 : {
81397 0 : std::cout << "SgOmpTeamsDistributeSimdStatement :: " << std::flush;
81398 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
81399 0 : std::cout << " not valid " << std::endl;
81400 : }
81401 : }
81402 :
81403 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
81404 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
81405 : {
81406 0 : if ( (*i_upir_children) != NULL )
81407 : {
81408 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81409 : {
81410 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
81411 : {
81412 0 : std::cout << "SgOmpTeamsDistributeSimdStatement :: ";
81413 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
81414 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
81415 : }
81416 : }
81417 : else
81418 : {
81419 0 : std::cout << "SgOmpTeamsDistributeSimdStatement :: " << std::flush;
81420 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
81421 0 : std::cout << " entry not valid " << std::endl;
81422 : }
81423 : }
81424 : else
81425 : {
81426 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
81427 : }
81428 : }
81429 :
81430 0 : if ( p_numeric_label != NULL )
81431 : {
81432 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81433 : {
81434 0 : if ( p_numeric_label->isInMemoryPool() == false )
81435 : {
81436 0 : std::cout << "SgOmpTeamsDistributeSimdStatement :: ";
81437 0 : std::cout << " p_numeric_label is not in memory pool of ";
81438 0 : std::cout << p_numeric_label->class_name() << std::endl;
81439 : }
81440 : }
81441 : else
81442 : {
81443 0 : std::cout << "SgOmpTeamsDistributeSimdStatement :: " << std::flush;
81444 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
81445 0 : std::cout << " not valid " << std::endl;
81446 : }
81447 : }
81448 :
81449 0 : if ( p_startOfConstruct != NULL )
81450 : {
81451 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81452 : {
81453 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
81454 : {
81455 0 : std::cout << "SgOmpTeamsDistributeSimdStatement :: ";
81456 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
81457 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
81458 : }
81459 : }
81460 : else
81461 : {
81462 0 : std::cout << "SgOmpTeamsDistributeSimdStatement :: " << std::flush;
81463 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
81464 0 : std::cout << " not valid " << std::endl;
81465 : }
81466 : }
81467 :
81468 0 : if ( p_endOfConstruct != NULL )
81469 : {
81470 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81471 : {
81472 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
81473 : {
81474 0 : std::cout << "SgOmpTeamsDistributeSimdStatement :: ";
81475 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
81476 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
81477 : }
81478 : }
81479 : else
81480 : {
81481 0 : std::cout << "SgOmpTeamsDistributeSimdStatement :: " << std::flush;
81482 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
81483 0 : std::cout << " not valid " << std::endl;
81484 : }
81485 : }
81486 :
81487 0 : if ( p_parent != NULL )
81488 : {
81489 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81490 : {
81491 0 : if ( p_parent->isInMemoryPool() == false )
81492 : {
81493 0 : std::cout << "SgOmpTeamsDistributeSimdStatement :: ";
81494 0 : std::cout << " p_parent is not in memory pool of ";
81495 0 : std::cout << p_parent->class_name() << std::endl;
81496 : }
81497 : }
81498 : else
81499 : {
81500 0 : std::cout << "SgOmpTeamsDistributeSimdStatement :: " << std::flush;
81501 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
81502 0 : std::cout << " not valid " << std::endl;
81503 : }
81504 : }
81505 :
81506 :
81507 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
81508 :
81509 0 : }
81510 :
81511 :
81512 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
81513 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
81514 : bool
81515 0 : SgOmpTeamsDistributeSimdStatement::isInMemoryPool ()
81516 : {
81517 0 : typedef unsigned char* TestType;
81518 :
81519 0 : bool found = false;
81520 :
81521 0 : ROSE_ASSERT(this != NULL);
81522 :
81523 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
81524 :
81525 0 : TestType tested = (TestType) ( this ) ;
81526 :
81527 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTeamsDistributeSimdStatement::pools.begin();
81528 :
81529 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
81530 : // while (found == false && block < Memory_Block_List.end())
81531 0 : while ( (found == false) && (block != SgOmpTeamsDistributeSimdStatement::pools.end()) )
81532 : {
81533 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTeamsDistributeSimdStatement::pool_size * sizeof(SgOmpTeamsDistributeSimdStatement) ) ) ;
81534 0 : ++block;
81535 : }
81536 :
81537 : // Special handling for static data
81538 :
81539 :
81540 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
81541 0 : ROSE_ASSERT(found == true);
81542 :
81543 0 : return found;
81544 : }
81545 : /* #line 81546 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
81546 :
81547 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
81548 :
81549 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
81550 :
81551 : /* #line 81552 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
81552 :
81553 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
81554 :
81555 : void
81556 0 : SgOmpTeamsDistributeParallelForStatement::checkDataMemberPointersIfInMemoryPool()
81557 : {
81558 : // ------------ checking pointers of SgOmpTeamsDistributeParallelForStatement -------------------
81559 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
81560 :
81561 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
81562 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
81563 : {
81564 0 : if ( (*i_clauses) != NULL )
81565 : {
81566 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81567 : {
81568 0 : if ( (*i_clauses)->isInMemoryPool() == false )
81569 : {
81570 0 : std::cout << "SgOmpTeamsDistributeParallelForStatement :: ";
81571 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
81572 0 : std::cout << (*i_clauses)->class_name() << std::endl;
81573 : }
81574 : }
81575 : else
81576 : {
81577 0 : std::cout << "SgOmpTeamsDistributeParallelForStatement :: " << std::flush;
81578 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
81579 0 : std::cout << " entry not valid " << std::endl;
81580 : }
81581 : }
81582 : else
81583 : {
81584 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
81585 : }
81586 : }
81587 :
81588 0 : if ( p_body != NULL )
81589 : {
81590 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81591 : {
81592 0 : if ( p_body->isInMemoryPool() == false )
81593 : {
81594 0 : std::cout << "SgOmpTeamsDistributeParallelForStatement :: ";
81595 0 : std::cout << " p_body is not in memory pool of ";
81596 0 : std::cout << p_body->class_name() << std::endl;
81597 : }
81598 : }
81599 : else
81600 : {
81601 0 : std::cout << "SgOmpTeamsDistributeParallelForStatement :: " << std::flush;
81602 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
81603 0 : std::cout << " not valid " << std::endl;
81604 : }
81605 : }
81606 :
81607 0 : if ( p_upir_parent != NULL )
81608 : {
81609 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81610 : {
81611 0 : if ( p_upir_parent->isInMemoryPool() == false )
81612 : {
81613 0 : std::cout << "SgOmpTeamsDistributeParallelForStatement :: ";
81614 0 : std::cout << " p_upir_parent is not in memory pool of ";
81615 0 : std::cout << p_upir_parent->class_name() << std::endl;
81616 : }
81617 : }
81618 : else
81619 : {
81620 0 : std::cout << "SgOmpTeamsDistributeParallelForStatement :: " << std::flush;
81621 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
81622 0 : std::cout << " not valid " << std::endl;
81623 : }
81624 : }
81625 :
81626 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
81627 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
81628 : {
81629 0 : if ( (*i_upir_children) != NULL )
81630 : {
81631 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81632 : {
81633 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
81634 : {
81635 0 : std::cout << "SgOmpTeamsDistributeParallelForStatement :: ";
81636 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
81637 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
81638 : }
81639 : }
81640 : else
81641 : {
81642 0 : std::cout << "SgOmpTeamsDistributeParallelForStatement :: " << std::flush;
81643 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
81644 0 : std::cout << " entry not valid " << std::endl;
81645 : }
81646 : }
81647 : else
81648 : {
81649 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
81650 : }
81651 : }
81652 :
81653 0 : if ( p_numeric_label != NULL )
81654 : {
81655 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81656 : {
81657 0 : if ( p_numeric_label->isInMemoryPool() == false )
81658 : {
81659 0 : std::cout << "SgOmpTeamsDistributeParallelForStatement :: ";
81660 0 : std::cout << " p_numeric_label is not in memory pool of ";
81661 0 : std::cout << p_numeric_label->class_name() << std::endl;
81662 : }
81663 : }
81664 : else
81665 : {
81666 0 : std::cout << "SgOmpTeamsDistributeParallelForStatement :: " << std::flush;
81667 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
81668 0 : std::cout << " not valid " << std::endl;
81669 : }
81670 : }
81671 :
81672 0 : if ( p_startOfConstruct != NULL )
81673 : {
81674 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81675 : {
81676 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
81677 : {
81678 0 : std::cout << "SgOmpTeamsDistributeParallelForStatement :: ";
81679 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
81680 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
81681 : }
81682 : }
81683 : else
81684 : {
81685 0 : std::cout << "SgOmpTeamsDistributeParallelForStatement :: " << std::flush;
81686 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
81687 0 : std::cout << " not valid " << std::endl;
81688 : }
81689 : }
81690 :
81691 0 : if ( p_endOfConstruct != NULL )
81692 : {
81693 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81694 : {
81695 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
81696 : {
81697 0 : std::cout << "SgOmpTeamsDistributeParallelForStatement :: ";
81698 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
81699 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
81700 : }
81701 : }
81702 : else
81703 : {
81704 0 : std::cout << "SgOmpTeamsDistributeParallelForStatement :: " << std::flush;
81705 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
81706 0 : std::cout << " not valid " << std::endl;
81707 : }
81708 : }
81709 :
81710 0 : if ( p_parent != NULL )
81711 : {
81712 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81713 : {
81714 0 : if ( p_parent->isInMemoryPool() == false )
81715 : {
81716 0 : std::cout << "SgOmpTeamsDistributeParallelForStatement :: ";
81717 0 : std::cout << " p_parent is not in memory pool of ";
81718 0 : std::cout << p_parent->class_name() << std::endl;
81719 : }
81720 : }
81721 : else
81722 : {
81723 0 : std::cout << "SgOmpTeamsDistributeParallelForStatement :: " << std::flush;
81724 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
81725 0 : std::cout << " not valid " << std::endl;
81726 : }
81727 : }
81728 :
81729 :
81730 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
81731 :
81732 0 : }
81733 :
81734 :
81735 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
81736 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
81737 : bool
81738 0 : SgOmpTeamsDistributeParallelForStatement::isInMemoryPool ()
81739 : {
81740 0 : typedef unsigned char* TestType;
81741 :
81742 0 : bool found = false;
81743 :
81744 0 : ROSE_ASSERT(this != NULL);
81745 :
81746 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
81747 :
81748 0 : TestType tested = (TestType) ( this ) ;
81749 :
81750 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTeamsDistributeParallelForStatement::pools.begin();
81751 :
81752 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
81753 : // while (found == false && block < Memory_Block_List.end())
81754 0 : while ( (found == false) && (block != SgOmpTeamsDistributeParallelForStatement::pools.end()) )
81755 : {
81756 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTeamsDistributeParallelForStatement::pool_size * sizeof(SgOmpTeamsDistributeParallelForStatement) ) ) ;
81757 0 : ++block;
81758 : }
81759 :
81760 : // Special handling for static data
81761 :
81762 :
81763 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
81764 0 : ROSE_ASSERT(found == true);
81765 :
81766 0 : return found;
81767 : }
81768 : /* #line 81769 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
81769 :
81770 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
81771 :
81772 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
81773 :
81774 : /* #line 81775 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
81775 :
81776 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
81777 :
81778 : void
81779 0 : SgOmpTeamsDistributeParallelForSimdStatement::checkDataMemberPointersIfInMemoryPool()
81780 : {
81781 : // ------------ checking pointers of SgOmpTeamsDistributeParallelForSimdStatement -------------------
81782 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
81783 :
81784 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
81785 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
81786 : {
81787 0 : if ( (*i_clauses) != NULL )
81788 : {
81789 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81790 : {
81791 0 : if ( (*i_clauses)->isInMemoryPool() == false )
81792 : {
81793 0 : std::cout << "SgOmpTeamsDistributeParallelForSimdStatement :: ";
81794 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
81795 0 : std::cout << (*i_clauses)->class_name() << std::endl;
81796 : }
81797 : }
81798 : else
81799 : {
81800 0 : std::cout << "SgOmpTeamsDistributeParallelForSimdStatement :: " << std::flush;
81801 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
81802 0 : std::cout << " entry not valid " << std::endl;
81803 : }
81804 : }
81805 : else
81806 : {
81807 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
81808 : }
81809 : }
81810 :
81811 0 : if ( p_body != NULL )
81812 : {
81813 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81814 : {
81815 0 : if ( p_body->isInMemoryPool() == false )
81816 : {
81817 0 : std::cout << "SgOmpTeamsDistributeParallelForSimdStatement :: ";
81818 0 : std::cout << " p_body is not in memory pool of ";
81819 0 : std::cout << p_body->class_name() << std::endl;
81820 : }
81821 : }
81822 : else
81823 : {
81824 0 : std::cout << "SgOmpTeamsDistributeParallelForSimdStatement :: " << std::flush;
81825 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
81826 0 : std::cout << " not valid " << std::endl;
81827 : }
81828 : }
81829 :
81830 0 : if ( p_upir_parent != NULL )
81831 : {
81832 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81833 : {
81834 0 : if ( p_upir_parent->isInMemoryPool() == false )
81835 : {
81836 0 : std::cout << "SgOmpTeamsDistributeParallelForSimdStatement :: ";
81837 0 : std::cout << " p_upir_parent is not in memory pool of ";
81838 0 : std::cout << p_upir_parent->class_name() << std::endl;
81839 : }
81840 : }
81841 : else
81842 : {
81843 0 : std::cout << "SgOmpTeamsDistributeParallelForSimdStatement :: " << std::flush;
81844 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
81845 0 : std::cout << " not valid " << std::endl;
81846 : }
81847 : }
81848 :
81849 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
81850 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
81851 : {
81852 0 : if ( (*i_upir_children) != NULL )
81853 : {
81854 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81855 : {
81856 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
81857 : {
81858 0 : std::cout << "SgOmpTeamsDistributeParallelForSimdStatement :: ";
81859 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
81860 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
81861 : }
81862 : }
81863 : else
81864 : {
81865 0 : std::cout << "SgOmpTeamsDistributeParallelForSimdStatement :: " << std::flush;
81866 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
81867 0 : std::cout << " entry not valid " << std::endl;
81868 : }
81869 : }
81870 : else
81871 : {
81872 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
81873 : }
81874 : }
81875 :
81876 0 : if ( p_numeric_label != NULL )
81877 : {
81878 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81879 : {
81880 0 : if ( p_numeric_label->isInMemoryPool() == false )
81881 : {
81882 0 : std::cout << "SgOmpTeamsDistributeParallelForSimdStatement :: ";
81883 0 : std::cout << " p_numeric_label is not in memory pool of ";
81884 0 : std::cout << p_numeric_label->class_name() << std::endl;
81885 : }
81886 : }
81887 : else
81888 : {
81889 0 : std::cout << "SgOmpTeamsDistributeParallelForSimdStatement :: " << std::flush;
81890 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
81891 0 : std::cout << " not valid " << std::endl;
81892 : }
81893 : }
81894 :
81895 0 : if ( p_startOfConstruct != NULL )
81896 : {
81897 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81898 : {
81899 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
81900 : {
81901 0 : std::cout << "SgOmpTeamsDistributeParallelForSimdStatement :: ";
81902 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
81903 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
81904 : }
81905 : }
81906 : else
81907 : {
81908 0 : std::cout << "SgOmpTeamsDistributeParallelForSimdStatement :: " << std::flush;
81909 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
81910 0 : std::cout << " not valid " << std::endl;
81911 : }
81912 : }
81913 :
81914 0 : if ( p_endOfConstruct != NULL )
81915 : {
81916 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81917 : {
81918 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
81919 : {
81920 0 : std::cout << "SgOmpTeamsDistributeParallelForSimdStatement :: ";
81921 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
81922 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
81923 : }
81924 : }
81925 : else
81926 : {
81927 0 : std::cout << "SgOmpTeamsDistributeParallelForSimdStatement :: " << std::flush;
81928 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
81929 0 : std::cout << " not valid " << std::endl;
81930 : }
81931 : }
81932 :
81933 0 : if ( p_parent != NULL )
81934 : {
81935 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
81936 : {
81937 0 : if ( p_parent->isInMemoryPool() == false )
81938 : {
81939 0 : std::cout << "SgOmpTeamsDistributeParallelForSimdStatement :: ";
81940 0 : std::cout << " p_parent is not in memory pool of ";
81941 0 : std::cout << p_parent->class_name() << std::endl;
81942 : }
81943 : }
81944 : else
81945 : {
81946 0 : std::cout << "SgOmpTeamsDistributeParallelForSimdStatement :: " << std::flush;
81947 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
81948 0 : std::cout << " not valid " << std::endl;
81949 : }
81950 : }
81951 :
81952 :
81953 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
81954 :
81955 0 : }
81956 :
81957 :
81958 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
81959 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
81960 : bool
81961 0 : SgOmpTeamsDistributeParallelForSimdStatement::isInMemoryPool ()
81962 : {
81963 0 : typedef unsigned char* TestType;
81964 :
81965 0 : bool found = false;
81966 :
81967 0 : ROSE_ASSERT(this != NULL);
81968 :
81969 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
81970 :
81971 0 : TestType tested = (TestType) ( this ) ;
81972 :
81973 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTeamsDistributeParallelForSimdStatement::pools.begin();
81974 :
81975 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
81976 : // while (found == false && block < Memory_Block_List.end())
81977 0 : while ( (found == false) && (block != SgOmpTeamsDistributeParallelForSimdStatement::pools.end()) )
81978 : {
81979 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTeamsDistributeParallelForSimdStatement::pool_size * sizeof(SgOmpTeamsDistributeParallelForSimdStatement) ) ) ;
81980 0 : ++block;
81981 : }
81982 :
81983 : // Special handling for static data
81984 :
81985 :
81986 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
81987 0 : ROSE_ASSERT(found == true);
81988 :
81989 0 : return found;
81990 : }
81991 : /* #line 81992 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
81992 :
81993 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
81994 :
81995 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
81996 :
81997 : /* #line 81998 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
81998 :
81999 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
82000 :
82001 : void
82002 0 : SgOmpTeamsLoopStatement::checkDataMemberPointersIfInMemoryPool()
82003 : {
82004 : // ------------ checking pointers of SgOmpTeamsLoopStatement -------------------
82005 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
82006 :
82007 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
82008 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
82009 : {
82010 0 : if ( (*i_clauses) != NULL )
82011 : {
82012 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82013 : {
82014 0 : if ( (*i_clauses)->isInMemoryPool() == false )
82015 : {
82016 0 : std::cout << "SgOmpTeamsLoopStatement :: ";
82017 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
82018 0 : std::cout << (*i_clauses)->class_name() << std::endl;
82019 : }
82020 : }
82021 : else
82022 : {
82023 0 : std::cout << "SgOmpTeamsLoopStatement :: " << std::flush;
82024 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
82025 0 : std::cout << " entry not valid " << std::endl;
82026 : }
82027 : }
82028 : else
82029 : {
82030 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
82031 : }
82032 : }
82033 :
82034 0 : if ( p_body != NULL )
82035 : {
82036 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82037 : {
82038 0 : if ( p_body->isInMemoryPool() == false )
82039 : {
82040 0 : std::cout << "SgOmpTeamsLoopStatement :: ";
82041 0 : std::cout << " p_body is not in memory pool of ";
82042 0 : std::cout << p_body->class_name() << std::endl;
82043 : }
82044 : }
82045 : else
82046 : {
82047 0 : std::cout << "SgOmpTeamsLoopStatement :: " << std::flush;
82048 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
82049 0 : std::cout << " not valid " << std::endl;
82050 : }
82051 : }
82052 :
82053 0 : if ( p_upir_parent != NULL )
82054 : {
82055 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82056 : {
82057 0 : if ( p_upir_parent->isInMemoryPool() == false )
82058 : {
82059 0 : std::cout << "SgOmpTeamsLoopStatement :: ";
82060 0 : std::cout << " p_upir_parent is not in memory pool of ";
82061 0 : std::cout << p_upir_parent->class_name() << std::endl;
82062 : }
82063 : }
82064 : else
82065 : {
82066 0 : std::cout << "SgOmpTeamsLoopStatement :: " << std::flush;
82067 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
82068 0 : std::cout << " not valid " << std::endl;
82069 : }
82070 : }
82071 :
82072 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
82073 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
82074 : {
82075 0 : if ( (*i_upir_children) != NULL )
82076 : {
82077 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82078 : {
82079 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
82080 : {
82081 0 : std::cout << "SgOmpTeamsLoopStatement :: ";
82082 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
82083 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
82084 : }
82085 : }
82086 : else
82087 : {
82088 0 : std::cout << "SgOmpTeamsLoopStatement :: " << std::flush;
82089 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
82090 0 : std::cout << " entry not valid " << std::endl;
82091 : }
82092 : }
82093 : else
82094 : {
82095 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
82096 : }
82097 : }
82098 :
82099 0 : if ( p_numeric_label != NULL )
82100 : {
82101 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82102 : {
82103 0 : if ( p_numeric_label->isInMemoryPool() == false )
82104 : {
82105 0 : std::cout << "SgOmpTeamsLoopStatement :: ";
82106 0 : std::cout << " p_numeric_label is not in memory pool of ";
82107 0 : std::cout << p_numeric_label->class_name() << std::endl;
82108 : }
82109 : }
82110 : else
82111 : {
82112 0 : std::cout << "SgOmpTeamsLoopStatement :: " << std::flush;
82113 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
82114 0 : std::cout << " not valid " << std::endl;
82115 : }
82116 : }
82117 :
82118 0 : if ( p_startOfConstruct != NULL )
82119 : {
82120 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82121 : {
82122 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
82123 : {
82124 0 : std::cout << "SgOmpTeamsLoopStatement :: ";
82125 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
82126 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
82127 : }
82128 : }
82129 : else
82130 : {
82131 0 : std::cout << "SgOmpTeamsLoopStatement :: " << std::flush;
82132 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
82133 0 : std::cout << " not valid " << std::endl;
82134 : }
82135 : }
82136 :
82137 0 : if ( p_endOfConstruct != NULL )
82138 : {
82139 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82140 : {
82141 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
82142 : {
82143 0 : std::cout << "SgOmpTeamsLoopStatement :: ";
82144 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
82145 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
82146 : }
82147 : }
82148 : else
82149 : {
82150 0 : std::cout << "SgOmpTeamsLoopStatement :: " << std::flush;
82151 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
82152 0 : std::cout << " not valid " << std::endl;
82153 : }
82154 : }
82155 :
82156 0 : if ( p_parent != NULL )
82157 : {
82158 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82159 : {
82160 0 : if ( p_parent->isInMemoryPool() == false )
82161 : {
82162 0 : std::cout << "SgOmpTeamsLoopStatement :: ";
82163 0 : std::cout << " p_parent is not in memory pool of ";
82164 0 : std::cout << p_parent->class_name() << std::endl;
82165 : }
82166 : }
82167 : else
82168 : {
82169 0 : std::cout << "SgOmpTeamsLoopStatement :: " << std::flush;
82170 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
82171 0 : std::cout << " not valid " << std::endl;
82172 : }
82173 : }
82174 :
82175 :
82176 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
82177 :
82178 0 : }
82179 :
82180 :
82181 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
82182 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
82183 : bool
82184 0 : SgOmpTeamsLoopStatement::isInMemoryPool ()
82185 : {
82186 0 : typedef unsigned char* TestType;
82187 :
82188 0 : bool found = false;
82189 :
82190 0 : ROSE_ASSERT(this != NULL);
82191 :
82192 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
82193 :
82194 0 : TestType tested = (TestType) ( this ) ;
82195 :
82196 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTeamsLoopStatement::pools.begin();
82197 :
82198 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
82199 : // while (found == false && block < Memory_Block_List.end())
82200 0 : while ( (found == false) && (block != SgOmpTeamsLoopStatement::pools.end()) )
82201 : {
82202 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTeamsLoopStatement::pool_size * sizeof(SgOmpTeamsLoopStatement) ) ) ;
82203 0 : ++block;
82204 : }
82205 :
82206 : // Special handling for static data
82207 :
82208 :
82209 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
82210 0 : ROSE_ASSERT(found == true);
82211 :
82212 0 : return found;
82213 : }
82214 : /* #line 82215 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
82215 :
82216 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
82217 :
82218 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
82219 :
82220 : /* #line 82221 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
82221 :
82222 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
82223 :
82224 : void
82225 0 : SgOmpForSimdStatement::checkDataMemberPointersIfInMemoryPool()
82226 : {
82227 : // ------------ checking pointers of SgOmpForSimdStatement -------------------
82228 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
82229 :
82230 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
82231 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
82232 : {
82233 0 : if ( (*i_clauses) != NULL )
82234 : {
82235 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82236 : {
82237 0 : if ( (*i_clauses)->isInMemoryPool() == false )
82238 : {
82239 0 : std::cout << "SgOmpForSimdStatement :: ";
82240 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
82241 0 : std::cout << (*i_clauses)->class_name() << std::endl;
82242 : }
82243 : }
82244 : else
82245 : {
82246 0 : std::cout << "SgOmpForSimdStatement :: " << std::flush;
82247 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
82248 0 : std::cout << " entry not valid " << std::endl;
82249 : }
82250 : }
82251 : else
82252 : {
82253 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
82254 : }
82255 : }
82256 :
82257 0 : if ( p_body != NULL )
82258 : {
82259 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82260 : {
82261 0 : if ( p_body->isInMemoryPool() == false )
82262 : {
82263 0 : std::cout << "SgOmpForSimdStatement :: ";
82264 0 : std::cout << " p_body is not in memory pool of ";
82265 0 : std::cout << p_body->class_name() << std::endl;
82266 : }
82267 : }
82268 : else
82269 : {
82270 0 : std::cout << "SgOmpForSimdStatement :: " << std::flush;
82271 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
82272 0 : std::cout << " not valid " << std::endl;
82273 : }
82274 : }
82275 :
82276 0 : if ( p_upir_parent != NULL )
82277 : {
82278 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82279 : {
82280 0 : if ( p_upir_parent->isInMemoryPool() == false )
82281 : {
82282 0 : std::cout << "SgOmpForSimdStatement :: ";
82283 0 : std::cout << " p_upir_parent is not in memory pool of ";
82284 0 : std::cout << p_upir_parent->class_name() << std::endl;
82285 : }
82286 : }
82287 : else
82288 : {
82289 0 : std::cout << "SgOmpForSimdStatement :: " << std::flush;
82290 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
82291 0 : std::cout << " not valid " << std::endl;
82292 : }
82293 : }
82294 :
82295 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
82296 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
82297 : {
82298 0 : if ( (*i_upir_children) != NULL )
82299 : {
82300 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82301 : {
82302 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
82303 : {
82304 0 : std::cout << "SgOmpForSimdStatement :: ";
82305 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
82306 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
82307 : }
82308 : }
82309 : else
82310 : {
82311 0 : std::cout << "SgOmpForSimdStatement :: " << std::flush;
82312 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
82313 0 : std::cout << " entry not valid " << std::endl;
82314 : }
82315 : }
82316 : else
82317 : {
82318 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
82319 : }
82320 : }
82321 :
82322 0 : if ( p_numeric_label != NULL )
82323 : {
82324 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82325 : {
82326 0 : if ( p_numeric_label->isInMemoryPool() == false )
82327 : {
82328 0 : std::cout << "SgOmpForSimdStatement :: ";
82329 0 : std::cout << " p_numeric_label is not in memory pool of ";
82330 0 : std::cout << p_numeric_label->class_name() << std::endl;
82331 : }
82332 : }
82333 : else
82334 : {
82335 0 : std::cout << "SgOmpForSimdStatement :: " << std::flush;
82336 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
82337 0 : std::cout << " not valid " << std::endl;
82338 : }
82339 : }
82340 :
82341 0 : if ( p_startOfConstruct != NULL )
82342 : {
82343 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82344 : {
82345 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
82346 : {
82347 0 : std::cout << "SgOmpForSimdStatement :: ";
82348 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
82349 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
82350 : }
82351 : }
82352 : else
82353 : {
82354 0 : std::cout << "SgOmpForSimdStatement :: " << std::flush;
82355 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
82356 0 : std::cout << " not valid " << std::endl;
82357 : }
82358 : }
82359 :
82360 0 : if ( p_endOfConstruct != NULL )
82361 : {
82362 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82363 : {
82364 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
82365 : {
82366 0 : std::cout << "SgOmpForSimdStatement :: ";
82367 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
82368 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
82369 : }
82370 : }
82371 : else
82372 : {
82373 0 : std::cout << "SgOmpForSimdStatement :: " << std::flush;
82374 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
82375 0 : std::cout << " not valid " << std::endl;
82376 : }
82377 : }
82378 :
82379 0 : if ( p_parent != NULL )
82380 : {
82381 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82382 : {
82383 0 : if ( p_parent->isInMemoryPool() == false )
82384 : {
82385 0 : std::cout << "SgOmpForSimdStatement :: ";
82386 0 : std::cout << " p_parent is not in memory pool of ";
82387 0 : std::cout << p_parent->class_name() << std::endl;
82388 : }
82389 : }
82390 : else
82391 : {
82392 0 : std::cout << "SgOmpForSimdStatement :: " << std::flush;
82393 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
82394 0 : std::cout << " not valid " << std::endl;
82395 : }
82396 : }
82397 :
82398 :
82399 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
82400 :
82401 0 : }
82402 :
82403 :
82404 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
82405 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
82406 : bool
82407 0 : SgOmpForSimdStatement::isInMemoryPool ()
82408 : {
82409 0 : typedef unsigned char* TestType;
82410 :
82411 0 : bool found = false;
82412 :
82413 0 : ROSE_ASSERT(this != NULL);
82414 :
82415 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
82416 :
82417 0 : TestType tested = (TestType) ( this ) ;
82418 :
82419 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpForSimdStatement::pools.begin();
82420 :
82421 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
82422 : // while (found == false && block < Memory_Block_List.end())
82423 0 : while ( (found == false) && (block != SgOmpForSimdStatement::pools.end()) )
82424 : {
82425 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpForSimdStatement::pool_size * sizeof(SgOmpForSimdStatement) ) ) ;
82426 0 : ++block;
82427 : }
82428 :
82429 : // Special handling for static data
82430 :
82431 :
82432 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
82433 0 : ROSE_ASSERT(found == true);
82434 :
82435 0 : return found;
82436 : }
82437 : /* #line 82438 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
82438 :
82439 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
82440 :
82441 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
82442 :
82443 : /* #line 82444 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
82444 :
82445 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
82446 :
82447 : void
82448 0 : SgOmpCriticalStatement::checkDataMemberPointersIfInMemoryPool()
82449 : {
82450 : // ------------ checking pointers of SgOmpCriticalStatement -------------------
82451 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
82452 :
82453 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
82454 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
82455 : {
82456 0 : if ( (*i_clauses) != NULL )
82457 : {
82458 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82459 : {
82460 0 : if ( (*i_clauses)->isInMemoryPool() == false )
82461 : {
82462 0 : std::cout << "SgOmpCriticalStatement :: ";
82463 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
82464 0 : std::cout << (*i_clauses)->class_name() << std::endl;
82465 : }
82466 : }
82467 : else
82468 : {
82469 0 : std::cout << "SgOmpCriticalStatement :: " << std::flush;
82470 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
82471 0 : std::cout << " entry not valid " << std::endl;
82472 : }
82473 : }
82474 : else
82475 : {
82476 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
82477 : }
82478 : }
82479 :
82480 0 : if ( p_body != NULL )
82481 : {
82482 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82483 : {
82484 0 : if ( p_body->isInMemoryPool() == false )
82485 : {
82486 0 : std::cout << "SgOmpCriticalStatement :: ";
82487 0 : std::cout << " p_body is not in memory pool of ";
82488 0 : std::cout << p_body->class_name() << std::endl;
82489 : }
82490 : }
82491 : else
82492 : {
82493 0 : std::cout << "SgOmpCriticalStatement :: " << std::flush;
82494 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
82495 0 : std::cout << " not valid " << std::endl;
82496 : }
82497 : }
82498 :
82499 0 : if ( p_upir_parent != NULL )
82500 : {
82501 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82502 : {
82503 0 : if ( p_upir_parent->isInMemoryPool() == false )
82504 : {
82505 0 : std::cout << "SgOmpCriticalStatement :: ";
82506 0 : std::cout << " p_upir_parent is not in memory pool of ";
82507 0 : std::cout << p_upir_parent->class_name() << std::endl;
82508 : }
82509 : }
82510 : else
82511 : {
82512 0 : std::cout << "SgOmpCriticalStatement :: " << std::flush;
82513 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
82514 0 : std::cout << " not valid " << std::endl;
82515 : }
82516 : }
82517 :
82518 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
82519 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
82520 : {
82521 0 : if ( (*i_upir_children) != NULL )
82522 : {
82523 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82524 : {
82525 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
82526 : {
82527 0 : std::cout << "SgOmpCriticalStatement :: ";
82528 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
82529 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
82530 : }
82531 : }
82532 : else
82533 : {
82534 0 : std::cout << "SgOmpCriticalStatement :: " << std::flush;
82535 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
82536 0 : std::cout << " entry not valid " << std::endl;
82537 : }
82538 : }
82539 : else
82540 : {
82541 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
82542 : }
82543 : }
82544 :
82545 0 : if ( p_numeric_label != NULL )
82546 : {
82547 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82548 : {
82549 0 : if ( p_numeric_label->isInMemoryPool() == false )
82550 : {
82551 0 : std::cout << "SgOmpCriticalStatement :: ";
82552 0 : std::cout << " p_numeric_label is not in memory pool of ";
82553 0 : std::cout << p_numeric_label->class_name() << std::endl;
82554 : }
82555 : }
82556 : else
82557 : {
82558 0 : std::cout << "SgOmpCriticalStatement :: " << std::flush;
82559 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
82560 0 : std::cout << " not valid " << std::endl;
82561 : }
82562 : }
82563 :
82564 0 : if ( p_startOfConstruct != NULL )
82565 : {
82566 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82567 : {
82568 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
82569 : {
82570 0 : std::cout << "SgOmpCriticalStatement :: ";
82571 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
82572 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
82573 : }
82574 : }
82575 : else
82576 : {
82577 0 : std::cout << "SgOmpCriticalStatement :: " << std::flush;
82578 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
82579 0 : std::cout << " not valid " << std::endl;
82580 : }
82581 : }
82582 :
82583 0 : if ( p_endOfConstruct != NULL )
82584 : {
82585 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82586 : {
82587 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
82588 : {
82589 0 : std::cout << "SgOmpCriticalStatement :: ";
82590 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
82591 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
82592 : }
82593 : }
82594 : else
82595 : {
82596 0 : std::cout << "SgOmpCriticalStatement :: " << std::flush;
82597 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
82598 0 : std::cout << " not valid " << std::endl;
82599 : }
82600 : }
82601 :
82602 0 : if ( p_parent != NULL )
82603 : {
82604 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82605 : {
82606 0 : if ( p_parent->isInMemoryPool() == false )
82607 : {
82608 0 : std::cout << "SgOmpCriticalStatement :: ";
82609 0 : std::cout << " p_parent is not in memory pool of ";
82610 0 : std::cout << p_parent->class_name() << std::endl;
82611 : }
82612 : }
82613 : else
82614 : {
82615 0 : std::cout << "SgOmpCriticalStatement :: " << std::flush;
82616 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
82617 0 : std::cout << " not valid " << std::endl;
82618 : }
82619 : }
82620 :
82621 :
82622 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
82623 :
82624 0 : }
82625 :
82626 :
82627 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
82628 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
82629 : bool
82630 0 : SgOmpCriticalStatement::isInMemoryPool ()
82631 : {
82632 0 : typedef unsigned char* TestType;
82633 :
82634 0 : bool found = false;
82635 :
82636 0 : ROSE_ASSERT(this != NULL);
82637 :
82638 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
82639 :
82640 0 : TestType tested = (TestType) ( this ) ;
82641 :
82642 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpCriticalStatement::pools.begin();
82643 :
82644 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
82645 : // while (found == false && block < Memory_Block_List.end())
82646 0 : while ( (found == false) && (block != SgOmpCriticalStatement::pools.end()) )
82647 : {
82648 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpCriticalStatement::pool_size * sizeof(SgOmpCriticalStatement) ) ) ;
82649 0 : ++block;
82650 : }
82651 :
82652 : // Special handling for static data
82653 :
82654 :
82655 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
82656 0 : ROSE_ASSERT(found == true);
82657 :
82658 0 : return found;
82659 : }
82660 : /* #line 82661 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
82661 :
82662 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
82663 :
82664 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
82665 :
82666 : /* #line 82667 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
82667 :
82668 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
82669 :
82670 : void
82671 0 : SgOmpDistributeStatement::checkDataMemberPointersIfInMemoryPool()
82672 : {
82673 : // ------------ checking pointers of SgOmpDistributeStatement -------------------
82674 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
82675 :
82676 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
82677 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
82678 : {
82679 0 : if ( (*i_clauses) != NULL )
82680 : {
82681 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82682 : {
82683 0 : if ( (*i_clauses)->isInMemoryPool() == false )
82684 : {
82685 0 : std::cout << "SgOmpDistributeStatement :: ";
82686 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
82687 0 : std::cout << (*i_clauses)->class_name() << std::endl;
82688 : }
82689 : }
82690 : else
82691 : {
82692 0 : std::cout << "SgOmpDistributeStatement :: " << std::flush;
82693 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
82694 0 : std::cout << " entry not valid " << std::endl;
82695 : }
82696 : }
82697 : else
82698 : {
82699 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
82700 : }
82701 : }
82702 :
82703 0 : if ( p_body != NULL )
82704 : {
82705 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82706 : {
82707 0 : if ( p_body->isInMemoryPool() == false )
82708 : {
82709 0 : std::cout << "SgOmpDistributeStatement :: ";
82710 0 : std::cout << " p_body is not in memory pool of ";
82711 0 : std::cout << p_body->class_name() << std::endl;
82712 : }
82713 : }
82714 : else
82715 : {
82716 0 : std::cout << "SgOmpDistributeStatement :: " << std::flush;
82717 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
82718 0 : std::cout << " not valid " << std::endl;
82719 : }
82720 : }
82721 :
82722 0 : if ( p_upir_parent != NULL )
82723 : {
82724 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82725 : {
82726 0 : if ( p_upir_parent->isInMemoryPool() == false )
82727 : {
82728 0 : std::cout << "SgOmpDistributeStatement :: ";
82729 0 : std::cout << " p_upir_parent is not in memory pool of ";
82730 0 : std::cout << p_upir_parent->class_name() << std::endl;
82731 : }
82732 : }
82733 : else
82734 : {
82735 0 : std::cout << "SgOmpDistributeStatement :: " << std::flush;
82736 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
82737 0 : std::cout << " not valid " << std::endl;
82738 : }
82739 : }
82740 :
82741 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
82742 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
82743 : {
82744 0 : if ( (*i_upir_children) != NULL )
82745 : {
82746 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82747 : {
82748 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
82749 : {
82750 0 : std::cout << "SgOmpDistributeStatement :: ";
82751 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
82752 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
82753 : }
82754 : }
82755 : else
82756 : {
82757 0 : std::cout << "SgOmpDistributeStatement :: " << std::flush;
82758 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
82759 0 : std::cout << " entry not valid " << std::endl;
82760 : }
82761 : }
82762 : else
82763 : {
82764 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
82765 : }
82766 : }
82767 :
82768 0 : if ( p_numeric_label != NULL )
82769 : {
82770 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82771 : {
82772 0 : if ( p_numeric_label->isInMemoryPool() == false )
82773 : {
82774 0 : std::cout << "SgOmpDistributeStatement :: ";
82775 0 : std::cout << " p_numeric_label is not in memory pool of ";
82776 0 : std::cout << p_numeric_label->class_name() << std::endl;
82777 : }
82778 : }
82779 : else
82780 : {
82781 0 : std::cout << "SgOmpDistributeStatement :: " << std::flush;
82782 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
82783 0 : std::cout << " not valid " << std::endl;
82784 : }
82785 : }
82786 :
82787 0 : if ( p_startOfConstruct != NULL )
82788 : {
82789 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82790 : {
82791 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
82792 : {
82793 0 : std::cout << "SgOmpDistributeStatement :: ";
82794 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
82795 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
82796 : }
82797 : }
82798 : else
82799 : {
82800 0 : std::cout << "SgOmpDistributeStatement :: " << std::flush;
82801 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
82802 0 : std::cout << " not valid " << std::endl;
82803 : }
82804 : }
82805 :
82806 0 : if ( p_endOfConstruct != NULL )
82807 : {
82808 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82809 : {
82810 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
82811 : {
82812 0 : std::cout << "SgOmpDistributeStatement :: ";
82813 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
82814 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
82815 : }
82816 : }
82817 : else
82818 : {
82819 0 : std::cout << "SgOmpDistributeStatement :: " << std::flush;
82820 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
82821 0 : std::cout << " not valid " << std::endl;
82822 : }
82823 : }
82824 :
82825 0 : if ( p_parent != NULL )
82826 : {
82827 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82828 : {
82829 0 : if ( p_parent->isInMemoryPool() == false )
82830 : {
82831 0 : std::cout << "SgOmpDistributeStatement :: ";
82832 0 : std::cout << " p_parent is not in memory pool of ";
82833 0 : std::cout << p_parent->class_name() << std::endl;
82834 : }
82835 : }
82836 : else
82837 : {
82838 0 : std::cout << "SgOmpDistributeStatement :: " << std::flush;
82839 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
82840 0 : std::cout << " not valid " << std::endl;
82841 : }
82842 : }
82843 :
82844 :
82845 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
82846 :
82847 0 : }
82848 :
82849 :
82850 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
82851 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
82852 : bool
82853 0 : SgOmpDistributeStatement::isInMemoryPool ()
82854 : {
82855 0 : typedef unsigned char* TestType;
82856 :
82857 0 : bool found = false;
82858 :
82859 0 : ROSE_ASSERT(this != NULL);
82860 :
82861 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
82862 :
82863 0 : TestType tested = (TestType) ( this ) ;
82864 :
82865 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDistributeStatement::pools.begin();
82866 :
82867 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
82868 : // while (found == false && block < Memory_Block_List.end())
82869 0 : while ( (found == false) && (block != SgOmpDistributeStatement::pools.end()) )
82870 : {
82871 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDistributeStatement::pool_size * sizeof(SgOmpDistributeStatement) ) ) ;
82872 0 : ++block;
82873 : }
82874 :
82875 : // Special handling for static data
82876 :
82877 :
82878 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
82879 0 : ROSE_ASSERT(found == true);
82880 :
82881 0 : return found;
82882 : }
82883 : /* #line 82884 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
82884 :
82885 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
82886 :
82887 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
82888 :
82889 : /* #line 82890 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
82890 :
82891 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
82892 :
82893 : void
82894 0 : SgOmpUnrollStatement::checkDataMemberPointersIfInMemoryPool()
82895 : {
82896 : // ------------ checking pointers of SgOmpUnrollStatement -------------------
82897 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
82898 :
82899 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
82900 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
82901 : {
82902 0 : if ( (*i_clauses) != NULL )
82903 : {
82904 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82905 : {
82906 0 : if ( (*i_clauses)->isInMemoryPool() == false )
82907 : {
82908 0 : std::cout << "SgOmpUnrollStatement :: ";
82909 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
82910 0 : std::cout << (*i_clauses)->class_name() << std::endl;
82911 : }
82912 : }
82913 : else
82914 : {
82915 0 : std::cout << "SgOmpUnrollStatement :: " << std::flush;
82916 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
82917 0 : std::cout << " entry not valid " << std::endl;
82918 : }
82919 : }
82920 : else
82921 : {
82922 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
82923 : }
82924 : }
82925 :
82926 0 : if ( p_body != NULL )
82927 : {
82928 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82929 : {
82930 0 : if ( p_body->isInMemoryPool() == false )
82931 : {
82932 0 : std::cout << "SgOmpUnrollStatement :: ";
82933 0 : std::cout << " p_body is not in memory pool of ";
82934 0 : std::cout << p_body->class_name() << std::endl;
82935 : }
82936 : }
82937 : else
82938 : {
82939 0 : std::cout << "SgOmpUnrollStatement :: " << std::flush;
82940 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
82941 0 : std::cout << " not valid " << std::endl;
82942 : }
82943 : }
82944 :
82945 0 : if ( p_upir_parent != NULL )
82946 : {
82947 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82948 : {
82949 0 : if ( p_upir_parent->isInMemoryPool() == false )
82950 : {
82951 0 : std::cout << "SgOmpUnrollStatement :: ";
82952 0 : std::cout << " p_upir_parent is not in memory pool of ";
82953 0 : std::cout << p_upir_parent->class_name() << std::endl;
82954 : }
82955 : }
82956 : else
82957 : {
82958 0 : std::cout << "SgOmpUnrollStatement :: " << std::flush;
82959 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
82960 0 : std::cout << " not valid " << std::endl;
82961 : }
82962 : }
82963 :
82964 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
82965 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
82966 : {
82967 0 : if ( (*i_upir_children) != NULL )
82968 : {
82969 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82970 : {
82971 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
82972 : {
82973 0 : std::cout << "SgOmpUnrollStatement :: ";
82974 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
82975 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
82976 : }
82977 : }
82978 : else
82979 : {
82980 0 : std::cout << "SgOmpUnrollStatement :: " << std::flush;
82981 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
82982 0 : std::cout << " entry not valid " << std::endl;
82983 : }
82984 : }
82985 : else
82986 : {
82987 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
82988 : }
82989 : }
82990 :
82991 0 : if ( p_numeric_label != NULL )
82992 : {
82993 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
82994 : {
82995 0 : if ( p_numeric_label->isInMemoryPool() == false )
82996 : {
82997 0 : std::cout << "SgOmpUnrollStatement :: ";
82998 0 : std::cout << " p_numeric_label is not in memory pool of ";
82999 0 : std::cout << p_numeric_label->class_name() << std::endl;
83000 : }
83001 : }
83002 : else
83003 : {
83004 0 : std::cout << "SgOmpUnrollStatement :: " << std::flush;
83005 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
83006 0 : std::cout << " not valid " << std::endl;
83007 : }
83008 : }
83009 :
83010 0 : if ( p_startOfConstruct != NULL )
83011 : {
83012 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83013 : {
83014 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
83015 : {
83016 0 : std::cout << "SgOmpUnrollStatement :: ";
83017 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
83018 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
83019 : }
83020 : }
83021 : else
83022 : {
83023 0 : std::cout << "SgOmpUnrollStatement :: " << std::flush;
83024 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
83025 0 : std::cout << " not valid " << std::endl;
83026 : }
83027 : }
83028 :
83029 0 : if ( p_endOfConstruct != NULL )
83030 : {
83031 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83032 : {
83033 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
83034 : {
83035 0 : std::cout << "SgOmpUnrollStatement :: ";
83036 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
83037 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
83038 : }
83039 : }
83040 : else
83041 : {
83042 0 : std::cout << "SgOmpUnrollStatement :: " << std::flush;
83043 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
83044 0 : std::cout << " not valid " << std::endl;
83045 : }
83046 : }
83047 :
83048 0 : if ( p_parent != NULL )
83049 : {
83050 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83051 : {
83052 0 : if ( p_parent->isInMemoryPool() == false )
83053 : {
83054 0 : std::cout << "SgOmpUnrollStatement :: ";
83055 0 : std::cout << " p_parent is not in memory pool of ";
83056 0 : std::cout << p_parent->class_name() << std::endl;
83057 : }
83058 : }
83059 : else
83060 : {
83061 0 : std::cout << "SgOmpUnrollStatement :: " << std::flush;
83062 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
83063 0 : std::cout << " not valid " << std::endl;
83064 : }
83065 : }
83066 :
83067 :
83068 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
83069 :
83070 0 : }
83071 :
83072 :
83073 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
83074 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
83075 : bool
83076 0 : SgOmpUnrollStatement::isInMemoryPool ()
83077 : {
83078 0 : typedef unsigned char* TestType;
83079 :
83080 0 : bool found = false;
83081 :
83082 0 : ROSE_ASSERT(this != NULL);
83083 :
83084 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
83085 :
83086 0 : TestType tested = (TestType) ( this ) ;
83087 :
83088 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpUnrollStatement::pools.begin();
83089 :
83090 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
83091 : // while (found == false && block < Memory_Block_List.end())
83092 0 : while ( (found == false) && (block != SgOmpUnrollStatement::pools.end()) )
83093 : {
83094 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpUnrollStatement::pool_size * sizeof(SgOmpUnrollStatement) ) ) ;
83095 0 : ++block;
83096 : }
83097 :
83098 : // Special handling for static data
83099 :
83100 :
83101 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
83102 0 : ROSE_ASSERT(found == true);
83103 :
83104 0 : return found;
83105 : }
83106 : /* #line 83107 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
83107 :
83108 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
83109 :
83110 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
83111 :
83112 : /* #line 83113 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
83113 :
83114 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
83115 :
83116 : void
83117 0 : SgOmpTileStatement::checkDataMemberPointersIfInMemoryPool()
83118 : {
83119 : // ------------ checking pointers of SgOmpTileStatement -------------------
83120 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
83121 :
83122 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
83123 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
83124 : {
83125 0 : if ( (*i_clauses) != NULL )
83126 : {
83127 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83128 : {
83129 0 : if ( (*i_clauses)->isInMemoryPool() == false )
83130 : {
83131 0 : std::cout << "SgOmpTileStatement :: ";
83132 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
83133 0 : std::cout << (*i_clauses)->class_name() << std::endl;
83134 : }
83135 : }
83136 : else
83137 : {
83138 0 : std::cout << "SgOmpTileStatement :: " << std::flush;
83139 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
83140 0 : std::cout << " entry not valid " << std::endl;
83141 : }
83142 : }
83143 : else
83144 : {
83145 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
83146 : }
83147 : }
83148 :
83149 0 : if ( p_body != NULL )
83150 : {
83151 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83152 : {
83153 0 : if ( p_body->isInMemoryPool() == false )
83154 : {
83155 0 : std::cout << "SgOmpTileStatement :: ";
83156 0 : std::cout << " p_body is not in memory pool of ";
83157 0 : std::cout << p_body->class_name() << std::endl;
83158 : }
83159 : }
83160 : else
83161 : {
83162 0 : std::cout << "SgOmpTileStatement :: " << std::flush;
83163 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
83164 0 : std::cout << " not valid " << std::endl;
83165 : }
83166 : }
83167 :
83168 0 : if ( p_upir_parent != NULL )
83169 : {
83170 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83171 : {
83172 0 : if ( p_upir_parent->isInMemoryPool() == false )
83173 : {
83174 0 : std::cout << "SgOmpTileStatement :: ";
83175 0 : std::cout << " p_upir_parent is not in memory pool of ";
83176 0 : std::cout << p_upir_parent->class_name() << std::endl;
83177 : }
83178 : }
83179 : else
83180 : {
83181 0 : std::cout << "SgOmpTileStatement :: " << std::flush;
83182 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
83183 0 : std::cout << " not valid " << std::endl;
83184 : }
83185 : }
83186 :
83187 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
83188 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
83189 : {
83190 0 : if ( (*i_upir_children) != NULL )
83191 : {
83192 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83193 : {
83194 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
83195 : {
83196 0 : std::cout << "SgOmpTileStatement :: ";
83197 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
83198 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
83199 : }
83200 : }
83201 : else
83202 : {
83203 0 : std::cout << "SgOmpTileStatement :: " << std::flush;
83204 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
83205 0 : std::cout << " entry not valid " << std::endl;
83206 : }
83207 : }
83208 : else
83209 : {
83210 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
83211 : }
83212 : }
83213 :
83214 0 : if ( p_numeric_label != NULL )
83215 : {
83216 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83217 : {
83218 0 : if ( p_numeric_label->isInMemoryPool() == false )
83219 : {
83220 0 : std::cout << "SgOmpTileStatement :: ";
83221 0 : std::cout << " p_numeric_label is not in memory pool of ";
83222 0 : std::cout << p_numeric_label->class_name() << std::endl;
83223 : }
83224 : }
83225 : else
83226 : {
83227 0 : std::cout << "SgOmpTileStatement :: " << std::flush;
83228 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
83229 0 : std::cout << " not valid " << std::endl;
83230 : }
83231 : }
83232 :
83233 0 : if ( p_startOfConstruct != NULL )
83234 : {
83235 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83236 : {
83237 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
83238 : {
83239 0 : std::cout << "SgOmpTileStatement :: ";
83240 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
83241 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
83242 : }
83243 : }
83244 : else
83245 : {
83246 0 : std::cout << "SgOmpTileStatement :: " << std::flush;
83247 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
83248 0 : std::cout << " not valid " << std::endl;
83249 : }
83250 : }
83251 :
83252 0 : if ( p_endOfConstruct != NULL )
83253 : {
83254 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83255 : {
83256 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
83257 : {
83258 0 : std::cout << "SgOmpTileStatement :: ";
83259 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
83260 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
83261 : }
83262 : }
83263 : else
83264 : {
83265 0 : std::cout << "SgOmpTileStatement :: " << std::flush;
83266 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
83267 0 : std::cout << " not valid " << std::endl;
83268 : }
83269 : }
83270 :
83271 0 : if ( p_parent != NULL )
83272 : {
83273 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83274 : {
83275 0 : if ( p_parent->isInMemoryPool() == false )
83276 : {
83277 0 : std::cout << "SgOmpTileStatement :: ";
83278 0 : std::cout << " p_parent is not in memory pool of ";
83279 0 : std::cout << p_parent->class_name() << std::endl;
83280 : }
83281 : }
83282 : else
83283 : {
83284 0 : std::cout << "SgOmpTileStatement :: " << std::flush;
83285 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
83286 0 : std::cout << " not valid " << std::endl;
83287 : }
83288 : }
83289 :
83290 :
83291 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
83292 :
83293 0 : }
83294 :
83295 :
83296 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
83297 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
83298 : bool
83299 0 : SgOmpTileStatement::isInMemoryPool ()
83300 : {
83301 0 : typedef unsigned char* TestType;
83302 :
83303 0 : bool found = false;
83304 :
83305 0 : ROSE_ASSERT(this != NULL);
83306 :
83307 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
83308 :
83309 0 : TestType tested = (TestType) ( this ) ;
83310 :
83311 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTileStatement::pools.begin();
83312 :
83313 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
83314 : // while (found == false && block < Memory_Block_List.end())
83315 0 : while ( (found == false) && (block != SgOmpTileStatement::pools.end()) )
83316 : {
83317 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTileStatement::pool_size * sizeof(SgOmpTileStatement) ) ) ;
83318 0 : ++block;
83319 : }
83320 :
83321 : // Special handling for static data
83322 :
83323 :
83324 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
83325 0 : ROSE_ASSERT(found == true);
83326 :
83327 0 : return found;
83328 : }
83329 : /* #line 83330 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
83330 :
83331 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
83332 :
83333 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
83334 :
83335 : /* #line 83336 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
83336 :
83337 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
83338 :
83339 : void
83340 0 : SgUpirLoopStatement::checkDataMemberPointersIfInMemoryPool()
83341 : {
83342 : // ------------ checking pointers of SgUpirLoopStatement -------------------
83343 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
83344 :
83345 0 : if ( p_induction != NULL )
83346 : {
83347 0 : if ( p_induction->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83348 : {
83349 0 : if ( p_induction->isInMemoryPool() == false )
83350 : {
83351 0 : std::cout << "SgUpirLoopStatement :: ";
83352 0 : std::cout << " p_induction is not in memory pool of ";
83353 0 : std::cout << p_induction->class_name() << std::endl;
83354 : }
83355 : }
83356 : else
83357 : {
83358 0 : std::cout << "SgUpirLoopStatement :: " << std::flush;
83359 0 : std::cout << "SgInitializedName* p_induction = " << p_induction << " --> " << std::flush;
83360 0 : std::cout << " not valid " << std::endl;
83361 : }
83362 : }
83363 :
83364 0 : if ( p_lower_bound != NULL )
83365 : {
83366 0 : if ( p_lower_bound->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83367 : {
83368 0 : if ( p_lower_bound->isInMemoryPool() == false )
83369 : {
83370 0 : std::cout << "SgUpirLoopStatement :: ";
83371 0 : std::cout << " p_lower_bound is not in memory pool of ";
83372 0 : std::cout << p_lower_bound->class_name() << std::endl;
83373 : }
83374 : }
83375 : else
83376 : {
83377 0 : std::cout << "SgUpirLoopStatement :: " << std::flush;
83378 0 : std::cout << "SgExpression* p_lower_bound = " << p_lower_bound << " --> " << std::flush;
83379 0 : std::cout << " not valid " << std::endl;
83380 : }
83381 : }
83382 :
83383 0 : if ( p_upper_bound != NULL )
83384 : {
83385 0 : if ( p_upper_bound->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83386 : {
83387 0 : if ( p_upper_bound->isInMemoryPool() == false )
83388 : {
83389 0 : std::cout << "SgUpirLoopStatement :: ";
83390 0 : std::cout << " p_upper_bound is not in memory pool of ";
83391 0 : std::cout << p_upper_bound->class_name() << std::endl;
83392 : }
83393 : }
83394 : else
83395 : {
83396 0 : std::cout << "SgUpirLoopStatement :: " << std::flush;
83397 0 : std::cout << "SgExpression* p_upper_bound = " << p_upper_bound << " --> " << std::flush;
83398 0 : std::cout << " not valid " << std::endl;
83399 : }
83400 : }
83401 :
83402 0 : if ( p_step != NULL )
83403 : {
83404 0 : if ( p_step->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83405 : {
83406 0 : if ( p_step->isInMemoryPool() == false )
83407 : {
83408 0 : std::cout << "SgUpirLoopStatement :: ";
83409 0 : std::cout << " p_step is not in memory pool of ";
83410 0 : std::cout << p_step->class_name() << std::endl;
83411 : }
83412 : }
83413 : else
83414 : {
83415 0 : std::cout << "SgUpirLoopStatement :: " << std::flush;
83416 0 : std::cout << "SgExpression* p_step = " << p_step << " --> " << std::flush;
83417 0 : std::cout << " not valid " << std::endl;
83418 : }
83419 : }
83420 :
83421 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
83422 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
83423 : {
83424 0 : if ( (*i_clauses) != NULL )
83425 : {
83426 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83427 : {
83428 0 : if ( (*i_clauses)->isInMemoryPool() == false )
83429 : {
83430 0 : std::cout << "SgUpirLoopStatement :: ";
83431 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
83432 0 : std::cout << (*i_clauses)->class_name() << std::endl;
83433 : }
83434 : }
83435 : else
83436 : {
83437 0 : std::cout << "SgUpirLoopStatement :: " << std::flush;
83438 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
83439 0 : std::cout << " entry not valid " << std::endl;
83440 : }
83441 : }
83442 : else
83443 : {
83444 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
83445 : }
83446 : }
83447 :
83448 0 : if ( p_body != NULL )
83449 : {
83450 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83451 : {
83452 0 : if ( p_body->isInMemoryPool() == false )
83453 : {
83454 0 : std::cout << "SgUpirLoopStatement :: ";
83455 0 : std::cout << " p_body is not in memory pool of ";
83456 0 : std::cout << p_body->class_name() << std::endl;
83457 : }
83458 : }
83459 : else
83460 : {
83461 0 : std::cout << "SgUpirLoopStatement :: " << std::flush;
83462 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
83463 0 : std::cout << " not valid " << std::endl;
83464 : }
83465 : }
83466 :
83467 0 : if ( p_upir_parent != NULL )
83468 : {
83469 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83470 : {
83471 0 : if ( p_upir_parent->isInMemoryPool() == false )
83472 : {
83473 0 : std::cout << "SgUpirLoopStatement :: ";
83474 0 : std::cout << " p_upir_parent is not in memory pool of ";
83475 0 : std::cout << p_upir_parent->class_name() << std::endl;
83476 : }
83477 : }
83478 : else
83479 : {
83480 0 : std::cout << "SgUpirLoopStatement :: " << std::flush;
83481 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
83482 0 : std::cout << " not valid " << std::endl;
83483 : }
83484 : }
83485 :
83486 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
83487 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
83488 : {
83489 0 : if ( (*i_upir_children) != NULL )
83490 : {
83491 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83492 : {
83493 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
83494 : {
83495 0 : std::cout << "SgUpirLoopStatement :: ";
83496 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
83497 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
83498 : }
83499 : }
83500 : else
83501 : {
83502 0 : std::cout << "SgUpirLoopStatement :: " << std::flush;
83503 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
83504 0 : std::cout << " entry not valid " << std::endl;
83505 : }
83506 : }
83507 : else
83508 : {
83509 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
83510 : }
83511 : }
83512 :
83513 0 : if ( p_numeric_label != NULL )
83514 : {
83515 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83516 : {
83517 0 : if ( p_numeric_label->isInMemoryPool() == false )
83518 : {
83519 0 : std::cout << "SgUpirLoopStatement :: ";
83520 0 : std::cout << " p_numeric_label is not in memory pool of ";
83521 0 : std::cout << p_numeric_label->class_name() << std::endl;
83522 : }
83523 : }
83524 : else
83525 : {
83526 0 : std::cout << "SgUpirLoopStatement :: " << std::flush;
83527 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
83528 0 : std::cout << " not valid " << std::endl;
83529 : }
83530 : }
83531 :
83532 0 : if ( p_startOfConstruct != NULL )
83533 : {
83534 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83535 : {
83536 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
83537 : {
83538 0 : std::cout << "SgUpirLoopStatement :: ";
83539 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
83540 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
83541 : }
83542 : }
83543 : else
83544 : {
83545 0 : std::cout << "SgUpirLoopStatement :: " << std::flush;
83546 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
83547 0 : std::cout << " not valid " << std::endl;
83548 : }
83549 : }
83550 :
83551 0 : if ( p_endOfConstruct != NULL )
83552 : {
83553 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83554 : {
83555 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
83556 : {
83557 0 : std::cout << "SgUpirLoopStatement :: ";
83558 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
83559 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
83560 : }
83561 : }
83562 : else
83563 : {
83564 0 : std::cout << "SgUpirLoopStatement :: " << std::flush;
83565 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
83566 0 : std::cout << " not valid " << std::endl;
83567 : }
83568 : }
83569 :
83570 0 : if ( p_parent != NULL )
83571 : {
83572 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83573 : {
83574 0 : if ( p_parent->isInMemoryPool() == false )
83575 : {
83576 0 : std::cout << "SgUpirLoopStatement :: ";
83577 0 : std::cout << " p_parent is not in memory pool of ";
83578 0 : std::cout << p_parent->class_name() << std::endl;
83579 : }
83580 : }
83581 : else
83582 : {
83583 0 : std::cout << "SgUpirLoopStatement :: " << std::flush;
83584 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
83585 0 : std::cout << " not valid " << std::endl;
83586 : }
83587 : }
83588 :
83589 :
83590 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
83591 :
83592 0 : }
83593 :
83594 :
83595 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
83596 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
83597 : bool
83598 0 : SgUpirLoopStatement::isInMemoryPool ()
83599 : {
83600 0 : typedef unsigned char* TestType;
83601 :
83602 0 : bool found = false;
83603 :
83604 0 : ROSE_ASSERT(this != NULL);
83605 :
83606 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
83607 :
83608 0 : TestType tested = (TestType) ( this ) ;
83609 :
83610 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirLoopStatement::pools.begin();
83611 :
83612 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
83613 : // while (found == false && block < Memory_Block_List.end())
83614 0 : while ( (found == false) && (block != SgUpirLoopStatement::pools.end()) )
83615 : {
83616 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirLoopStatement::pool_size * sizeof(SgUpirLoopStatement) ) ) ;
83617 0 : ++block;
83618 : }
83619 :
83620 : // Special handling for static data
83621 :
83622 :
83623 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
83624 0 : ROSE_ASSERT(found == true);
83625 :
83626 0 : return found;
83627 : }
83628 : /* #line 83629 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
83629 :
83630 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
83631 :
83632 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
83633 :
83634 : /* #line 83635 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
83635 :
83636 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
83637 :
83638 : void
83639 0 : SgUpirFieldStatement::checkDataMemberPointersIfInMemoryPool()
83640 : {
83641 : // ------------ checking pointers of SgUpirFieldStatement -------------------
83642 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
83643 :
83644 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
83645 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
83646 : {
83647 0 : if ( (*i_clauses) != NULL )
83648 : {
83649 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83650 : {
83651 0 : if ( (*i_clauses)->isInMemoryPool() == false )
83652 : {
83653 0 : std::cout << "SgUpirFieldStatement :: ";
83654 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
83655 0 : std::cout << (*i_clauses)->class_name() << std::endl;
83656 : }
83657 : }
83658 : else
83659 : {
83660 0 : std::cout << "SgUpirFieldStatement :: " << std::flush;
83661 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
83662 0 : std::cout << " entry not valid " << std::endl;
83663 : }
83664 : }
83665 : else
83666 : {
83667 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
83668 : }
83669 : }
83670 :
83671 0 : if ( p_upir_parent != NULL )
83672 : {
83673 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83674 : {
83675 0 : if ( p_upir_parent->isInMemoryPool() == false )
83676 : {
83677 0 : std::cout << "SgUpirFieldStatement :: ";
83678 0 : std::cout << " p_upir_parent is not in memory pool of ";
83679 0 : std::cout << p_upir_parent->class_name() << std::endl;
83680 : }
83681 : }
83682 : else
83683 : {
83684 0 : std::cout << "SgUpirFieldStatement :: " << std::flush;
83685 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
83686 0 : std::cout << " not valid " << std::endl;
83687 : }
83688 : }
83689 :
83690 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
83691 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
83692 : {
83693 0 : if ( (*i_upir_children) != NULL )
83694 : {
83695 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83696 : {
83697 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
83698 : {
83699 0 : std::cout << "SgUpirFieldStatement :: ";
83700 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
83701 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
83702 : }
83703 : }
83704 : else
83705 : {
83706 0 : std::cout << "SgUpirFieldStatement :: " << std::flush;
83707 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
83708 0 : std::cout << " entry not valid " << std::endl;
83709 : }
83710 : }
83711 : else
83712 : {
83713 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
83714 : }
83715 : }
83716 :
83717 0 : if ( p_numeric_label != NULL )
83718 : {
83719 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83720 : {
83721 0 : if ( p_numeric_label->isInMemoryPool() == false )
83722 : {
83723 0 : std::cout << "SgUpirFieldStatement :: ";
83724 0 : std::cout << " p_numeric_label is not in memory pool of ";
83725 0 : std::cout << p_numeric_label->class_name() << std::endl;
83726 : }
83727 : }
83728 : else
83729 : {
83730 0 : std::cout << "SgUpirFieldStatement :: " << std::flush;
83731 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
83732 0 : std::cout << " not valid " << std::endl;
83733 : }
83734 : }
83735 :
83736 0 : if ( p_startOfConstruct != NULL )
83737 : {
83738 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83739 : {
83740 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
83741 : {
83742 0 : std::cout << "SgUpirFieldStatement :: ";
83743 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
83744 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
83745 : }
83746 : }
83747 : else
83748 : {
83749 0 : std::cout << "SgUpirFieldStatement :: " << std::flush;
83750 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
83751 0 : std::cout << " not valid " << std::endl;
83752 : }
83753 : }
83754 :
83755 0 : if ( p_endOfConstruct != NULL )
83756 : {
83757 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83758 : {
83759 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
83760 : {
83761 0 : std::cout << "SgUpirFieldStatement :: ";
83762 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
83763 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
83764 : }
83765 : }
83766 : else
83767 : {
83768 0 : std::cout << "SgUpirFieldStatement :: " << std::flush;
83769 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
83770 0 : std::cout << " not valid " << std::endl;
83771 : }
83772 : }
83773 :
83774 0 : if ( p_parent != NULL )
83775 : {
83776 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83777 : {
83778 0 : if ( p_parent->isInMemoryPool() == false )
83779 : {
83780 0 : std::cout << "SgUpirFieldStatement :: ";
83781 0 : std::cout << " p_parent is not in memory pool of ";
83782 0 : std::cout << p_parent->class_name() << std::endl;
83783 : }
83784 : }
83785 : else
83786 : {
83787 0 : std::cout << "SgUpirFieldStatement :: " << std::flush;
83788 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
83789 0 : std::cout << " not valid " << std::endl;
83790 : }
83791 : }
83792 :
83793 :
83794 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
83795 :
83796 0 : }
83797 :
83798 :
83799 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
83800 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
83801 : bool
83802 0 : SgUpirFieldStatement::isInMemoryPool ()
83803 : {
83804 0 : typedef unsigned char* TestType;
83805 :
83806 0 : bool found = false;
83807 :
83808 0 : ROSE_ASSERT(this != NULL);
83809 :
83810 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
83811 :
83812 0 : TestType tested = (TestType) ( this ) ;
83813 :
83814 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirFieldStatement::pools.begin();
83815 :
83816 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
83817 : // while (found == false && block < Memory_Block_List.end())
83818 0 : while ( (found == false) && (block != SgUpirFieldStatement::pools.end()) )
83819 : {
83820 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirFieldStatement::pool_size * sizeof(SgUpirFieldStatement) ) ) ;
83821 0 : ++block;
83822 : }
83823 :
83824 : // Special handling for static data
83825 :
83826 :
83827 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
83828 0 : ROSE_ASSERT(found == true);
83829 :
83830 0 : return found;
83831 : }
83832 : /* #line 83833 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
83833 :
83834 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
83835 :
83836 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
83837 :
83838 : /* #line 83839 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
83839 :
83840 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
83841 :
83842 : void
83843 0 : SgOmpCancelStatement::checkDataMemberPointersIfInMemoryPool()
83844 : {
83845 : // ------------ checking pointers of SgOmpCancelStatement -------------------
83846 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
83847 :
83848 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
83849 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
83850 : {
83851 0 : if ( (*i_clauses) != NULL )
83852 : {
83853 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83854 : {
83855 0 : if ( (*i_clauses)->isInMemoryPool() == false )
83856 : {
83857 0 : std::cout << "SgOmpCancelStatement :: ";
83858 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
83859 0 : std::cout << (*i_clauses)->class_name() << std::endl;
83860 : }
83861 : }
83862 : else
83863 : {
83864 0 : std::cout << "SgOmpCancelStatement :: " << std::flush;
83865 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
83866 0 : std::cout << " entry not valid " << std::endl;
83867 : }
83868 : }
83869 : else
83870 : {
83871 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
83872 : }
83873 : }
83874 :
83875 0 : if ( p_upir_parent != NULL )
83876 : {
83877 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83878 : {
83879 0 : if ( p_upir_parent->isInMemoryPool() == false )
83880 : {
83881 0 : std::cout << "SgOmpCancelStatement :: ";
83882 0 : std::cout << " p_upir_parent is not in memory pool of ";
83883 0 : std::cout << p_upir_parent->class_name() << std::endl;
83884 : }
83885 : }
83886 : else
83887 : {
83888 0 : std::cout << "SgOmpCancelStatement :: " << std::flush;
83889 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
83890 0 : std::cout << " not valid " << std::endl;
83891 : }
83892 : }
83893 :
83894 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
83895 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
83896 : {
83897 0 : if ( (*i_upir_children) != NULL )
83898 : {
83899 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83900 : {
83901 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
83902 : {
83903 0 : std::cout << "SgOmpCancelStatement :: ";
83904 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
83905 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
83906 : }
83907 : }
83908 : else
83909 : {
83910 0 : std::cout << "SgOmpCancelStatement :: " << std::flush;
83911 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
83912 0 : std::cout << " entry not valid " << std::endl;
83913 : }
83914 : }
83915 : else
83916 : {
83917 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
83918 : }
83919 : }
83920 :
83921 0 : if ( p_numeric_label != NULL )
83922 : {
83923 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83924 : {
83925 0 : if ( p_numeric_label->isInMemoryPool() == false )
83926 : {
83927 0 : std::cout << "SgOmpCancelStatement :: ";
83928 0 : std::cout << " p_numeric_label is not in memory pool of ";
83929 0 : std::cout << p_numeric_label->class_name() << std::endl;
83930 : }
83931 : }
83932 : else
83933 : {
83934 0 : std::cout << "SgOmpCancelStatement :: " << std::flush;
83935 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
83936 0 : std::cout << " not valid " << std::endl;
83937 : }
83938 : }
83939 :
83940 0 : if ( p_startOfConstruct != NULL )
83941 : {
83942 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83943 : {
83944 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
83945 : {
83946 0 : std::cout << "SgOmpCancelStatement :: ";
83947 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
83948 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
83949 : }
83950 : }
83951 : else
83952 : {
83953 0 : std::cout << "SgOmpCancelStatement :: " << std::flush;
83954 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
83955 0 : std::cout << " not valid " << std::endl;
83956 : }
83957 : }
83958 :
83959 0 : if ( p_endOfConstruct != NULL )
83960 : {
83961 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83962 : {
83963 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
83964 : {
83965 0 : std::cout << "SgOmpCancelStatement :: ";
83966 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
83967 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
83968 : }
83969 : }
83970 : else
83971 : {
83972 0 : std::cout << "SgOmpCancelStatement :: " << std::flush;
83973 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
83974 0 : std::cout << " not valid " << std::endl;
83975 : }
83976 : }
83977 :
83978 0 : if ( p_parent != NULL )
83979 : {
83980 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
83981 : {
83982 0 : if ( p_parent->isInMemoryPool() == false )
83983 : {
83984 0 : std::cout << "SgOmpCancelStatement :: ";
83985 0 : std::cout << " p_parent is not in memory pool of ";
83986 0 : std::cout << p_parent->class_name() << std::endl;
83987 : }
83988 : }
83989 : else
83990 : {
83991 0 : std::cout << "SgOmpCancelStatement :: " << std::flush;
83992 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
83993 0 : std::cout << " not valid " << std::endl;
83994 : }
83995 : }
83996 :
83997 :
83998 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
83999 :
84000 0 : }
84001 :
84002 :
84003 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
84004 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
84005 : bool
84006 0 : SgOmpCancelStatement::isInMemoryPool ()
84007 : {
84008 0 : typedef unsigned char* TestType;
84009 :
84010 0 : bool found = false;
84011 :
84012 0 : ROSE_ASSERT(this != NULL);
84013 :
84014 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
84015 :
84016 0 : TestType tested = (TestType) ( this ) ;
84017 :
84018 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpCancelStatement::pools.begin();
84019 :
84020 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
84021 : // while (found == false && block < Memory_Block_List.end())
84022 0 : while ( (found == false) && (block != SgOmpCancelStatement::pools.end()) )
84023 : {
84024 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpCancelStatement::pool_size * sizeof(SgOmpCancelStatement) ) ) ;
84025 0 : ++block;
84026 : }
84027 :
84028 : // Special handling for static data
84029 :
84030 :
84031 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
84032 0 : ROSE_ASSERT(found == true);
84033 :
84034 0 : return found;
84035 : }
84036 : /* #line 84037 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
84037 :
84038 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
84039 :
84040 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
84041 :
84042 : /* #line 84043 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
84043 :
84044 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
84045 :
84046 : void
84047 0 : SgOmpCancellationPointStatement::checkDataMemberPointersIfInMemoryPool()
84048 : {
84049 : // ------------ checking pointers of SgOmpCancellationPointStatement -------------------
84050 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
84051 :
84052 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
84053 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
84054 : {
84055 0 : if ( (*i_clauses) != NULL )
84056 : {
84057 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84058 : {
84059 0 : if ( (*i_clauses)->isInMemoryPool() == false )
84060 : {
84061 0 : std::cout << "SgOmpCancellationPointStatement :: ";
84062 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
84063 0 : std::cout << (*i_clauses)->class_name() << std::endl;
84064 : }
84065 : }
84066 : else
84067 : {
84068 0 : std::cout << "SgOmpCancellationPointStatement :: " << std::flush;
84069 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
84070 0 : std::cout << " entry not valid " << std::endl;
84071 : }
84072 : }
84073 : else
84074 : {
84075 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
84076 : }
84077 : }
84078 :
84079 0 : if ( p_upir_parent != NULL )
84080 : {
84081 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84082 : {
84083 0 : if ( p_upir_parent->isInMemoryPool() == false )
84084 : {
84085 0 : std::cout << "SgOmpCancellationPointStatement :: ";
84086 0 : std::cout << " p_upir_parent is not in memory pool of ";
84087 0 : std::cout << p_upir_parent->class_name() << std::endl;
84088 : }
84089 : }
84090 : else
84091 : {
84092 0 : std::cout << "SgOmpCancellationPointStatement :: " << std::flush;
84093 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
84094 0 : std::cout << " not valid " << std::endl;
84095 : }
84096 : }
84097 :
84098 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
84099 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
84100 : {
84101 0 : if ( (*i_upir_children) != NULL )
84102 : {
84103 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84104 : {
84105 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
84106 : {
84107 0 : std::cout << "SgOmpCancellationPointStatement :: ";
84108 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
84109 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
84110 : }
84111 : }
84112 : else
84113 : {
84114 0 : std::cout << "SgOmpCancellationPointStatement :: " << std::flush;
84115 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
84116 0 : std::cout << " entry not valid " << std::endl;
84117 : }
84118 : }
84119 : else
84120 : {
84121 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
84122 : }
84123 : }
84124 :
84125 0 : if ( p_numeric_label != NULL )
84126 : {
84127 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84128 : {
84129 0 : if ( p_numeric_label->isInMemoryPool() == false )
84130 : {
84131 0 : std::cout << "SgOmpCancellationPointStatement :: ";
84132 0 : std::cout << " p_numeric_label is not in memory pool of ";
84133 0 : std::cout << p_numeric_label->class_name() << std::endl;
84134 : }
84135 : }
84136 : else
84137 : {
84138 0 : std::cout << "SgOmpCancellationPointStatement :: " << std::flush;
84139 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
84140 0 : std::cout << " not valid " << std::endl;
84141 : }
84142 : }
84143 :
84144 0 : if ( p_startOfConstruct != NULL )
84145 : {
84146 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84147 : {
84148 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
84149 : {
84150 0 : std::cout << "SgOmpCancellationPointStatement :: ";
84151 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
84152 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
84153 : }
84154 : }
84155 : else
84156 : {
84157 0 : std::cout << "SgOmpCancellationPointStatement :: " << std::flush;
84158 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
84159 0 : std::cout << " not valid " << std::endl;
84160 : }
84161 : }
84162 :
84163 0 : if ( p_endOfConstruct != NULL )
84164 : {
84165 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84166 : {
84167 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
84168 : {
84169 0 : std::cout << "SgOmpCancellationPointStatement :: ";
84170 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
84171 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
84172 : }
84173 : }
84174 : else
84175 : {
84176 0 : std::cout << "SgOmpCancellationPointStatement :: " << std::flush;
84177 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
84178 0 : std::cout << " not valid " << std::endl;
84179 : }
84180 : }
84181 :
84182 0 : if ( p_parent != NULL )
84183 : {
84184 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84185 : {
84186 0 : if ( p_parent->isInMemoryPool() == false )
84187 : {
84188 0 : std::cout << "SgOmpCancellationPointStatement :: ";
84189 0 : std::cout << " p_parent is not in memory pool of ";
84190 0 : std::cout << p_parent->class_name() << std::endl;
84191 : }
84192 : }
84193 : else
84194 : {
84195 0 : std::cout << "SgOmpCancellationPointStatement :: " << std::flush;
84196 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
84197 0 : std::cout << " not valid " << std::endl;
84198 : }
84199 : }
84200 :
84201 :
84202 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
84203 :
84204 0 : }
84205 :
84206 :
84207 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
84208 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
84209 : bool
84210 0 : SgOmpCancellationPointStatement::isInMemoryPool ()
84211 : {
84212 0 : typedef unsigned char* TestType;
84213 :
84214 0 : bool found = false;
84215 :
84216 0 : ROSE_ASSERT(this != NULL);
84217 :
84218 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
84219 :
84220 0 : TestType tested = (TestType) ( this ) ;
84221 :
84222 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpCancellationPointStatement::pools.begin();
84223 :
84224 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
84225 : // while (found == false && block < Memory_Block_List.end())
84226 0 : while ( (found == false) && (block != SgOmpCancellationPointStatement::pools.end()) )
84227 : {
84228 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpCancellationPointStatement::pool_size * sizeof(SgOmpCancellationPointStatement) ) ) ;
84229 0 : ++block;
84230 : }
84231 :
84232 : // Special handling for static data
84233 :
84234 :
84235 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
84236 0 : ROSE_ASSERT(found == true);
84237 :
84238 0 : return found;
84239 : }
84240 : /* #line 84241 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
84241 :
84242 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
84243 :
84244 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
84245 :
84246 : /* #line 84247 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
84247 :
84248 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
84249 :
84250 : void
84251 0 : SgOmpTargetUpdateStatement::checkDataMemberPointersIfInMemoryPool()
84252 : {
84253 : // ------------ checking pointers of SgOmpTargetUpdateStatement -------------------
84254 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
84255 :
84256 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
84257 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
84258 : {
84259 0 : if ( (*i_clauses) != NULL )
84260 : {
84261 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84262 : {
84263 0 : if ( (*i_clauses)->isInMemoryPool() == false )
84264 : {
84265 0 : std::cout << "SgOmpTargetUpdateStatement :: ";
84266 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
84267 0 : std::cout << (*i_clauses)->class_name() << std::endl;
84268 : }
84269 : }
84270 : else
84271 : {
84272 0 : std::cout << "SgOmpTargetUpdateStatement :: " << std::flush;
84273 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
84274 0 : std::cout << " entry not valid " << std::endl;
84275 : }
84276 : }
84277 : else
84278 : {
84279 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
84280 : }
84281 : }
84282 :
84283 0 : if ( p_upir_parent != NULL )
84284 : {
84285 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84286 : {
84287 0 : if ( p_upir_parent->isInMemoryPool() == false )
84288 : {
84289 0 : std::cout << "SgOmpTargetUpdateStatement :: ";
84290 0 : std::cout << " p_upir_parent is not in memory pool of ";
84291 0 : std::cout << p_upir_parent->class_name() << std::endl;
84292 : }
84293 : }
84294 : else
84295 : {
84296 0 : std::cout << "SgOmpTargetUpdateStatement :: " << std::flush;
84297 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
84298 0 : std::cout << " not valid " << std::endl;
84299 : }
84300 : }
84301 :
84302 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
84303 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
84304 : {
84305 0 : if ( (*i_upir_children) != NULL )
84306 : {
84307 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84308 : {
84309 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
84310 : {
84311 0 : std::cout << "SgOmpTargetUpdateStatement :: ";
84312 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
84313 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
84314 : }
84315 : }
84316 : else
84317 : {
84318 0 : std::cout << "SgOmpTargetUpdateStatement :: " << std::flush;
84319 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
84320 0 : std::cout << " entry not valid " << std::endl;
84321 : }
84322 : }
84323 : else
84324 : {
84325 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
84326 : }
84327 : }
84328 :
84329 0 : if ( p_numeric_label != NULL )
84330 : {
84331 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84332 : {
84333 0 : if ( p_numeric_label->isInMemoryPool() == false )
84334 : {
84335 0 : std::cout << "SgOmpTargetUpdateStatement :: ";
84336 0 : std::cout << " p_numeric_label is not in memory pool of ";
84337 0 : std::cout << p_numeric_label->class_name() << std::endl;
84338 : }
84339 : }
84340 : else
84341 : {
84342 0 : std::cout << "SgOmpTargetUpdateStatement :: " << std::flush;
84343 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
84344 0 : std::cout << " not valid " << std::endl;
84345 : }
84346 : }
84347 :
84348 0 : if ( p_startOfConstruct != NULL )
84349 : {
84350 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84351 : {
84352 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
84353 : {
84354 0 : std::cout << "SgOmpTargetUpdateStatement :: ";
84355 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
84356 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
84357 : }
84358 : }
84359 : else
84360 : {
84361 0 : std::cout << "SgOmpTargetUpdateStatement :: " << std::flush;
84362 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
84363 0 : std::cout << " not valid " << std::endl;
84364 : }
84365 : }
84366 :
84367 0 : if ( p_endOfConstruct != NULL )
84368 : {
84369 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84370 : {
84371 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
84372 : {
84373 0 : std::cout << "SgOmpTargetUpdateStatement :: ";
84374 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
84375 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
84376 : }
84377 : }
84378 : else
84379 : {
84380 0 : std::cout << "SgOmpTargetUpdateStatement :: " << std::flush;
84381 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
84382 0 : std::cout << " not valid " << std::endl;
84383 : }
84384 : }
84385 :
84386 0 : if ( p_parent != NULL )
84387 : {
84388 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84389 : {
84390 0 : if ( p_parent->isInMemoryPool() == false )
84391 : {
84392 0 : std::cout << "SgOmpTargetUpdateStatement :: ";
84393 0 : std::cout << " p_parent is not in memory pool of ";
84394 0 : std::cout << p_parent->class_name() << std::endl;
84395 : }
84396 : }
84397 : else
84398 : {
84399 0 : std::cout << "SgOmpTargetUpdateStatement :: " << std::flush;
84400 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
84401 0 : std::cout << " not valid " << std::endl;
84402 : }
84403 : }
84404 :
84405 :
84406 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
84407 :
84408 0 : }
84409 :
84410 :
84411 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
84412 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
84413 : bool
84414 0 : SgOmpTargetUpdateStatement::isInMemoryPool ()
84415 : {
84416 0 : typedef unsigned char* TestType;
84417 :
84418 0 : bool found = false;
84419 :
84420 0 : ROSE_ASSERT(this != NULL);
84421 :
84422 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
84423 :
84424 0 : TestType tested = (TestType) ( this ) ;
84425 :
84426 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpTargetUpdateStatement::pools.begin();
84427 :
84428 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
84429 : // while (found == false && block < Memory_Block_List.end())
84430 0 : while ( (found == false) && (block != SgOmpTargetUpdateStatement::pools.end()) )
84431 : {
84432 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpTargetUpdateStatement::pool_size * sizeof(SgOmpTargetUpdateStatement) ) ) ;
84433 0 : ++block;
84434 : }
84435 :
84436 : // Special handling for static data
84437 :
84438 :
84439 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
84440 0 : ROSE_ASSERT(found == true);
84441 :
84442 0 : return found;
84443 : }
84444 : /* #line 84445 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
84445 :
84446 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
84447 :
84448 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
84449 :
84450 : /* #line 84451 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
84451 :
84452 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
84453 :
84454 : void
84455 0 : SgOmpFlushStatement::checkDataMemberPointersIfInMemoryPool()
84456 : {
84457 : // ------------ checking pointers of SgOmpFlushStatement -------------------
84458 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
84459 :
84460 0 : SgVarRefExpPtrList::iterator i_variables = p_variables.begin() ;
84461 0 : for ( ; i_variables != p_variables.end(); ++i_variables )
84462 : {
84463 0 : if ( (*i_variables) != NULL )
84464 : {
84465 0 : if ( (*i_variables)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84466 : {
84467 0 : if ( (*i_variables)->isInMemoryPool() == false )
84468 : {
84469 0 : std::cout << "SgOmpFlushStatement :: ";
84470 0 : std::cout << " p_variables ( list of poitners to IR nodes ), entry is not in memory pool of ";
84471 0 : std::cout << (*i_variables)->class_name() << std::endl;
84472 : }
84473 : }
84474 : else
84475 : {
84476 0 : std::cout << "SgOmpFlushStatement :: " << std::flush;
84477 0 : std::cout << "SgVarRefExpPtrList p_variables --> " << std::flush;
84478 0 : std::cout << " entry not valid " << std::endl;
84479 : }
84480 : }
84481 : else
84482 : {
84483 0 : std::cout << "SgVarRefExpPtrList p_variables --> NULL " << std::endl;
84484 : }
84485 : }
84486 :
84487 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
84488 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
84489 : {
84490 0 : if ( (*i_clauses) != NULL )
84491 : {
84492 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84493 : {
84494 0 : if ( (*i_clauses)->isInMemoryPool() == false )
84495 : {
84496 0 : std::cout << "SgOmpFlushStatement :: ";
84497 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
84498 0 : std::cout << (*i_clauses)->class_name() << std::endl;
84499 : }
84500 : }
84501 : else
84502 : {
84503 0 : std::cout << "SgOmpFlushStatement :: " << std::flush;
84504 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
84505 0 : std::cout << " entry not valid " << std::endl;
84506 : }
84507 : }
84508 : else
84509 : {
84510 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
84511 : }
84512 : }
84513 :
84514 0 : if ( p_upir_parent != NULL )
84515 : {
84516 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84517 : {
84518 0 : if ( p_upir_parent->isInMemoryPool() == false )
84519 : {
84520 0 : std::cout << "SgOmpFlushStatement :: ";
84521 0 : std::cout << " p_upir_parent is not in memory pool of ";
84522 0 : std::cout << p_upir_parent->class_name() << std::endl;
84523 : }
84524 : }
84525 : else
84526 : {
84527 0 : std::cout << "SgOmpFlushStatement :: " << std::flush;
84528 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
84529 0 : std::cout << " not valid " << std::endl;
84530 : }
84531 : }
84532 :
84533 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
84534 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
84535 : {
84536 0 : if ( (*i_upir_children) != NULL )
84537 : {
84538 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84539 : {
84540 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
84541 : {
84542 0 : std::cout << "SgOmpFlushStatement :: ";
84543 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
84544 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
84545 : }
84546 : }
84547 : else
84548 : {
84549 0 : std::cout << "SgOmpFlushStatement :: " << std::flush;
84550 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
84551 0 : std::cout << " entry not valid " << std::endl;
84552 : }
84553 : }
84554 : else
84555 : {
84556 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
84557 : }
84558 : }
84559 :
84560 0 : if ( p_numeric_label != NULL )
84561 : {
84562 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84563 : {
84564 0 : if ( p_numeric_label->isInMemoryPool() == false )
84565 : {
84566 0 : std::cout << "SgOmpFlushStatement :: ";
84567 0 : std::cout << " p_numeric_label is not in memory pool of ";
84568 0 : std::cout << p_numeric_label->class_name() << std::endl;
84569 : }
84570 : }
84571 : else
84572 : {
84573 0 : std::cout << "SgOmpFlushStatement :: " << std::flush;
84574 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
84575 0 : std::cout << " not valid " << std::endl;
84576 : }
84577 : }
84578 :
84579 0 : if ( p_startOfConstruct != NULL )
84580 : {
84581 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84582 : {
84583 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
84584 : {
84585 0 : std::cout << "SgOmpFlushStatement :: ";
84586 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
84587 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
84588 : }
84589 : }
84590 : else
84591 : {
84592 0 : std::cout << "SgOmpFlushStatement :: " << std::flush;
84593 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
84594 0 : std::cout << " not valid " << std::endl;
84595 : }
84596 : }
84597 :
84598 0 : if ( p_endOfConstruct != NULL )
84599 : {
84600 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84601 : {
84602 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
84603 : {
84604 0 : std::cout << "SgOmpFlushStatement :: ";
84605 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
84606 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
84607 : }
84608 : }
84609 : else
84610 : {
84611 0 : std::cout << "SgOmpFlushStatement :: " << std::flush;
84612 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
84613 0 : std::cout << " not valid " << std::endl;
84614 : }
84615 : }
84616 :
84617 0 : if ( p_parent != NULL )
84618 : {
84619 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84620 : {
84621 0 : if ( p_parent->isInMemoryPool() == false )
84622 : {
84623 0 : std::cout << "SgOmpFlushStatement :: ";
84624 0 : std::cout << " p_parent is not in memory pool of ";
84625 0 : std::cout << p_parent->class_name() << std::endl;
84626 : }
84627 : }
84628 : else
84629 : {
84630 0 : std::cout << "SgOmpFlushStatement :: " << std::flush;
84631 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
84632 0 : std::cout << " not valid " << std::endl;
84633 : }
84634 : }
84635 :
84636 :
84637 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
84638 :
84639 0 : }
84640 :
84641 :
84642 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
84643 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
84644 : bool
84645 0 : SgOmpFlushStatement::isInMemoryPool ()
84646 : {
84647 0 : typedef unsigned char* TestType;
84648 :
84649 0 : bool found = false;
84650 :
84651 0 : ROSE_ASSERT(this != NULL);
84652 :
84653 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
84654 :
84655 0 : TestType tested = (TestType) ( this ) ;
84656 :
84657 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpFlushStatement::pools.begin();
84658 :
84659 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
84660 : // while (found == false && block < Memory_Block_List.end())
84661 0 : while ( (found == false) && (block != SgOmpFlushStatement::pools.end()) )
84662 : {
84663 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpFlushStatement::pool_size * sizeof(SgOmpFlushStatement) ) ) ;
84664 0 : ++block;
84665 : }
84666 :
84667 : // Special handling for static data
84668 :
84669 :
84670 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
84671 0 : ROSE_ASSERT(found == true);
84672 :
84673 0 : return found;
84674 : }
84675 : /* #line 84676 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
84676 :
84677 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
84678 :
84679 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
84680 :
84681 : /* #line 84682 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
84682 :
84683 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
84684 :
84685 : void
84686 0 : SgOmpAllocateStatement::checkDataMemberPointersIfInMemoryPool()
84687 : {
84688 : // ------------ checking pointers of SgOmpAllocateStatement -------------------
84689 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
84690 :
84691 0 : SgVarRefExpPtrList::iterator i_variables = p_variables.begin() ;
84692 0 : for ( ; i_variables != p_variables.end(); ++i_variables )
84693 : {
84694 0 : if ( (*i_variables) != NULL )
84695 : {
84696 0 : if ( (*i_variables)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84697 : {
84698 0 : if ( (*i_variables)->isInMemoryPool() == false )
84699 : {
84700 0 : std::cout << "SgOmpAllocateStatement :: ";
84701 0 : std::cout << " p_variables ( list of poitners to IR nodes ), entry is not in memory pool of ";
84702 0 : std::cout << (*i_variables)->class_name() << std::endl;
84703 : }
84704 : }
84705 : else
84706 : {
84707 0 : std::cout << "SgOmpAllocateStatement :: " << std::flush;
84708 0 : std::cout << "SgVarRefExpPtrList p_variables --> " << std::flush;
84709 0 : std::cout << " entry not valid " << std::endl;
84710 : }
84711 : }
84712 : else
84713 : {
84714 0 : std::cout << "SgVarRefExpPtrList p_variables --> NULL " << std::endl;
84715 : }
84716 : }
84717 :
84718 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
84719 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
84720 : {
84721 0 : if ( (*i_clauses) != NULL )
84722 : {
84723 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84724 : {
84725 0 : if ( (*i_clauses)->isInMemoryPool() == false )
84726 : {
84727 0 : std::cout << "SgOmpAllocateStatement :: ";
84728 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
84729 0 : std::cout << (*i_clauses)->class_name() << std::endl;
84730 : }
84731 : }
84732 : else
84733 : {
84734 0 : std::cout << "SgOmpAllocateStatement :: " << std::flush;
84735 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
84736 0 : std::cout << " entry not valid " << std::endl;
84737 : }
84738 : }
84739 : else
84740 : {
84741 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
84742 : }
84743 : }
84744 :
84745 0 : if ( p_upir_parent != NULL )
84746 : {
84747 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84748 : {
84749 0 : if ( p_upir_parent->isInMemoryPool() == false )
84750 : {
84751 0 : std::cout << "SgOmpAllocateStatement :: ";
84752 0 : std::cout << " p_upir_parent is not in memory pool of ";
84753 0 : std::cout << p_upir_parent->class_name() << std::endl;
84754 : }
84755 : }
84756 : else
84757 : {
84758 0 : std::cout << "SgOmpAllocateStatement :: " << std::flush;
84759 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
84760 0 : std::cout << " not valid " << std::endl;
84761 : }
84762 : }
84763 :
84764 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
84765 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
84766 : {
84767 0 : if ( (*i_upir_children) != NULL )
84768 : {
84769 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84770 : {
84771 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
84772 : {
84773 0 : std::cout << "SgOmpAllocateStatement :: ";
84774 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
84775 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
84776 : }
84777 : }
84778 : else
84779 : {
84780 0 : std::cout << "SgOmpAllocateStatement :: " << std::flush;
84781 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
84782 0 : std::cout << " entry not valid " << std::endl;
84783 : }
84784 : }
84785 : else
84786 : {
84787 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
84788 : }
84789 : }
84790 :
84791 0 : if ( p_numeric_label != NULL )
84792 : {
84793 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84794 : {
84795 0 : if ( p_numeric_label->isInMemoryPool() == false )
84796 : {
84797 0 : std::cout << "SgOmpAllocateStatement :: ";
84798 0 : std::cout << " p_numeric_label is not in memory pool of ";
84799 0 : std::cout << p_numeric_label->class_name() << std::endl;
84800 : }
84801 : }
84802 : else
84803 : {
84804 0 : std::cout << "SgOmpAllocateStatement :: " << std::flush;
84805 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
84806 0 : std::cout << " not valid " << std::endl;
84807 : }
84808 : }
84809 :
84810 0 : if ( p_startOfConstruct != NULL )
84811 : {
84812 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84813 : {
84814 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
84815 : {
84816 0 : std::cout << "SgOmpAllocateStatement :: ";
84817 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
84818 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
84819 : }
84820 : }
84821 : else
84822 : {
84823 0 : std::cout << "SgOmpAllocateStatement :: " << std::flush;
84824 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
84825 0 : std::cout << " not valid " << std::endl;
84826 : }
84827 : }
84828 :
84829 0 : if ( p_endOfConstruct != NULL )
84830 : {
84831 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84832 : {
84833 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
84834 : {
84835 0 : std::cout << "SgOmpAllocateStatement :: ";
84836 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
84837 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
84838 : }
84839 : }
84840 : else
84841 : {
84842 0 : std::cout << "SgOmpAllocateStatement :: " << std::flush;
84843 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
84844 0 : std::cout << " not valid " << std::endl;
84845 : }
84846 : }
84847 :
84848 0 : if ( p_parent != NULL )
84849 : {
84850 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84851 : {
84852 0 : if ( p_parent->isInMemoryPool() == false )
84853 : {
84854 0 : std::cout << "SgOmpAllocateStatement :: ";
84855 0 : std::cout << " p_parent is not in memory pool of ";
84856 0 : std::cout << p_parent->class_name() << std::endl;
84857 : }
84858 : }
84859 : else
84860 : {
84861 0 : std::cout << "SgOmpAllocateStatement :: " << std::flush;
84862 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
84863 0 : std::cout << " not valid " << std::endl;
84864 : }
84865 : }
84866 :
84867 :
84868 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
84869 :
84870 0 : }
84871 :
84872 :
84873 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
84874 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
84875 : bool
84876 0 : SgOmpAllocateStatement::isInMemoryPool ()
84877 : {
84878 0 : typedef unsigned char* TestType;
84879 :
84880 0 : bool found = false;
84881 :
84882 0 : ROSE_ASSERT(this != NULL);
84883 :
84884 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
84885 :
84886 0 : TestType tested = (TestType) ( this ) ;
84887 :
84888 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpAllocateStatement::pools.begin();
84889 :
84890 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
84891 : // while (found == false && block < Memory_Block_List.end())
84892 0 : while ( (found == false) && (block != SgOmpAllocateStatement::pools.end()) )
84893 : {
84894 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpAllocateStatement::pool_size * sizeof(SgOmpAllocateStatement) ) ) ;
84895 0 : ++block;
84896 : }
84897 :
84898 : // Special handling for static data
84899 :
84900 :
84901 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
84902 0 : ROSE_ASSERT(found == true);
84903 :
84904 0 : return found;
84905 : }
84906 : /* #line 84907 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
84907 :
84908 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
84909 :
84910 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
84911 :
84912 : /* #line 84913 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
84913 :
84914 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
84915 :
84916 : void
84917 0 : SgOmpOrderedDependStatement::checkDataMemberPointersIfInMemoryPool()
84918 : {
84919 : // ------------ checking pointers of SgOmpOrderedDependStatement -------------------
84920 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
84921 :
84922 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
84923 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
84924 : {
84925 0 : if ( (*i_clauses) != NULL )
84926 : {
84927 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84928 : {
84929 0 : if ( (*i_clauses)->isInMemoryPool() == false )
84930 : {
84931 0 : std::cout << "SgOmpOrderedDependStatement :: ";
84932 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
84933 0 : std::cout << (*i_clauses)->class_name() << std::endl;
84934 : }
84935 : }
84936 : else
84937 : {
84938 0 : std::cout << "SgOmpOrderedDependStatement :: " << std::flush;
84939 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
84940 0 : std::cout << " entry not valid " << std::endl;
84941 : }
84942 : }
84943 : else
84944 : {
84945 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
84946 : }
84947 : }
84948 :
84949 0 : if ( p_upir_parent != NULL )
84950 : {
84951 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84952 : {
84953 0 : if ( p_upir_parent->isInMemoryPool() == false )
84954 : {
84955 0 : std::cout << "SgOmpOrderedDependStatement :: ";
84956 0 : std::cout << " p_upir_parent is not in memory pool of ";
84957 0 : std::cout << p_upir_parent->class_name() << std::endl;
84958 : }
84959 : }
84960 : else
84961 : {
84962 0 : std::cout << "SgOmpOrderedDependStatement :: " << std::flush;
84963 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
84964 0 : std::cout << " not valid " << std::endl;
84965 : }
84966 : }
84967 :
84968 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
84969 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
84970 : {
84971 0 : if ( (*i_upir_children) != NULL )
84972 : {
84973 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84974 : {
84975 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
84976 : {
84977 0 : std::cout << "SgOmpOrderedDependStatement :: ";
84978 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
84979 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
84980 : }
84981 : }
84982 : else
84983 : {
84984 0 : std::cout << "SgOmpOrderedDependStatement :: " << std::flush;
84985 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
84986 0 : std::cout << " entry not valid " << std::endl;
84987 : }
84988 : }
84989 : else
84990 : {
84991 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
84992 : }
84993 : }
84994 :
84995 0 : if ( p_numeric_label != NULL )
84996 : {
84997 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
84998 : {
84999 0 : if ( p_numeric_label->isInMemoryPool() == false )
85000 : {
85001 0 : std::cout << "SgOmpOrderedDependStatement :: ";
85002 0 : std::cout << " p_numeric_label is not in memory pool of ";
85003 0 : std::cout << p_numeric_label->class_name() << std::endl;
85004 : }
85005 : }
85006 : else
85007 : {
85008 0 : std::cout << "SgOmpOrderedDependStatement :: " << std::flush;
85009 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
85010 0 : std::cout << " not valid " << std::endl;
85011 : }
85012 : }
85013 :
85014 0 : if ( p_startOfConstruct != NULL )
85015 : {
85016 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85017 : {
85018 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
85019 : {
85020 0 : std::cout << "SgOmpOrderedDependStatement :: ";
85021 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
85022 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
85023 : }
85024 : }
85025 : else
85026 : {
85027 0 : std::cout << "SgOmpOrderedDependStatement :: " << std::flush;
85028 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
85029 0 : std::cout << " not valid " << std::endl;
85030 : }
85031 : }
85032 :
85033 0 : if ( p_endOfConstruct != NULL )
85034 : {
85035 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85036 : {
85037 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
85038 : {
85039 0 : std::cout << "SgOmpOrderedDependStatement :: ";
85040 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
85041 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
85042 : }
85043 : }
85044 : else
85045 : {
85046 0 : std::cout << "SgOmpOrderedDependStatement :: " << std::flush;
85047 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
85048 0 : std::cout << " not valid " << std::endl;
85049 : }
85050 : }
85051 :
85052 0 : if ( p_parent != NULL )
85053 : {
85054 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85055 : {
85056 0 : if ( p_parent->isInMemoryPool() == false )
85057 : {
85058 0 : std::cout << "SgOmpOrderedDependStatement :: ";
85059 0 : std::cout << " p_parent is not in memory pool of ";
85060 0 : std::cout << p_parent->class_name() << std::endl;
85061 : }
85062 : }
85063 : else
85064 : {
85065 0 : std::cout << "SgOmpOrderedDependStatement :: " << std::flush;
85066 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
85067 0 : std::cout << " not valid " << std::endl;
85068 : }
85069 : }
85070 :
85071 :
85072 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
85073 :
85074 0 : }
85075 :
85076 :
85077 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
85078 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
85079 : bool
85080 0 : SgOmpOrderedDependStatement::isInMemoryPool ()
85081 : {
85082 0 : typedef unsigned char* TestType;
85083 :
85084 0 : bool found = false;
85085 :
85086 0 : ROSE_ASSERT(this != NULL);
85087 :
85088 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
85089 :
85090 0 : TestType tested = (TestType) ( this ) ;
85091 :
85092 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpOrderedDependStatement::pools.begin();
85093 :
85094 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
85095 : // while (found == false && block < Memory_Block_List.end())
85096 0 : while ( (found == false) && (block != SgOmpOrderedDependStatement::pools.end()) )
85097 : {
85098 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpOrderedDependStatement::pool_size * sizeof(SgOmpOrderedDependStatement) ) ) ;
85099 0 : ++block;
85100 : }
85101 :
85102 : // Special handling for static data
85103 :
85104 :
85105 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
85106 0 : ROSE_ASSERT(found == true);
85107 :
85108 0 : return found;
85109 : }
85110 : /* #line 85111 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
85111 :
85112 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
85113 :
85114 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
85115 :
85116 : /* #line 85117 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
85117 :
85118 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
85119 :
85120 : void
85121 0 : SgUpirSyncStatement::checkDataMemberPointersIfInMemoryPool()
85122 : {
85123 : // ------------ checking pointers of SgUpirSyncStatement -------------------
85124 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
85125 :
85126 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
85127 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
85128 : {
85129 0 : if ( (*i_clauses) != NULL )
85130 : {
85131 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85132 : {
85133 0 : if ( (*i_clauses)->isInMemoryPool() == false )
85134 : {
85135 0 : std::cout << "SgUpirSyncStatement :: ";
85136 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
85137 0 : std::cout << (*i_clauses)->class_name() << std::endl;
85138 : }
85139 : }
85140 : else
85141 : {
85142 0 : std::cout << "SgUpirSyncStatement :: " << std::flush;
85143 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
85144 0 : std::cout << " entry not valid " << std::endl;
85145 : }
85146 : }
85147 : else
85148 : {
85149 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
85150 : }
85151 : }
85152 :
85153 0 : if ( p_upir_parent != NULL )
85154 : {
85155 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85156 : {
85157 0 : if ( p_upir_parent->isInMemoryPool() == false )
85158 : {
85159 0 : std::cout << "SgUpirSyncStatement :: ";
85160 0 : std::cout << " p_upir_parent is not in memory pool of ";
85161 0 : std::cout << p_upir_parent->class_name() << std::endl;
85162 : }
85163 : }
85164 : else
85165 : {
85166 0 : std::cout << "SgUpirSyncStatement :: " << std::flush;
85167 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
85168 0 : std::cout << " not valid " << std::endl;
85169 : }
85170 : }
85171 :
85172 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
85173 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
85174 : {
85175 0 : if ( (*i_upir_children) != NULL )
85176 : {
85177 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85178 : {
85179 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
85180 : {
85181 0 : std::cout << "SgUpirSyncStatement :: ";
85182 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
85183 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
85184 : }
85185 : }
85186 : else
85187 : {
85188 0 : std::cout << "SgUpirSyncStatement :: " << std::flush;
85189 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
85190 0 : std::cout << " entry not valid " << std::endl;
85191 : }
85192 : }
85193 : else
85194 : {
85195 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
85196 : }
85197 : }
85198 :
85199 0 : if ( p_numeric_label != NULL )
85200 : {
85201 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85202 : {
85203 0 : if ( p_numeric_label->isInMemoryPool() == false )
85204 : {
85205 0 : std::cout << "SgUpirSyncStatement :: ";
85206 0 : std::cout << " p_numeric_label is not in memory pool of ";
85207 0 : std::cout << p_numeric_label->class_name() << std::endl;
85208 : }
85209 : }
85210 : else
85211 : {
85212 0 : std::cout << "SgUpirSyncStatement :: " << std::flush;
85213 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
85214 0 : std::cout << " not valid " << std::endl;
85215 : }
85216 : }
85217 :
85218 0 : if ( p_startOfConstruct != NULL )
85219 : {
85220 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85221 : {
85222 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
85223 : {
85224 0 : std::cout << "SgUpirSyncStatement :: ";
85225 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
85226 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
85227 : }
85228 : }
85229 : else
85230 : {
85231 0 : std::cout << "SgUpirSyncStatement :: " << std::flush;
85232 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
85233 0 : std::cout << " not valid " << std::endl;
85234 : }
85235 : }
85236 :
85237 0 : if ( p_endOfConstruct != NULL )
85238 : {
85239 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85240 : {
85241 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
85242 : {
85243 0 : std::cout << "SgUpirSyncStatement :: ";
85244 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
85245 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
85246 : }
85247 : }
85248 : else
85249 : {
85250 0 : std::cout << "SgUpirSyncStatement :: " << std::flush;
85251 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
85252 0 : std::cout << " not valid " << std::endl;
85253 : }
85254 : }
85255 :
85256 0 : if ( p_parent != NULL )
85257 : {
85258 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85259 : {
85260 0 : if ( p_parent->isInMemoryPool() == false )
85261 : {
85262 0 : std::cout << "SgUpirSyncStatement :: ";
85263 0 : std::cout << " p_parent is not in memory pool of ";
85264 0 : std::cout << p_parent->class_name() << std::endl;
85265 : }
85266 : }
85267 : else
85268 : {
85269 0 : std::cout << "SgUpirSyncStatement :: " << std::flush;
85270 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
85271 0 : std::cout << " not valid " << std::endl;
85272 : }
85273 : }
85274 :
85275 :
85276 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
85277 :
85278 0 : }
85279 :
85280 :
85281 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
85282 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
85283 : bool
85284 0 : SgUpirSyncStatement::isInMemoryPool ()
85285 : {
85286 0 : typedef unsigned char* TestType;
85287 :
85288 0 : bool found = false;
85289 :
85290 0 : ROSE_ASSERT(this != NULL);
85291 :
85292 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
85293 :
85294 0 : TestType tested = (TestType) ( this ) ;
85295 :
85296 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirSyncStatement::pools.begin();
85297 :
85298 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
85299 : // while (found == false && block < Memory_Block_List.end())
85300 0 : while ( (found == false) && (block != SgUpirSyncStatement::pools.end()) )
85301 : {
85302 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirSyncStatement::pool_size * sizeof(SgUpirSyncStatement) ) ) ;
85303 0 : ++block;
85304 : }
85305 :
85306 : // Special handling for static data
85307 :
85308 :
85309 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
85310 0 : ROSE_ASSERT(found == true);
85311 :
85312 0 : return found;
85313 : }
85314 : /* #line 85315 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
85315 :
85316 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
85317 :
85318 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
85319 :
85320 : /* #line 85321 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
85321 :
85322 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
85323 :
85324 : void
85325 0 : SgUpirLoopParallelStatement::checkDataMemberPointersIfInMemoryPool()
85326 : {
85327 : // ------------ checking pointers of SgUpirLoopParallelStatement -------------------
85328 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
85329 :
85330 0 : if ( p_worksharing != NULL )
85331 : {
85332 0 : if ( p_worksharing->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85333 : {
85334 0 : if ( p_worksharing->isInMemoryPool() == false )
85335 : {
85336 0 : std::cout << "SgUpirLoopParallelStatement :: ";
85337 0 : std::cout << " p_worksharing is not in memory pool of ";
85338 0 : std::cout << p_worksharing->class_name() << std::endl;
85339 : }
85340 : }
85341 : else
85342 : {
85343 0 : std::cout << "SgUpirLoopParallelStatement :: " << std::flush;
85344 0 : std::cout << "SgStatement* p_worksharing = " << p_worksharing << " --> " << std::flush;
85345 0 : std::cout << " not valid " << std::endl;
85346 : }
85347 : }
85348 :
85349 0 : if ( p_simd != NULL )
85350 : {
85351 0 : if ( p_simd->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85352 : {
85353 0 : if ( p_simd->isInMemoryPool() == false )
85354 : {
85355 0 : std::cout << "SgUpirLoopParallelStatement :: ";
85356 0 : std::cout << " p_simd is not in memory pool of ";
85357 0 : std::cout << p_simd->class_name() << std::endl;
85358 : }
85359 : }
85360 : else
85361 : {
85362 0 : std::cout << "SgUpirLoopParallelStatement :: " << std::flush;
85363 0 : std::cout << "SgStatement* p_simd = " << p_simd << " --> " << std::flush;
85364 0 : std::cout << " not valid " << std::endl;
85365 : }
85366 : }
85367 :
85368 0 : if ( p_taskloop != NULL )
85369 : {
85370 0 : if ( p_taskloop->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85371 : {
85372 0 : if ( p_taskloop->isInMemoryPool() == false )
85373 : {
85374 0 : std::cout << "SgUpirLoopParallelStatement :: ";
85375 0 : std::cout << " p_taskloop is not in memory pool of ";
85376 0 : std::cout << p_taskloop->class_name() << std::endl;
85377 : }
85378 : }
85379 : else
85380 : {
85381 0 : std::cout << "SgUpirLoopParallelStatement :: " << std::flush;
85382 0 : std::cout << "SgStatement* p_taskloop = " << p_taskloop << " --> " << std::flush;
85383 0 : std::cout << " not valid " << std::endl;
85384 : }
85385 : }
85386 :
85387 0 : if ( p_loop != NULL )
85388 : {
85389 0 : if ( p_loop->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85390 : {
85391 0 : if ( p_loop->isInMemoryPool() == false )
85392 : {
85393 0 : std::cout << "SgUpirLoopParallelStatement :: ";
85394 0 : std::cout << " p_loop is not in memory pool of ";
85395 0 : std::cout << p_loop->class_name() << std::endl;
85396 : }
85397 : }
85398 : else
85399 : {
85400 0 : std::cout << "SgUpirLoopParallelStatement :: " << std::flush;
85401 0 : std::cout << "SgStatement* p_loop = " << p_loop << " --> " << std::flush;
85402 0 : std::cout << " not valid " << std::endl;
85403 : }
85404 : }
85405 :
85406 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
85407 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
85408 : {
85409 0 : if ( (*i_clauses) != NULL )
85410 : {
85411 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85412 : {
85413 0 : if ( (*i_clauses)->isInMemoryPool() == false )
85414 : {
85415 0 : std::cout << "SgUpirLoopParallelStatement :: ";
85416 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
85417 0 : std::cout << (*i_clauses)->class_name() << std::endl;
85418 : }
85419 : }
85420 : else
85421 : {
85422 0 : std::cout << "SgUpirLoopParallelStatement :: " << std::flush;
85423 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
85424 0 : std::cout << " entry not valid " << std::endl;
85425 : }
85426 : }
85427 : else
85428 : {
85429 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
85430 : }
85431 : }
85432 :
85433 0 : if ( p_upir_parent != NULL )
85434 : {
85435 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85436 : {
85437 0 : if ( p_upir_parent->isInMemoryPool() == false )
85438 : {
85439 0 : std::cout << "SgUpirLoopParallelStatement :: ";
85440 0 : std::cout << " p_upir_parent is not in memory pool of ";
85441 0 : std::cout << p_upir_parent->class_name() << std::endl;
85442 : }
85443 : }
85444 : else
85445 : {
85446 0 : std::cout << "SgUpirLoopParallelStatement :: " << std::flush;
85447 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
85448 0 : std::cout << " not valid " << std::endl;
85449 : }
85450 : }
85451 :
85452 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
85453 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
85454 : {
85455 0 : if ( (*i_upir_children) != NULL )
85456 : {
85457 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85458 : {
85459 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
85460 : {
85461 0 : std::cout << "SgUpirLoopParallelStatement :: ";
85462 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
85463 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
85464 : }
85465 : }
85466 : else
85467 : {
85468 0 : std::cout << "SgUpirLoopParallelStatement :: " << std::flush;
85469 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
85470 0 : std::cout << " entry not valid " << std::endl;
85471 : }
85472 : }
85473 : else
85474 : {
85475 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
85476 : }
85477 : }
85478 :
85479 0 : if ( p_numeric_label != NULL )
85480 : {
85481 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85482 : {
85483 0 : if ( p_numeric_label->isInMemoryPool() == false )
85484 : {
85485 0 : std::cout << "SgUpirLoopParallelStatement :: ";
85486 0 : std::cout << " p_numeric_label is not in memory pool of ";
85487 0 : std::cout << p_numeric_label->class_name() << std::endl;
85488 : }
85489 : }
85490 : else
85491 : {
85492 0 : std::cout << "SgUpirLoopParallelStatement :: " << std::flush;
85493 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
85494 0 : std::cout << " not valid " << std::endl;
85495 : }
85496 : }
85497 :
85498 0 : if ( p_startOfConstruct != NULL )
85499 : {
85500 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85501 : {
85502 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
85503 : {
85504 0 : std::cout << "SgUpirLoopParallelStatement :: ";
85505 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
85506 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
85507 : }
85508 : }
85509 : else
85510 : {
85511 0 : std::cout << "SgUpirLoopParallelStatement :: " << std::flush;
85512 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
85513 0 : std::cout << " not valid " << std::endl;
85514 : }
85515 : }
85516 :
85517 0 : if ( p_endOfConstruct != NULL )
85518 : {
85519 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85520 : {
85521 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
85522 : {
85523 0 : std::cout << "SgUpirLoopParallelStatement :: ";
85524 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
85525 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
85526 : }
85527 : }
85528 : else
85529 : {
85530 0 : std::cout << "SgUpirLoopParallelStatement :: " << std::flush;
85531 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
85532 0 : std::cout << " not valid " << std::endl;
85533 : }
85534 : }
85535 :
85536 0 : if ( p_parent != NULL )
85537 : {
85538 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85539 : {
85540 0 : if ( p_parent->isInMemoryPool() == false )
85541 : {
85542 0 : std::cout << "SgUpirLoopParallelStatement :: ";
85543 0 : std::cout << " p_parent is not in memory pool of ";
85544 0 : std::cout << p_parent->class_name() << std::endl;
85545 : }
85546 : }
85547 : else
85548 : {
85549 0 : std::cout << "SgUpirLoopParallelStatement :: " << std::flush;
85550 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
85551 0 : std::cout << " not valid " << std::endl;
85552 : }
85553 : }
85554 :
85555 :
85556 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
85557 :
85558 0 : }
85559 :
85560 :
85561 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
85562 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
85563 : bool
85564 0 : SgUpirLoopParallelStatement::isInMemoryPool ()
85565 : {
85566 0 : typedef unsigned char* TestType;
85567 :
85568 0 : bool found = false;
85569 :
85570 0 : ROSE_ASSERT(this != NULL);
85571 :
85572 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
85573 :
85574 0 : TestType tested = (TestType) ( this ) ;
85575 :
85576 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirLoopParallelStatement::pools.begin();
85577 :
85578 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
85579 : // while (found == false && block < Memory_Block_List.end())
85580 0 : while ( (found == false) && (block != SgUpirLoopParallelStatement::pools.end()) )
85581 : {
85582 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirLoopParallelStatement::pool_size * sizeof(SgUpirLoopParallelStatement) ) ) ;
85583 0 : ++block;
85584 : }
85585 :
85586 : // Special handling for static data
85587 :
85588 :
85589 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
85590 0 : ROSE_ASSERT(found == true);
85591 :
85592 0 : return found;
85593 : }
85594 : /* #line 85595 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
85595 :
85596 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
85597 :
85598 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
85599 :
85600 : /* #line 85601 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
85601 :
85602 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
85603 :
85604 : void
85605 0 : SgUpirWorksharingStatement::checkDataMemberPointersIfInMemoryPool()
85606 : {
85607 : // ------------ checking pointers of SgUpirWorksharingStatement -------------------
85608 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
85609 :
85610 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
85611 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
85612 : {
85613 0 : if ( (*i_clauses) != NULL )
85614 : {
85615 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85616 : {
85617 0 : if ( (*i_clauses)->isInMemoryPool() == false )
85618 : {
85619 0 : std::cout << "SgUpirWorksharingStatement :: ";
85620 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
85621 0 : std::cout << (*i_clauses)->class_name() << std::endl;
85622 : }
85623 : }
85624 : else
85625 : {
85626 0 : std::cout << "SgUpirWorksharingStatement :: " << std::flush;
85627 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
85628 0 : std::cout << " entry not valid " << std::endl;
85629 : }
85630 : }
85631 : else
85632 : {
85633 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
85634 : }
85635 : }
85636 :
85637 0 : if ( p_upir_parent != NULL )
85638 : {
85639 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85640 : {
85641 0 : if ( p_upir_parent->isInMemoryPool() == false )
85642 : {
85643 0 : std::cout << "SgUpirWorksharingStatement :: ";
85644 0 : std::cout << " p_upir_parent is not in memory pool of ";
85645 0 : std::cout << p_upir_parent->class_name() << std::endl;
85646 : }
85647 : }
85648 : else
85649 : {
85650 0 : std::cout << "SgUpirWorksharingStatement :: " << std::flush;
85651 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
85652 0 : std::cout << " not valid " << std::endl;
85653 : }
85654 : }
85655 :
85656 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
85657 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
85658 : {
85659 0 : if ( (*i_upir_children) != NULL )
85660 : {
85661 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85662 : {
85663 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
85664 : {
85665 0 : std::cout << "SgUpirWorksharingStatement :: ";
85666 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
85667 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
85668 : }
85669 : }
85670 : else
85671 : {
85672 0 : std::cout << "SgUpirWorksharingStatement :: " << std::flush;
85673 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
85674 0 : std::cout << " entry not valid " << std::endl;
85675 : }
85676 : }
85677 : else
85678 : {
85679 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
85680 : }
85681 : }
85682 :
85683 0 : if ( p_numeric_label != NULL )
85684 : {
85685 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85686 : {
85687 0 : if ( p_numeric_label->isInMemoryPool() == false )
85688 : {
85689 0 : std::cout << "SgUpirWorksharingStatement :: ";
85690 0 : std::cout << " p_numeric_label is not in memory pool of ";
85691 0 : std::cout << p_numeric_label->class_name() << std::endl;
85692 : }
85693 : }
85694 : else
85695 : {
85696 0 : std::cout << "SgUpirWorksharingStatement :: " << std::flush;
85697 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
85698 0 : std::cout << " not valid " << std::endl;
85699 : }
85700 : }
85701 :
85702 0 : if ( p_startOfConstruct != NULL )
85703 : {
85704 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85705 : {
85706 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
85707 : {
85708 0 : std::cout << "SgUpirWorksharingStatement :: ";
85709 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
85710 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
85711 : }
85712 : }
85713 : else
85714 : {
85715 0 : std::cout << "SgUpirWorksharingStatement :: " << std::flush;
85716 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
85717 0 : std::cout << " not valid " << std::endl;
85718 : }
85719 : }
85720 :
85721 0 : if ( p_endOfConstruct != NULL )
85722 : {
85723 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85724 : {
85725 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
85726 : {
85727 0 : std::cout << "SgUpirWorksharingStatement :: ";
85728 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
85729 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
85730 : }
85731 : }
85732 : else
85733 : {
85734 0 : std::cout << "SgUpirWorksharingStatement :: " << std::flush;
85735 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
85736 0 : std::cout << " not valid " << std::endl;
85737 : }
85738 : }
85739 :
85740 0 : if ( p_parent != NULL )
85741 : {
85742 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85743 : {
85744 0 : if ( p_parent->isInMemoryPool() == false )
85745 : {
85746 0 : std::cout << "SgUpirWorksharingStatement :: ";
85747 0 : std::cout << " p_parent is not in memory pool of ";
85748 0 : std::cout << p_parent->class_name() << std::endl;
85749 : }
85750 : }
85751 : else
85752 : {
85753 0 : std::cout << "SgUpirWorksharingStatement :: " << std::flush;
85754 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
85755 0 : std::cout << " not valid " << std::endl;
85756 : }
85757 : }
85758 :
85759 :
85760 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
85761 :
85762 0 : }
85763 :
85764 :
85765 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
85766 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
85767 : bool
85768 0 : SgUpirWorksharingStatement::isInMemoryPool ()
85769 : {
85770 0 : typedef unsigned char* TestType;
85771 :
85772 0 : bool found = false;
85773 :
85774 0 : ROSE_ASSERT(this != NULL);
85775 :
85776 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
85777 :
85778 0 : TestType tested = (TestType) ( this ) ;
85779 :
85780 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirWorksharingStatement::pools.begin();
85781 :
85782 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
85783 : // while (found == false && block < Memory_Block_List.end())
85784 0 : while ( (found == false) && (block != SgUpirWorksharingStatement::pools.end()) )
85785 : {
85786 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirWorksharingStatement::pool_size * sizeof(SgUpirWorksharingStatement) ) ) ;
85787 0 : ++block;
85788 : }
85789 :
85790 : // Special handling for static data
85791 :
85792 :
85793 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
85794 0 : ROSE_ASSERT(found == true);
85795 :
85796 0 : return found;
85797 : }
85798 : /* #line 85799 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
85799 :
85800 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
85801 :
85802 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
85803 :
85804 : /* #line 85805 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
85805 :
85806 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
85807 :
85808 : void
85809 0 : SgUpirSimdStatement::checkDataMemberPointersIfInMemoryPool()
85810 : {
85811 : // ------------ checking pointers of SgUpirSimdStatement -------------------
85812 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
85813 :
85814 0 : SgOmpClausePtrList::iterator i_clauses = p_clauses.begin() ;
85815 0 : for ( ; i_clauses != p_clauses.end(); ++i_clauses )
85816 : {
85817 0 : if ( (*i_clauses) != NULL )
85818 : {
85819 0 : if ( (*i_clauses)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85820 : {
85821 0 : if ( (*i_clauses)->isInMemoryPool() == false )
85822 : {
85823 0 : std::cout << "SgUpirSimdStatement :: ";
85824 0 : std::cout << " p_clauses ( list of poitners to IR nodes ), entry is not in memory pool of ";
85825 0 : std::cout << (*i_clauses)->class_name() << std::endl;
85826 : }
85827 : }
85828 : else
85829 : {
85830 0 : std::cout << "SgUpirSimdStatement :: " << std::flush;
85831 0 : std::cout << "SgOmpClausePtrList p_clauses --> " << std::flush;
85832 0 : std::cout << " entry not valid " << std::endl;
85833 : }
85834 : }
85835 : else
85836 : {
85837 0 : std::cout << "SgOmpClausePtrList p_clauses --> NULL " << std::endl;
85838 : }
85839 : }
85840 :
85841 0 : if ( p_upir_parent != NULL )
85842 : {
85843 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85844 : {
85845 0 : if ( p_upir_parent->isInMemoryPool() == false )
85846 : {
85847 0 : std::cout << "SgUpirSimdStatement :: ";
85848 0 : std::cout << " p_upir_parent is not in memory pool of ";
85849 0 : std::cout << p_upir_parent->class_name() << std::endl;
85850 : }
85851 : }
85852 : else
85853 : {
85854 0 : std::cout << "SgUpirSimdStatement :: " << std::flush;
85855 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
85856 0 : std::cout << " not valid " << std::endl;
85857 : }
85858 : }
85859 :
85860 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
85861 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
85862 : {
85863 0 : if ( (*i_upir_children) != NULL )
85864 : {
85865 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85866 : {
85867 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
85868 : {
85869 0 : std::cout << "SgUpirSimdStatement :: ";
85870 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
85871 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
85872 : }
85873 : }
85874 : else
85875 : {
85876 0 : std::cout << "SgUpirSimdStatement :: " << std::flush;
85877 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
85878 0 : std::cout << " entry not valid " << std::endl;
85879 : }
85880 : }
85881 : else
85882 : {
85883 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
85884 : }
85885 : }
85886 :
85887 0 : if ( p_numeric_label != NULL )
85888 : {
85889 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85890 : {
85891 0 : if ( p_numeric_label->isInMemoryPool() == false )
85892 : {
85893 0 : std::cout << "SgUpirSimdStatement :: ";
85894 0 : std::cout << " p_numeric_label is not in memory pool of ";
85895 0 : std::cout << p_numeric_label->class_name() << std::endl;
85896 : }
85897 : }
85898 : else
85899 : {
85900 0 : std::cout << "SgUpirSimdStatement :: " << std::flush;
85901 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
85902 0 : std::cout << " not valid " << std::endl;
85903 : }
85904 : }
85905 :
85906 0 : if ( p_startOfConstruct != NULL )
85907 : {
85908 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85909 : {
85910 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
85911 : {
85912 0 : std::cout << "SgUpirSimdStatement :: ";
85913 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
85914 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
85915 : }
85916 : }
85917 : else
85918 : {
85919 0 : std::cout << "SgUpirSimdStatement :: " << std::flush;
85920 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
85921 0 : std::cout << " not valid " << std::endl;
85922 : }
85923 : }
85924 :
85925 0 : if ( p_endOfConstruct != NULL )
85926 : {
85927 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85928 : {
85929 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
85930 : {
85931 0 : std::cout << "SgUpirSimdStatement :: ";
85932 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
85933 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
85934 : }
85935 : }
85936 : else
85937 : {
85938 0 : std::cout << "SgUpirSimdStatement :: " << std::flush;
85939 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
85940 0 : std::cout << " not valid " << std::endl;
85941 : }
85942 : }
85943 :
85944 0 : if ( p_parent != NULL )
85945 : {
85946 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
85947 : {
85948 0 : if ( p_parent->isInMemoryPool() == false )
85949 : {
85950 0 : std::cout << "SgUpirSimdStatement :: ";
85951 0 : std::cout << " p_parent is not in memory pool of ";
85952 0 : std::cout << p_parent->class_name() << std::endl;
85953 : }
85954 : }
85955 : else
85956 : {
85957 0 : std::cout << "SgUpirSimdStatement :: " << std::flush;
85958 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
85959 0 : std::cout << " not valid " << std::endl;
85960 : }
85961 : }
85962 :
85963 :
85964 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
85965 :
85966 0 : }
85967 :
85968 :
85969 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
85970 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
85971 : bool
85972 0 : SgUpirSimdStatement::isInMemoryPool ()
85973 : {
85974 0 : typedef unsigned char* TestType;
85975 :
85976 0 : bool found = false;
85977 :
85978 0 : ROSE_ASSERT(this != NULL);
85979 :
85980 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
85981 :
85982 0 : TestType tested = (TestType) ( this ) ;
85983 :
85984 0 : std::vector < unsigned char* > :: const_iterator block = SgUpirSimdStatement::pools.begin();
85985 :
85986 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
85987 : // while (found == false && block < Memory_Block_List.end())
85988 0 : while ( (found == false) && (block != SgUpirSimdStatement::pools.end()) )
85989 : {
85990 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpirSimdStatement::pool_size * sizeof(SgUpirSimdStatement) ) ) ;
85991 0 : ++block;
85992 : }
85993 :
85994 : // Special handling for static data
85995 :
85996 :
85997 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
85998 0 : ROSE_ASSERT(found == true);
85999 :
86000 0 : return found;
86001 : }
86002 : /* #line 86003 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
86003 :
86004 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
86005 :
86006 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86007 :
86008 : /* #line 86009 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
86009 :
86010 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86011 :
86012 : void
86013 0 : SgOmpDeclareMapperStatement::checkDataMemberPointersIfInMemoryPool()
86014 : {
86015 : // ------------ checking pointers of SgOmpDeclareMapperStatement -------------------
86016 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
86017 :
86018 0 : if ( p_upir_parent != NULL )
86019 : {
86020 0 : if ( p_upir_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86021 : {
86022 0 : if ( p_upir_parent->isInMemoryPool() == false )
86023 : {
86024 0 : std::cout << "SgOmpDeclareMapperStatement :: ";
86025 0 : std::cout << " p_upir_parent is not in memory pool of ";
86026 0 : std::cout << p_upir_parent->class_name() << std::endl;
86027 : }
86028 : }
86029 : else
86030 : {
86031 0 : std::cout << "SgOmpDeclareMapperStatement :: " << std::flush;
86032 0 : std::cout << "SgStatement* p_upir_parent = " << p_upir_parent << " --> " << std::flush;
86033 0 : std::cout << " not valid " << std::endl;
86034 : }
86035 : }
86036 :
86037 0 : SgStatementPtrList::iterator i_upir_children = p_upir_children.begin() ;
86038 0 : for ( ; i_upir_children != p_upir_children.end(); ++i_upir_children )
86039 : {
86040 0 : if ( (*i_upir_children) != NULL )
86041 : {
86042 0 : if ( (*i_upir_children)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86043 : {
86044 0 : if ( (*i_upir_children)->isInMemoryPool() == false )
86045 : {
86046 0 : std::cout << "SgOmpDeclareMapperStatement :: ";
86047 0 : std::cout << " p_upir_children ( list of poitners to IR nodes ), entry is not in memory pool of ";
86048 0 : std::cout << (*i_upir_children)->class_name() << std::endl;
86049 : }
86050 : }
86051 : else
86052 : {
86053 0 : std::cout << "SgOmpDeclareMapperStatement :: " << std::flush;
86054 0 : std::cout << "SgStatementPtrList p_upir_children --> " << std::flush;
86055 0 : std::cout << " entry not valid " << std::endl;
86056 : }
86057 : }
86058 : else
86059 : {
86060 0 : std::cout << "SgStatementPtrList p_upir_children --> NULL " << std::endl;
86061 : }
86062 : }
86063 :
86064 0 : if ( p_numeric_label != NULL )
86065 : {
86066 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86067 : {
86068 0 : if ( p_numeric_label->isInMemoryPool() == false )
86069 : {
86070 0 : std::cout << "SgOmpDeclareMapperStatement :: ";
86071 0 : std::cout << " p_numeric_label is not in memory pool of ";
86072 0 : std::cout << p_numeric_label->class_name() << std::endl;
86073 : }
86074 : }
86075 : else
86076 : {
86077 0 : std::cout << "SgOmpDeclareMapperStatement :: " << std::flush;
86078 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
86079 0 : std::cout << " not valid " << std::endl;
86080 : }
86081 : }
86082 :
86083 0 : if ( p_startOfConstruct != NULL )
86084 : {
86085 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86086 : {
86087 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
86088 : {
86089 0 : std::cout << "SgOmpDeclareMapperStatement :: ";
86090 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
86091 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
86092 : }
86093 : }
86094 : else
86095 : {
86096 0 : std::cout << "SgOmpDeclareMapperStatement :: " << std::flush;
86097 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
86098 0 : std::cout << " not valid " << std::endl;
86099 : }
86100 : }
86101 :
86102 0 : if ( p_endOfConstruct != NULL )
86103 : {
86104 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86105 : {
86106 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
86107 : {
86108 0 : std::cout << "SgOmpDeclareMapperStatement :: ";
86109 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
86110 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
86111 : }
86112 : }
86113 : else
86114 : {
86115 0 : std::cout << "SgOmpDeclareMapperStatement :: " << std::flush;
86116 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
86117 0 : std::cout << " not valid " << std::endl;
86118 : }
86119 : }
86120 :
86121 0 : if ( p_parent != NULL )
86122 : {
86123 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86124 : {
86125 0 : if ( p_parent->isInMemoryPool() == false )
86126 : {
86127 0 : std::cout << "SgOmpDeclareMapperStatement :: ";
86128 0 : std::cout << " p_parent is not in memory pool of ";
86129 0 : std::cout << p_parent->class_name() << std::endl;
86130 : }
86131 : }
86132 : else
86133 : {
86134 0 : std::cout << "SgOmpDeclareMapperStatement :: " << std::flush;
86135 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
86136 0 : std::cout << " not valid " << std::endl;
86137 : }
86138 : }
86139 :
86140 :
86141 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86142 :
86143 0 : }
86144 :
86145 :
86146 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
86147 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
86148 : bool
86149 0 : SgOmpDeclareMapperStatement::isInMemoryPool ()
86150 : {
86151 0 : typedef unsigned char* TestType;
86152 :
86153 0 : bool found = false;
86154 :
86155 0 : ROSE_ASSERT(this != NULL);
86156 :
86157 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
86158 :
86159 0 : TestType tested = (TestType) ( this ) ;
86160 :
86161 0 : std::vector < unsigned char* > :: const_iterator block = SgOmpDeclareMapperStatement::pools.begin();
86162 :
86163 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
86164 : // while (found == false && block < Memory_Block_List.end())
86165 0 : while ( (found == false) && (block != SgOmpDeclareMapperStatement::pools.end()) )
86166 : {
86167 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOmpDeclareMapperStatement::pool_size * sizeof(SgOmpDeclareMapperStatement) ) ) ;
86168 0 : ++block;
86169 : }
86170 :
86171 : // Special handling for static data
86172 :
86173 :
86174 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
86175 0 : ROSE_ASSERT(found == true);
86176 :
86177 0 : return found;
86178 : }
86179 : /* #line 86180 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
86180 :
86181 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
86182 :
86183 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86184 :
86185 : /* #line 86186 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
86186 :
86187 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86188 :
86189 : void
86190 0 : SgSequenceStatement::checkDataMemberPointersIfInMemoryPool()
86191 : {
86192 : // ------------ checking pointers of SgSequenceStatement -------------------
86193 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
86194 :
86195 0 : if ( p_numeric_label != NULL )
86196 : {
86197 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86198 : {
86199 0 : if ( p_numeric_label->isInMemoryPool() == false )
86200 : {
86201 0 : std::cout << "SgSequenceStatement :: ";
86202 0 : std::cout << " p_numeric_label is not in memory pool of ";
86203 0 : std::cout << p_numeric_label->class_name() << std::endl;
86204 : }
86205 : }
86206 : else
86207 : {
86208 0 : std::cout << "SgSequenceStatement :: " << std::flush;
86209 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
86210 0 : std::cout << " not valid " << std::endl;
86211 : }
86212 : }
86213 :
86214 0 : if ( p_startOfConstruct != NULL )
86215 : {
86216 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86217 : {
86218 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
86219 : {
86220 0 : std::cout << "SgSequenceStatement :: ";
86221 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
86222 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
86223 : }
86224 : }
86225 : else
86226 : {
86227 0 : std::cout << "SgSequenceStatement :: " << std::flush;
86228 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
86229 0 : std::cout << " not valid " << std::endl;
86230 : }
86231 : }
86232 :
86233 0 : if ( p_endOfConstruct != NULL )
86234 : {
86235 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86236 : {
86237 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
86238 : {
86239 0 : std::cout << "SgSequenceStatement :: ";
86240 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
86241 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
86242 : }
86243 : }
86244 : else
86245 : {
86246 0 : std::cout << "SgSequenceStatement :: " << std::flush;
86247 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
86248 0 : std::cout << " not valid " << std::endl;
86249 : }
86250 : }
86251 :
86252 0 : if ( p_parent != NULL )
86253 : {
86254 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86255 : {
86256 0 : if ( p_parent->isInMemoryPool() == false )
86257 : {
86258 0 : std::cout << "SgSequenceStatement :: ";
86259 0 : std::cout << " p_parent is not in memory pool of ";
86260 0 : std::cout << p_parent->class_name() << std::endl;
86261 : }
86262 : }
86263 : else
86264 : {
86265 0 : std::cout << "SgSequenceStatement :: " << std::flush;
86266 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
86267 0 : std::cout << " not valid " << std::endl;
86268 : }
86269 : }
86270 :
86271 :
86272 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86273 :
86274 0 : }
86275 :
86276 :
86277 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
86278 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
86279 : bool
86280 0 : SgSequenceStatement::isInMemoryPool ()
86281 : {
86282 0 : typedef unsigned char* TestType;
86283 :
86284 0 : bool found = false;
86285 :
86286 0 : ROSE_ASSERT(this != NULL);
86287 :
86288 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
86289 :
86290 0 : TestType tested = (TestType) ( this ) ;
86291 :
86292 0 : std::vector < unsigned char* > :: const_iterator block = SgSequenceStatement::pools.begin();
86293 :
86294 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
86295 : // while (found == false && block < Memory_Block_List.end())
86296 0 : while ( (found == false) && (block != SgSequenceStatement::pools.end()) )
86297 : {
86298 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSequenceStatement::pool_size * sizeof(SgSequenceStatement) ) ) ;
86299 0 : ++block;
86300 : }
86301 :
86302 : // Special handling for static data
86303 :
86304 :
86305 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
86306 0 : ROSE_ASSERT(found == true);
86307 :
86308 0 : return found;
86309 : }
86310 : /* #line 86311 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
86311 :
86312 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
86313 :
86314 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86315 :
86316 : /* #line 86317 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
86317 :
86318 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86319 :
86320 : void
86321 0 : SgWithStatement::checkDataMemberPointersIfInMemoryPool()
86322 : {
86323 : // ------------ checking pointers of SgWithStatement -------------------
86324 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
86325 :
86326 0 : if ( p_expression != NULL )
86327 : {
86328 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86329 : {
86330 0 : if ( p_expression->isInMemoryPool() == false )
86331 : {
86332 0 : std::cout << "SgWithStatement :: ";
86333 0 : std::cout << " p_expression is not in memory pool of ";
86334 0 : std::cout << p_expression->class_name() << std::endl;
86335 : }
86336 : }
86337 : else
86338 : {
86339 0 : std::cout << "SgWithStatement :: " << std::flush;
86340 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
86341 0 : std::cout << " not valid " << std::endl;
86342 : }
86343 : }
86344 :
86345 0 : if ( p_body != NULL )
86346 : {
86347 0 : if ( p_body->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86348 : {
86349 0 : if ( p_body->isInMemoryPool() == false )
86350 : {
86351 0 : std::cout << "SgWithStatement :: ";
86352 0 : std::cout << " p_body is not in memory pool of ";
86353 0 : std::cout << p_body->class_name() << std::endl;
86354 : }
86355 : }
86356 : else
86357 : {
86358 0 : std::cout << "SgWithStatement :: " << std::flush;
86359 0 : std::cout << "SgStatement* p_body = " << p_body << " --> " << std::flush;
86360 0 : std::cout << " not valid " << std::endl;
86361 : }
86362 : }
86363 :
86364 0 : if ( p_numeric_label != NULL )
86365 : {
86366 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86367 : {
86368 0 : if ( p_numeric_label->isInMemoryPool() == false )
86369 : {
86370 0 : std::cout << "SgWithStatement :: ";
86371 0 : std::cout << " p_numeric_label is not in memory pool of ";
86372 0 : std::cout << p_numeric_label->class_name() << std::endl;
86373 : }
86374 : }
86375 : else
86376 : {
86377 0 : std::cout << "SgWithStatement :: " << std::flush;
86378 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
86379 0 : std::cout << " not valid " << std::endl;
86380 : }
86381 : }
86382 :
86383 0 : if ( p_startOfConstruct != NULL )
86384 : {
86385 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86386 : {
86387 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
86388 : {
86389 0 : std::cout << "SgWithStatement :: ";
86390 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
86391 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
86392 : }
86393 : }
86394 : else
86395 : {
86396 0 : std::cout << "SgWithStatement :: " << std::flush;
86397 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
86398 0 : std::cout << " not valid " << std::endl;
86399 : }
86400 : }
86401 :
86402 0 : if ( p_endOfConstruct != NULL )
86403 : {
86404 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86405 : {
86406 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
86407 : {
86408 0 : std::cout << "SgWithStatement :: ";
86409 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
86410 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
86411 : }
86412 : }
86413 : else
86414 : {
86415 0 : std::cout << "SgWithStatement :: " << std::flush;
86416 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
86417 0 : std::cout << " not valid " << std::endl;
86418 : }
86419 : }
86420 :
86421 0 : if ( p_parent != NULL )
86422 : {
86423 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86424 : {
86425 0 : if ( p_parent->isInMemoryPool() == false )
86426 : {
86427 0 : std::cout << "SgWithStatement :: ";
86428 0 : std::cout << " p_parent is not in memory pool of ";
86429 0 : std::cout << p_parent->class_name() << std::endl;
86430 : }
86431 : }
86432 : else
86433 : {
86434 0 : std::cout << "SgWithStatement :: " << std::flush;
86435 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
86436 0 : std::cout << " not valid " << std::endl;
86437 : }
86438 : }
86439 :
86440 :
86441 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86442 :
86443 0 : }
86444 :
86445 :
86446 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
86447 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
86448 : bool
86449 0 : SgWithStatement::isInMemoryPool ()
86450 : {
86451 0 : typedef unsigned char* TestType;
86452 :
86453 0 : bool found = false;
86454 :
86455 0 : ROSE_ASSERT(this != NULL);
86456 :
86457 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
86458 :
86459 0 : TestType tested = (TestType) ( this ) ;
86460 :
86461 0 : std::vector < unsigned char* > :: const_iterator block = SgWithStatement::pools.begin();
86462 :
86463 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
86464 : // while (found == false && block < Memory_Block_List.end())
86465 0 : while ( (found == false) && (block != SgWithStatement::pools.end()) )
86466 : {
86467 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgWithStatement::pool_size * sizeof(SgWithStatement) ) ) ;
86468 0 : ++block;
86469 : }
86470 :
86471 : // Special handling for static data
86472 :
86473 :
86474 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
86475 0 : ROSE_ASSERT(found == true);
86476 :
86477 0 : return found;
86478 : }
86479 : /* #line 86480 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
86480 :
86481 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
86482 :
86483 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86484 :
86485 : /* #line 86486 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
86486 :
86487 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86488 :
86489 : void
86490 0 : SgPassStatement::checkDataMemberPointersIfInMemoryPool()
86491 : {
86492 : // ------------ checking pointers of SgPassStatement -------------------
86493 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
86494 :
86495 0 : if ( p_numeric_label != NULL )
86496 : {
86497 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86498 : {
86499 0 : if ( p_numeric_label->isInMemoryPool() == false )
86500 : {
86501 0 : std::cout << "SgPassStatement :: ";
86502 0 : std::cout << " p_numeric_label is not in memory pool of ";
86503 0 : std::cout << p_numeric_label->class_name() << std::endl;
86504 : }
86505 : }
86506 : else
86507 : {
86508 0 : std::cout << "SgPassStatement :: " << std::flush;
86509 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
86510 0 : std::cout << " not valid " << std::endl;
86511 : }
86512 : }
86513 :
86514 0 : if ( p_startOfConstruct != NULL )
86515 : {
86516 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86517 : {
86518 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
86519 : {
86520 0 : std::cout << "SgPassStatement :: ";
86521 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
86522 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
86523 : }
86524 : }
86525 : else
86526 : {
86527 0 : std::cout << "SgPassStatement :: " << std::flush;
86528 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
86529 0 : std::cout << " not valid " << std::endl;
86530 : }
86531 : }
86532 :
86533 0 : if ( p_endOfConstruct != NULL )
86534 : {
86535 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86536 : {
86537 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
86538 : {
86539 0 : std::cout << "SgPassStatement :: ";
86540 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
86541 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
86542 : }
86543 : }
86544 : else
86545 : {
86546 0 : std::cout << "SgPassStatement :: " << std::flush;
86547 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
86548 0 : std::cout << " not valid " << std::endl;
86549 : }
86550 : }
86551 :
86552 0 : if ( p_parent != NULL )
86553 : {
86554 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86555 : {
86556 0 : if ( p_parent->isInMemoryPool() == false )
86557 : {
86558 0 : std::cout << "SgPassStatement :: ";
86559 0 : std::cout << " p_parent is not in memory pool of ";
86560 0 : std::cout << p_parent->class_name() << std::endl;
86561 : }
86562 : }
86563 : else
86564 : {
86565 0 : std::cout << "SgPassStatement :: " << std::flush;
86566 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
86567 0 : std::cout << " not valid " << std::endl;
86568 : }
86569 : }
86570 :
86571 :
86572 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86573 :
86574 0 : }
86575 :
86576 :
86577 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
86578 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
86579 : bool
86580 0 : SgPassStatement::isInMemoryPool ()
86581 : {
86582 0 : typedef unsigned char* TestType;
86583 :
86584 0 : bool found = false;
86585 :
86586 0 : ROSE_ASSERT(this != NULL);
86587 :
86588 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
86589 :
86590 0 : TestType tested = (TestType) ( this ) ;
86591 :
86592 0 : std::vector < unsigned char* > :: const_iterator block = SgPassStatement::pools.begin();
86593 :
86594 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
86595 : // while (found == false && block < Memory_Block_List.end())
86596 0 : while ( (found == false) && (block != SgPassStatement::pools.end()) )
86597 : {
86598 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgPassStatement::pool_size * sizeof(SgPassStatement) ) ) ;
86599 0 : ++block;
86600 : }
86601 :
86602 : // Special handling for static data
86603 :
86604 :
86605 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
86606 0 : ROSE_ASSERT(found == true);
86607 :
86608 0 : return found;
86609 : }
86610 : /* #line 86611 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
86611 :
86612 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
86613 :
86614 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86615 :
86616 : /* #line 86617 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
86617 :
86618 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86619 :
86620 : void
86621 0 : SgAssertStmt::checkDataMemberPointersIfInMemoryPool()
86622 : {
86623 : // ------------ checking pointers of SgAssertStmt -------------------
86624 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
86625 :
86626 0 : if ( p_test != NULL )
86627 : {
86628 0 : if ( p_test->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86629 : {
86630 0 : if ( p_test->isInMemoryPool() == false )
86631 : {
86632 0 : std::cout << "SgAssertStmt :: ";
86633 0 : std::cout << " p_test is not in memory pool of ";
86634 0 : std::cout << p_test->class_name() << std::endl;
86635 : }
86636 : }
86637 : else
86638 : {
86639 0 : std::cout << "SgAssertStmt :: " << std::flush;
86640 0 : std::cout << "SgExpression* p_test = " << p_test << " --> " << std::flush;
86641 0 : std::cout << " not valid " << std::endl;
86642 : }
86643 : }
86644 :
86645 0 : if ( p_exception_argument != NULL )
86646 : {
86647 0 : if ( p_exception_argument->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86648 : {
86649 0 : if ( p_exception_argument->isInMemoryPool() == false )
86650 : {
86651 0 : std::cout << "SgAssertStmt :: ";
86652 0 : std::cout << " p_exception_argument is not in memory pool of ";
86653 0 : std::cout << p_exception_argument->class_name() << std::endl;
86654 : }
86655 : }
86656 : else
86657 : {
86658 0 : std::cout << "SgAssertStmt :: " << std::flush;
86659 0 : std::cout << "SgExpression* p_exception_argument = " << p_exception_argument << " --> " << std::flush;
86660 0 : std::cout << " not valid " << std::endl;
86661 : }
86662 : }
86663 :
86664 0 : if ( p_numeric_label != NULL )
86665 : {
86666 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86667 : {
86668 0 : if ( p_numeric_label->isInMemoryPool() == false )
86669 : {
86670 0 : std::cout << "SgAssertStmt :: ";
86671 0 : std::cout << " p_numeric_label is not in memory pool of ";
86672 0 : std::cout << p_numeric_label->class_name() << std::endl;
86673 : }
86674 : }
86675 : else
86676 : {
86677 0 : std::cout << "SgAssertStmt :: " << std::flush;
86678 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
86679 0 : std::cout << " not valid " << std::endl;
86680 : }
86681 : }
86682 :
86683 0 : if ( p_startOfConstruct != NULL )
86684 : {
86685 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86686 : {
86687 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
86688 : {
86689 0 : std::cout << "SgAssertStmt :: ";
86690 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
86691 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
86692 : }
86693 : }
86694 : else
86695 : {
86696 0 : std::cout << "SgAssertStmt :: " << std::flush;
86697 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
86698 0 : std::cout << " not valid " << std::endl;
86699 : }
86700 : }
86701 :
86702 0 : if ( p_endOfConstruct != NULL )
86703 : {
86704 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86705 : {
86706 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
86707 : {
86708 0 : std::cout << "SgAssertStmt :: ";
86709 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
86710 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
86711 : }
86712 : }
86713 : else
86714 : {
86715 0 : std::cout << "SgAssertStmt :: " << std::flush;
86716 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
86717 0 : std::cout << " not valid " << std::endl;
86718 : }
86719 : }
86720 :
86721 0 : if ( p_parent != NULL )
86722 : {
86723 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86724 : {
86725 0 : if ( p_parent->isInMemoryPool() == false )
86726 : {
86727 0 : std::cout << "SgAssertStmt :: ";
86728 0 : std::cout << " p_parent is not in memory pool of ";
86729 0 : std::cout << p_parent->class_name() << std::endl;
86730 : }
86731 : }
86732 : else
86733 : {
86734 0 : std::cout << "SgAssertStmt :: " << std::flush;
86735 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
86736 0 : std::cout << " not valid " << std::endl;
86737 : }
86738 : }
86739 :
86740 :
86741 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86742 :
86743 0 : }
86744 :
86745 :
86746 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
86747 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
86748 : bool
86749 0 : SgAssertStmt::isInMemoryPool ()
86750 : {
86751 0 : typedef unsigned char* TestType;
86752 :
86753 0 : bool found = false;
86754 :
86755 0 : ROSE_ASSERT(this != NULL);
86756 :
86757 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
86758 :
86759 0 : TestType tested = (TestType) ( this ) ;
86760 :
86761 0 : std::vector < unsigned char* > :: const_iterator block = SgAssertStmt::pools.begin();
86762 :
86763 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
86764 : // while (found == false && block < Memory_Block_List.end())
86765 0 : while ( (found == false) && (block != SgAssertStmt::pools.end()) )
86766 : {
86767 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAssertStmt::pool_size * sizeof(SgAssertStmt) ) ) ;
86768 0 : ++block;
86769 : }
86770 :
86771 : // Special handling for static data
86772 :
86773 :
86774 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
86775 0 : ROSE_ASSERT(found == true);
86776 :
86777 0 : return found;
86778 : }
86779 : /* #line 86780 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
86780 :
86781 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
86782 :
86783 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86784 :
86785 : /* #line 86786 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
86786 :
86787 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86788 :
86789 : void
86790 0 : SgExecStatement::checkDataMemberPointersIfInMemoryPool()
86791 : {
86792 : // ------------ checking pointers of SgExecStatement -------------------
86793 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
86794 :
86795 0 : if ( p_executable != NULL )
86796 : {
86797 0 : if ( p_executable->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86798 : {
86799 0 : if ( p_executable->isInMemoryPool() == false )
86800 : {
86801 0 : std::cout << "SgExecStatement :: ";
86802 0 : std::cout << " p_executable is not in memory pool of ";
86803 0 : std::cout << p_executable->class_name() << std::endl;
86804 : }
86805 : }
86806 : else
86807 : {
86808 0 : std::cout << "SgExecStatement :: " << std::flush;
86809 0 : std::cout << "SgExpression* p_executable = " << p_executable << " --> " << std::flush;
86810 0 : std::cout << " not valid " << std::endl;
86811 : }
86812 : }
86813 :
86814 0 : if ( p_globals != NULL )
86815 : {
86816 0 : if ( p_globals->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86817 : {
86818 0 : if ( p_globals->isInMemoryPool() == false )
86819 : {
86820 0 : std::cout << "SgExecStatement :: ";
86821 0 : std::cout << " p_globals is not in memory pool of ";
86822 0 : std::cout << p_globals->class_name() << std::endl;
86823 : }
86824 : }
86825 : else
86826 : {
86827 0 : std::cout << "SgExecStatement :: " << std::flush;
86828 0 : std::cout << "SgExpression* p_globals = " << p_globals << " --> " << std::flush;
86829 0 : std::cout << " not valid " << std::endl;
86830 : }
86831 : }
86832 :
86833 0 : if ( p_locals != NULL )
86834 : {
86835 0 : if ( p_locals->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86836 : {
86837 0 : if ( p_locals->isInMemoryPool() == false )
86838 : {
86839 0 : std::cout << "SgExecStatement :: ";
86840 0 : std::cout << " p_locals is not in memory pool of ";
86841 0 : std::cout << p_locals->class_name() << std::endl;
86842 : }
86843 : }
86844 : else
86845 : {
86846 0 : std::cout << "SgExecStatement :: " << std::flush;
86847 0 : std::cout << "SgExpression* p_locals = " << p_locals << " --> " << std::flush;
86848 0 : std::cout << " not valid " << std::endl;
86849 : }
86850 : }
86851 :
86852 0 : if ( p_numeric_label != NULL )
86853 : {
86854 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86855 : {
86856 0 : if ( p_numeric_label->isInMemoryPool() == false )
86857 : {
86858 0 : std::cout << "SgExecStatement :: ";
86859 0 : std::cout << " p_numeric_label is not in memory pool of ";
86860 0 : std::cout << p_numeric_label->class_name() << std::endl;
86861 : }
86862 : }
86863 : else
86864 : {
86865 0 : std::cout << "SgExecStatement :: " << std::flush;
86866 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
86867 0 : std::cout << " not valid " << std::endl;
86868 : }
86869 : }
86870 :
86871 0 : if ( p_startOfConstruct != NULL )
86872 : {
86873 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86874 : {
86875 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
86876 : {
86877 0 : std::cout << "SgExecStatement :: ";
86878 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
86879 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
86880 : }
86881 : }
86882 : else
86883 : {
86884 0 : std::cout << "SgExecStatement :: " << std::flush;
86885 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
86886 0 : std::cout << " not valid " << std::endl;
86887 : }
86888 : }
86889 :
86890 0 : if ( p_endOfConstruct != NULL )
86891 : {
86892 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86893 : {
86894 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
86895 : {
86896 0 : std::cout << "SgExecStatement :: ";
86897 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
86898 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
86899 : }
86900 : }
86901 : else
86902 : {
86903 0 : std::cout << "SgExecStatement :: " << std::flush;
86904 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
86905 0 : std::cout << " not valid " << std::endl;
86906 : }
86907 : }
86908 :
86909 0 : if ( p_parent != NULL )
86910 : {
86911 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86912 : {
86913 0 : if ( p_parent->isInMemoryPool() == false )
86914 : {
86915 0 : std::cout << "SgExecStatement :: ";
86916 0 : std::cout << " p_parent is not in memory pool of ";
86917 0 : std::cout << p_parent->class_name() << std::endl;
86918 : }
86919 : }
86920 : else
86921 : {
86922 0 : std::cout << "SgExecStatement :: " << std::flush;
86923 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
86924 0 : std::cout << " not valid " << std::endl;
86925 : }
86926 : }
86927 :
86928 :
86929 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86930 :
86931 0 : }
86932 :
86933 :
86934 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
86935 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
86936 : bool
86937 0 : SgExecStatement::isInMemoryPool ()
86938 : {
86939 0 : typedef unsigned char* TestType;
86940 :
86941 0 : bool found = false;
86942 :
86943 0 : ROSE_ASSERT(this != NULL);
86944 :
86945 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
86946 :
86947 0 : TestType tested = (TestType) ( this ) ;
86948 :
86949 0 : std::vector < unsigned char* > :: const_iterator block = SgExecStatement::pools.begin();
86950 :
86951 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
86952 : // while (found == false && block < Memory_Block_List.end())
86953 0 : while ( (found == false) && (block != SgExecStatement::pools.end()) )
86954 : {
86955 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgExecStatement::pool_size * sizeof(SgExecStatement) ) ) ;
86956 0 : ++block;
86957 : }
86958 :
86959 : // Special handling for static data
86960 :
86961 :
86962 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
86963 0 : ROSE_ASSERT(found == true);
86964 :
86965 0 : return found;
86966 : }
86967 : /* #line 86968 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
86968 :
86969 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
86970 :
86971 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86972 :
86973 : /* #line 86974 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
86974 :
86975 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
86976 :
86977 : void
86978 0 : SgImageControlStatement::checkDataMemberPointersIfInMemoryPool()
86979 : {
86980 : // ------------ checking pointers of SgImageControlStatement -------------------
86981 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
86982 :
86983 0 : if ( p_stat != NULL )
86984 : {
86985 0 : if ( p_stat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
86986 : {
86987 0 : if ( p_stat->isInMemoryPool() == false )
86988 : {
86989 0 : std::cout << "SgImageControlStatement :: ";
86990 0 : std::cout << " p_stat is not in memory pool of ";
86991 0 : std::cout << p_stat->class_name() << std::endl;
86992 : }
86993 : }
86994 : else
86995 : {
86996 0 : std::cout << "SgImageControlStatement :: " << std::flush;
86997 0 : std::cout << "SgExpression* p_stat = " << p_stat << " --> " << std::flush;
86998 0 : std::cout << " not valid " << std::endl;
86999 : }
87000 : }
87001 :
87002 0 : if ( p_err_msg != NULL )
87003 : {
87004 0 : if ( p_err_msg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87005 : {
87006 0 : if ( p_err_msg->isInMemoryPool() == false )
87007 : {
87008 0 : std::cout << "SgImageControlStatement :: ";
87009 0 : std::cout << " p_err_msg is not in memory pool of ";
87010 0 : std::cout << p_err_msg->class_name() << std::endl;
87011 : }
87012 : }
87013 : else
87014 : {
87015 0 : std::cout << "SgImageControlStatement :: " << std::flush;
87016 0 : std::cout << "SgExpression* p_err_msg = " << p_err_msg << " --> " << std::flush;
87017 0 : std::cout << " not valid " << std::endl;
87018 : }
87019 : }
87020 :
87021 0 : if ( p_acquired_lock != NULL )
87022 : {
87023 0 : if ( p_acquired_lock->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87024 : {
87025 0 : if ( p_acquired_lock->isInMemoryPool() == false )
87026 : {
87027 0 : std::cout << "SgImageControlStatement :: ";
87028 0 : std::cout << " p_acquired_lock is not in memory pool of ";
87029 0 : std::cout << p_acquired_lock->class_name() << std::endl;
87030 : }
87031 : }
87032 : else
87033 : {
87034 0 : std::cout << "SgImageControlStatement :: " << std::flush;
87035 0 : std::cout << "SgExpression* p_acquired_lock = " << p_acquired_lock << " --> " << std::flush;
87036 0 : std::cout << " not valid " << std::endl;
87037 : }
87038 : }
87039 :
87040 0 : if ( p_numeric_label != NULL )
87041 : {
87042 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87043 : {
87044 0 : if ( p_numeric_label->isInMemoryPool() == false )
87045 : {
87046 0 : std::cout << "SgImageControlStatement :: ";
87047 0 : std::cout << " p_numeric_label is not in memory pool of ";
87048 0 : std::cout << p_numeric_label->class_name() << std::endl;
87049 : }
87050 : }
87051 : else
87052 : {
87053 0 : std::cout << "SgImageControlStatement :: " << std::flush;
87054 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
87055 0 : std::cout << " not valid " << std::endl;
87056 : }
87057 : }
87058 :
87059 0 : if ( p_startOfConstruct != NULL )
87060 : {
87061 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87062 : {
87063 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
87064 : {
87065 0 : std::cout << "SgImageControlStatement :: ";
87066 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
87067 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
87068 : }
87069 : }
87070 : else
87071 : {
87072 0 : std::cout << "SgImageControlStatement :: " << std::flush;
87073 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
87074 0 : std::cout << " not valid " << std::endl;
87075 : }
87076 : }
87077 :
87078 0 : if ( p_endOfConstruct != NULL )
87079 : {
87080 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87081 : {
87082 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
87083 : {
87084 0 : std::cout << "SgImageControlStatement :: ";
87085 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
87086 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
87087 : }
87088 : }
87089 : else
87090 : {
87091 0 : std::cout << "SgImageControlStatement :: " << std::flush;
87092 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
87093 0 : std::cout << " not valid " << std::endl;
87094 : }
87095 : }
87096 :
87097 0 : if ( p_parent != NULL )
87098 : {
87099 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87100 : {
87101 0 : if ( p_parent->isInMemoryPool() == false )
87102 : {
87103 0 : std::cout << "SgImageControlStatement :: ";
87104 0 : std::cout << " p_parent is not in memory pool of ";
87105 0 : std::cout << p_parent->class_name() << std::endl;
87106 : }
87107 : }
87108 : else
87109 : {
87110 0 : std::cout << "SgImageControlStatement :: " << std::flush;
87111 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
87112 0 : std::cout << " not valid " << std::endl;
87113 : }
87114 : }
87115 :
87116 :
87117 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
87118 :
87119 0 : }
87120 :
87121 :
87122 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
87123 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
87124 : bool
87125 0 : SgImageControlStatement::isInMemoryPool ()
87126 : {
87127 0 : typedef unsigned char* TestType;
87128 :
87129 0 : bool found = false;
87130 :
87131 0 : ROSE_ASSERT(this != NULL);
87132 :
87133 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
87134 :
87135 0 : TestType tested = (TestType) ( this ) ;
87136 :
87137 0 : std::vector < unsigned char* > :: const_iterator block = SgImageControlStatement::pools.begin();
87138 :
87139 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
87140 : // while (found == false && block < Memory_Block_List.end())
87141 0 : while ( (found == false) && (block != SgImageControlStatement::pools.end()) )
87142 : {
87143 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgImageControlStatement::pool_size * sizeof(SgImageControlStatement) ) ) ;
87144 0 : ++block;
87145 : }
87146 :
87147 : // Special handling for static data
87148 :
87149 :
87150 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
87151 0 : ROSE_ASSERT(found == true);
87152 :
87153 0 : return found;
87154 : }
87155 : /* #line 87156 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
87156 :
87157 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
87158 :
87159 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
87160 :
87161 : /* #line 87162 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
87162 :
87163 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
87164 :
87165 : void
87166 0 : SgSyncAllStatement::checkDataMemberPointersIfInMemoryPool()
87167 : {
87168 : // ------------ checking pointers of SgSyncAllStatement -------------------
87169 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
87170 :
87171 0 : if ( p_stat != NULL )
87172 : {
87173 0 : if ( p_stat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87174 : {
87175 0 : if ( p_stat->isInMemoryPool() == false )
87176 : {
87177 0 : std::cout << "SgSyncAllStatement :: ";
87178 0 : std::cout << " p_stat is not in memory pool of ";
87179 0 : std::cout << p_stat->class_name() << std::endl;
87180 : }
87181 : }
87182 : else
87183 : {
87184 0 : std::cout << "SgSyncAllStatement :: " << std::flush;
87185 0 : std::cout << "SgExpression* p_stat = " << p_stat << " --> " << std::flush;
87186 0 : std::cout << " not valid " << std::endl;
87187 : }
87188 : }
87189 :
87190 0 : if ( p_err_msg != NULL )
87191 : {
87192 0 : if ( p_err_msg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87193 : {
87194 0 : if ( p_err_msg->isInMemoryPool() == false )
87195 : {
87196 0 : std::cout << "SgSyncAllStatement :: ";
87197 0 : std::cout << " p_err_msg is not in memory pool of ";
87198 0 : std::cout << p_err_msg->class_name() << std::endl;
87199 : }
87200 : }
87201 : else
87202 : {
87203 0 : std::cout << "SgSyncAllStatement :: " << std::flush;
87204 0 : std::cout << "SgExpression* p_err_msg = " << p_err_msg << " --> " << std::flush;
87205 0 : std::cout << " not valid " << std::endl;
87206 : }
87207 : }
87208 :
87209 0 : if ( p_acquired_lock != NULL )
87210 : {
87211 0 : if ( p_acquired_lock->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87212 : {
87213 0 : if ( p_acquired_lock->isInMemoryPool() == false )
87214 : {
87215 0 : std::cout << "SgSyncAllStatement :: ";
87216 0 : std::cout << " p_acquired_lock is not in memory pool of ";
87217 0 : std::cout << p_acquired_lock->class_name() << std::endl;
87218 : }
87219 : }
87220 : else
87221 : {
87222 0 : std::cout << "SgSyncAllStatement :: " << std::flush;
87223 0 : std::cout << "SgExpression* p_acquired_lock = " << p_acquired_lock << " --> " << std::flush;
87224 0 : std::cout << " not valid " << std::endl;
87225 : }
87226 : }
87227 :
87228 0 : if ( p_numeric_label != NULL )
87229 : {
87230 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87231 : {
87232 0 : if ( p_numeric_label->isInMemoryPool() == false )
87233 : {
87234 0 : std::cout << "SgSyncAllStatement :: ";
87235 0 : std::cout << " p_numeric_label is not in memory pool of ";
87236 0 : std::cout << p_numeric_label->class_name() << std::endl;
87237 : }
87238 : }
87239 : else
87240 : {
87241 0 : std::cout << "SgSyncAllStatement :: " << std::flush;
87242 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
87243 0 : std::cout << " not valid " << std::endl;
87244 : }
87245 : }
87246 :
87247 0 : if ( p_startOfConstruct != NULL )
87248 : {
87249 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87250 : {
87251 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
87252 : {
87253 0 : std::cout << "SgSyncAllStatement :: ";
87254 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
87255 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
87256 : }
87257 : }
87258 : else
87259 : {
87260 0 : std::cout << "SgSyncAllStatement :: " << std::flush;
87261 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
87262 0 : std::cout << " not valid " << std::endl;
87263 : }
87264 : }
87265 :
87266 0 : if ( p_endOfConstruct != NULL )
87267 : {
87268 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87269 : {
87270 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
87271 : {
87272 0 : std::cout << "SgSyncAllStatement :: ";
87273 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
87274 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
87275 : }
87276 : }
87277 : else
87278 : {
87279 0 : std::cout << "SgSyncAllStatement :: " << std::flush;
87280 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
87281 0 : std::cout << " not valid " << std::endl;
87282 : }
87283 : }
87284 :
87285 0 : if ( p_parent != NULL )
87286 : {
87287 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87288 : {
87289 0 : if ( p_parent->isInMemoryPool() == false )
87290 : {
87291 0 : std::cout << "SgSyncAllStatement :: ";
87292 0 : std::cout << " p_parent is not in memory pool of ";
87293 0 : std::cout << p_parent->class_name() << std::endl;
87294 : }
87295 : }
87296 : else
87297 : {
87298 0 : std::cout << "SgSyncAllStatement :: " << std::flush;
87299 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
87300 0 : std::cout << " not valid " << std::endl;
87301 : }
87302 : }
87303 :
87304 :
87305 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
87306 :
87307 0 : }
87308 :
87309 :
87310 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
87311 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
87312 : bool
87313 0 : SgSyncAllStatement::isInMemoryPool ()
87314 : {
87315 0 : typedef unsigned char* TestType;
87316 :
87317 0 : bool found = false;
87318 :
87319 0 : ROSE_ASSERT(this != NULL);
87320 :
87321 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
87322 :
87323 0 : TestType tested = (TestType) ( this ) ;
87324 :
87325 0 : std::vector < unsigned char* > :: const_iterator block = SgSyncAllStatement::pools.begin();
87326 :
87327 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
87328 : // while (found == false && block < Memory_Block_List.end())
87329 0 : while ( (found == false) && (block != SgSyncAllStatement::pools.end()) )
87330 : {
87331 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSyncAllStatement::pool_size * sizeof(SgSyncAllStatement) ) ) ;
87332 0 : ++block;
87333 : }
87334 :
87335 : // Special handling for static data
87336 :
87337 :
87338 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
87339 0 : ROSE_ASSERT(found == true);
87340 :
87341 0 : return found;
87342 : }
87343 : /* #line 87344 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
87344 :
87345 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
87346 :
87347 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
87348 :
87349 : /* #line 87350 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
87350 :
87351 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
87352 :
87353 : void
87354 0 : SgSyncImagesStatement::checkDataMemberPointersIfInMemoryPool()
87355 : {
87356 : // ------------ checking pointers of SgSyncImagesStatement -------------------
87357 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
87358 :
87359 0 : if ( p_image_set != NULL )
87360 : {
87361 0 : if ( p_image_set->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87362 : {
87363 0 : if ( p_image_set->isInMemoryPool() == false )
87364 : {
87365 0 : std::cout << "SgSyncImagesStatement :: ";
87366 0 : std::cout << " p_image_set is not in memory pool of ";
87367 0 : std::cout << p_image_set->class_name() << std::endl;
87368 : }
87369 : }
87370 : else
87371 : {
87372 0 : std::cout << "SgSyncImagesStatement :: " << std::flush;
87373 0 : std::cout << "SgExpression* p_image_set = " << p_image_set << " --> " << std::flush;
87374 0 : std::cout << " not valid " << std::endl;
87375 : }
87376 : }
87377 :
87378 0 : if ( p_stat != NULL )
87379 : {
87380 0 : if ( p_stat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87381 : {
87382 0 : if ( p_stat->isInMemoryPool() == false )
87383 : {
87384 0 : std::cout << "SgSyncImagesStatement :: ";
87385 0 : std::cout << " p_stat is not in memory pool of ";
87386 0 : std::cout << p_stat->class_name() << std::endl;
87387 : }
87388 : }
87389 : else
87390 : {
87391 0 : std::cout << "SgSyncImagesStatement :: " << std::flush;
87392 0 : std::cout << "SgExpression* p_stat = " << p_stat << " --> " << std::flush;
87393 0 : std::cout << " not valid " << std::endl;
87394 : }
87395 : }
87396 :
87397 0 : if ( p_err_msg != NULL )
87398 : {
87399 0 : if ( p_err_msg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87400 : {
87401 0 : if ( p_err_msg->isInMemoryPool() == false )
87402 : {
87403 0 : std::cout << "SgSyncImagesStatement :: ";
87404 0 : std::cout << " p_err_msg is not in memory pool of ";
87405 0 : std::cout << p_err_msg->class_name() << std::endl;
87406 : }
87407 : }
87408 : else
87409 : {
87410 0 : std::cout << "SgSyncImagesStatement :: " << std::flush;
87411 0 : std::cout << "SgExpression* p_err_msg = " << p_err_msg << " --> " << std::flush;
87412 0 : std::cout << " not valid " << std::endl;
87413 : }
87414 : }
87415 :
87416 0 : if ( p_acquired_lock != NULL )
87417 : {
87418 0 : if ( p_acquired_lock->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87419 : {
87420 0 : if ( p_acquired_lock->isInMemoryPool() == false )
87421 : {
87422 0 : std::cout << "SgSyncImagesStatement :: ";
87423 0 : std::cout << " p_acquired_lock is not in memory pool of ";
87424 0 : std::cout << p_acquired_lock->class_name() << std::endl;
87425 : }
87426 : }
87427 : else
87428 : {
87429 0 : std::cout << "SgSyncImagesStatement :: " << std::flush;
87430 0 : std::cout << "SgExpression* p_acquired_lock = " << p_acquired_lock << " --> " << std::flush;
87431 0 : std::cout << " not valid " << std::endl;
87432 : }
87433 : }
87434 :
87435 0 : if ( p_numeric_label != NULL )
87436 : {
87437 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87438 : {
87439 0 : if ( p_numeric_label->isInMemoryPool() == false )
87440 : {
87441 0 : std::cout << "SgSyncImagesStatement :: ";
87442 0 : std::cout << " p_numeric_label is not in memory pool of ";
87443 0 : std::cout << p_numeric_label->class_name() << std::endl;
87444 : }
87445 : }
87446 : else
87447 : {
87448 0 : std::cout << "SgSyncImagesStatement :: " << std::flush;
87449 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
87450 0 : std::cout << " not valid " << std::endl;
87451 : }
87452 : }
87453 :
87454 0 : if ( p_startOfConstruct != NULL )
87455 : {
87456 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87457 : {
87458 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
87459 : {
87460 0 : std::cout << "SgSyncImagesStatement :: ";
87461 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
87462 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
87463 : }
87464 : }
87465 : else
87466 : {
87467 0 : std::cout << "SgSyncImagesStatement :: " << std::flush;
87468 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
87469 0 : std::cout << " not valid " << std::endl;
87470 : }
87471 : }
87472 :
87473 0 : if ( p_endOfConstruct != NULL )
87474 : {
87475 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87476 : {
87477 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
87478 : {
87479 0 : std::cout << "SgSyncImagesStatement :: ";
87480 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
87481 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
87482 : }
87483 : }
87484 : else
87485 : {
87486 0 : std::cout << "SgSyncImagesStatement :: " << std::flush;
87487 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
87488 0 : std::cout << " not valid " << std::endl;
87489 : }
87490 : }
87491 :
87492 0 : if ( p_parent != NULL )
87493 : {
87494 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87495 : {
87496 0 : if ( p_parent->isInMemoryPool() == false )
87497 : {
87498 0 : std::cout << "SgSyncImagesStatement :: ";
87499 0 : std::cout << " p_parent is not in memory pool of ";
87500 0 : std::cout << p_parent->class_name() << std::endl;
87501 : }
87502 : }
87503 : else
87504 : {
87505 0 : std::cout << "SgSyncImagesStatement :: " << std::flush;
87506 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
87507 0 : std::cout << " not valid " << std::endl;
87508 : }
87509 : }
87510 :
87511 :
87512 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
87513 :
87514 0 : }
87515 :
87516 :
87517 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
87518 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
87519 : bool
87520 0 : SgSyncImagesStatement::isInMemoryPool ()
87521 : {
87522 0 : typedef unsigned char* TestType;
87523 :
87524 0 : bool found = false;
87525 :
87526 0 : ROSE_ASSERT(this != NULL);
87527 :
87528 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
87529 :
87530 0 : TestType tested = (TestType) ( this ) ;
87531 :
87532 0 : std::vector < unsigned char* > :: const_iterator block = SgSyncImagesStatement::pools.begin();
87533 :
87534 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
87535 : // while (found == false && block < Memory_Block_List.end())
87536 0 : while ( (found == false) && (block != SgSyncImagesStatement::pools.end()) )
87537 : {
87538 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSyncImagesStatement::pool_size * sizeof(SgSyncImagesStatement) ) ) ;
87539 0 : ++block;
87540 : }
87541 :
87542 : // Special handling for static data
87543 :
87544 :
87545 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
87546 0 : ROSE_ASSERT(found == true);
87547 :
87548 0 : return found;
87549 : }
87550 : /* #line 87551 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
87551 :
87552 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
87553 :
87554 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
87555 :
87556 : /* #line 87557 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
87557 :
87558 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
87559 :
87560 : void
87561 0 : SgSyncMemoryStatement::checkDataMemberPointersIfInMemoryPool()
87562 : {
87563 : // ------------ checking pointers of SgSyncMemoryStatement -------------------
87564 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
87565 :
87566 0 : if ( p_stat != NULL )
87567 : {
87568 0 : if ( p_stat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87569 : {
87570 0 : if ( p_stat->isInMemoryPool() == false )
87571 : {
87572 0 : std::cout << "SgSyncMemoryStatement :: ";
87573 0 : std::cout << " p_stat is not in memory pool of ";
87574 0 : std::cout << p_stat->class_name() << std::endl;
87575 : }
87576 : }
87577 : else
87578 : {
87579 0 : std::cout << "SgSyncMemoryStatement :: " << std::flush;
87580 0 : std::cout << "SgExpression* p_stat = " << p_stat << " --> " << std::flush;
87581 0 : std::cout << " not valid " << std::endl;
87582 : }
87583 : }
87584 :
87585 0 : if ( p_err_msg != NULL )
87586 : {
87587 0 : if ( p_err_msg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87588 : {
87589 0 : if ( p_err_msg->isInMemoryPool() == false )
87590 : {
87591 0 : std::cout << "SgSyncMemoryStatement :: ";
87592 0 : std::cout << " p_err_msg is not in memory pool of ";
87593 0 : std::cout << p_err_msg->class_name() << std::endl;
87594 : }
87595 : }
87596 : else
87597 : {
87598 0 : std::cout << "SgSyncMemoryStatement :: " << std::flush;
87599 0 : std::cout << "SgExpression* p_err_msg = " << p_err_msg << " --> " << std::flush;
87600 0 : std::cout << " not valid " << std::endl;
87601 : }
87602 : }
87603 :
87604 0 : if ( p_acquired_lock != NULL )
87605 : {
87606 0 : if ( p_acquired_lock->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87607 : {
87608 0 : if ( p_acquired_lock->isInMemoryPool() == false )
87609 : {
87610 0 : std::cout << "SgSyncMemoryStatement :: ";
87611 0 : std::cout << " p_acquired_lock is not in memory pool of ";
87612 0 : std::cout << p_acquired_lock->class_name() << std::endl;
87613 : }
87614 : }
87615 : else
87616 : {
87617 0 : std::cout << "SgSyncMemoryStatement :: " << std::flush;
87618 0 : std::cout << "SgExpression* p_acquired_lock = " << p_acquired_lock << " --> " << std::flush;
87619 0 : std::cout << " not valid " << std::endl;
87620 : }
87621 : }
87622 :
87623 0 : if ( p_numeric_label != NULL )
87624 : {
87625 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87626 : {
87627 0 : if ( p_numeric_label->isInMemoryPool() == false )
87628 : {
87629 0 : std::cout << "SgSyncMemoryStatement :: ";
87630 0 : std::cout << " p_numeric_label is not in memory pool of ";
87631 0 : std::cout << p_numeric_label->class_name() << std::endl;
87632 : }
87633 : }
87634 : else
87635 : {
87636 0 : std::cout << "SgSyncMemoryStatement :: " << std::flush;
87637 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
87638 0 : std::cout << " not valid " << std::endl;
87639 : }
87640 : }
87641 :
87642 0 : if ( p_startOfConstruct != NULL )
87643 : {
87644 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87645 : {
87646 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
87647 : {
87648 0 : std::cout << "SgSyncMemoryStatement :: ";
87649 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
87650 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
87651 : }
87652 : }
87653 : else
87654 : {
87655 0 : std::cout << "SgSyncMemoryStatement :: " << std::flush;
87656 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
87657 0 : std::cout << " not valid " << std::endl;
87658 : }
87659 : }
87660 :
87661 0 : if ( p_endOfConstruct != NULL )
87662 : {
87663 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87664 : {
87665 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
87666 : {
87667 0 : std::cout << "SgSyncMemoryStatement :: ";
87668 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
87669 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
87670 : }
87671 : }
87672 : else
87673 : {
87674 0 : std::cout << "SgSyncMemoryStatement :: " << std::flush;
87675 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
87676 0 : std::cout << " not valid " << std::endl;
87677 : }
87678 : }
87679 :
87680 0 : if ( p_parent != NULL )
87681 : {
87682 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87683 : {
87684 0 : if ( p_parent->isInMemoryPool() == false )
87685 : {
87686 0 : std::cout << "SgSyncMemoryStatement :: ";
87687 0 : std::cout << " p_parent is not in memory pool of ";
87688 0 : std::cout << p_parent->class_name() << std::endl;
87689 : }
87690 : }
87691 : else
87692 : {
87693 0 : std::cout << "SgSyncMemoryStatement :: " << std::flush;
87694 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
87695 0 : std::cout << " not valid " << std::endl;
87696 : }
87697 : }
87698 :
87699 :
87700 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
87701 :
87702 0 : }
87703 :
87704 :
87705 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
87706 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
87707 : bool
87708 0 : SgSyncMemoryStatement::isInMemoryPool ()
87709 : {
87710 0 : typedef unsigned char* TestType;
87711 :
87712 0 : bool found = false;
87713 :
87714 0 : ROSE_ASSERT(this != NULL);
87715 :
87716 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
87717 :
87718 0 : TestType tested = (TestType) ( this ) ;
87719 :
87720 0 : std::vector < unsigned char* > :: const_iterator block = SgSyncMemoryStatement::pools.begin();
87721 :
87722 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
87723 : // while (found == false && block < Memory_Block_List.end())
87724 0 : while ( (found == false) && (block != SgSyncMemoryStatement::pools.end()) )
87725 : {
87726 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSyncMemoryStatement::pool_size * sizeof(SgSyncMemoryStatement) ) ) ;
87727 0 : ++block;
87728 : }
87729 :
87730 : // Special handling for static data
87731 :
87732 :
87733 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
87734 0 : ROSE_ASSERT(found == true);
87735 :
87736 0 : return found;
87737 : }
87738 : /* #line 87739 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
87739 :
87740 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
87741 :
87742 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
87743 :
87744 : /* #line 87745 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
87745 :
87746 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
87747 :
87748 : void
87749 0 : SgSyncTeamStatement::checkDataMemberPointersIfInMemoryPool()
87750 : {
87751 : // ------------ checking pointers of SgSyncTeamStatement -------------------
87752 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
87753 :
87754 0 : if ( p_team_value != NULL )
87755 : {
87756 0 : if ( p_team_value->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87757 : {
87758 0 : if ( p_team_value->isInMemoryPool() == false )
87759 : {
87760 0 : std::cout << "SgSyncTeamStatement :: ";
87761 0 : std::cout << " p_team_value is not in memory pool of ";
87762 0 : std::cout << p_team_value->class_name() << std::endl;
87763 : }
87764 : }
87765 : else
87766 : {
87767 0 : std::cout << "SgSyncTeamStatement :: " << std::flush;
87768 0 : std::cout << "SgExpression* p_team_value = " << p_team_value << " --> " << std::flush;
87769 0 : std::cout << " not valid " << std::endl;
87770 : }
87771 : }
87772 :
87773 0 : if ( p_stat != NULL )
87774 : {
87775 0 : if ( p_stat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87776 : {
87777 0 : if ( p_stat->isInMemoryPool() == false )
87778 : {
87779 0 : std::cout << "SgSyncTeamStatement :: ";
87780 0 : std::cout << " p_stat is not in memory pool of ";
87781 0 : std::cout << p_stat->class_name() << std::endl;
87782 : }
87783 : }
87784 : else
87785 : {
87786 0 : std::cout << "SgSyncTeamStatement :: " << std::flush;
87787 0 : std::cout << "SgExpression* p_stat = " << p_stat << " --> " << std::flush;
87788 0 : std::cout << " not valid " << std::endl;
87789 : }
87790 : }
87791 :
87792 0 : if ( p_err_msg != NULL )
87793 : {
87794 0 : if ( p_err_msg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87795 : {
87796 0 : if ( p_err_msg->isInMemoryPool() == false )
87797 : {
87798 0 : std::cout << "SgSyncTeamStatement :: ";
87799 0 : std::cout << " p_err_msg is not in memory pool of ";
87800 0 : std::cout << p_err_msg->class_name() << std::endl;
87801 : }
87802 : }
87803 : else
87804 : {
87805 0 : std::cout << "SgSyncTeamStatement :: " << std::flush;
87806 0 : std::cout << "SgExpression* p_err_msg = " << p_err_msg << " --> " << std::flush;
87807 0 : std::cout << " not valid " << std::endl;
87808 : }
87809 : }
87810 :
87811 0 : if ( p_acquired_lock != NULL )
87812 : {
87813 0 : if ( p_acquired_lock->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87814 : {
87815 0 : if ( p_acquired_lock->isInMemoryPool() == false )
87816 : {
87817 0 : std::cout << "SgSyncTeamStatement :: ";
87818 0 : std::cout << " p_acquired_lock is not in memory pool of ";
87819 0 : std::cout << p_acquired_lock->class_name() << std::endl;
87820 : }
87821 : }
87822 : else
87823 : {
87824 0 : std::cout << "SgSyncTeamStatement :: " << std::flush;
87825 0 : std::cout << "SgExpression* p_acquired_lock = " << p_acquired_lock << " --> " << std::flush;
87826 0 : std::cout << " not valid " << std::endl;
87827 : }
87828 : }
87829 :
87830 0 : if ( p_numeric_label != NULL )
87831 : {
87832 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87833 : {
87834 0 : if ( p_numeric_label->isInMemoryPool() == false )
87835 : {
87836 0 : std::cout << "SgSyncTeamStatement :: ";
87837 0 : std::cout << " p_numeric_label is not in memory pool of ";
87838 0 : std::cout << p_numeric_label->class_name() << std::endl;
87839 : }
87840 : }
87841 : else
87842 : {
87843 0 : std::cout << "SgSyncTeamStatement :: " << std::flush;
87844 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
87845 0 : std::cout << " not valid " << std::endl;
87846 : }
87847 : }
87848 :
87849 0 : if ( p_startOfConstruct != NULL )
87850 : {
87851 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87852 : {
87853 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
87854 : {
87855 0 : std::cout << "SgSyncTeamStatement :: ";
87856 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
87857 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
87858 : }
87859 : }
87860 : else
87861 : {
87862 0 : std::cout << "SgSyncTeamStatement :: " << std::flush;
87863 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
87864 0 : std::cout << " not valid " << std::endl;
87865 : }
87866 : }
87867 :
87868 0 : if ( p_endOfConstruct != NULL )
87869 : {
87870 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87871 : {
87872 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
87873 : {
87874 0 : std::cout << "SgSyncTeamStatement :: ";
87875 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
87876 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
87877 : }
87878 : }
87879 : else
87880 : {
87881 0 : std::cout << "SgSyncTeamStatement :: " << std::flush;
87882 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
87883 0 : std::cout << " not valid " << std::endl;
87884 : }
87885 : }
87886 :
87887 0 : if ( p_parent != NULL )
87888 : {
87889 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87890 : {
87891 0 : if ( p_parent->isInMemoryPool() == false )
87892 : {
87893 0 : std::cout << "SgSyncTeamStatement :: ";
87894 0 : std::cout << " p_parent is not in memory pool of ";
87895 0 : std::cout << p_parent->class_name() << std::endl;
87896 : }
87897 : }
87898 : else
87899 : {
87900 0 : std::cout << "SgSyncTeamStatement :: " << std::flush;
87901 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
87902 0 : std::cout << " not valid " << std::endl;
87903 : }
87904 : }
87905 :
87906 :
87907 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
87908 :
87909 0 : }
87910 :
87911 :
87912 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
87913 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
87914 : bool
87915 0 : SgSyncTeamStatement::isInMemoryPool ()
87916 : {
87917 0 : typedef unsigned char* TestType;
87918 :
87919 0 : bool found = false;
87920 :
87921 0 : ROSE_ASSERT(this != NULL);
87922 :
87923 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
87924 :
87925 0 : TestType tested = (TestType) ( this ) ;
87926 :
87927 0 : std::vector < unsigned char* > :: const_iterator block = SgSyncTeamStatement::pools.begin();
87928 :
87929 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
87930 : // while (found == false && block < Memory_Block_List.end())
87931 0 : while ( (found == false) && (block != SgSyncTeamStatement::pools.end()) )
87932 : {
87933 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSyncTeamStatement::pool_size * sizeof(SgSyncTeamStatement) ) ) ;
87934 0 : ++block;
87935 : }
87936 :
87937 : // Special handling for static data
87938 :
87939 :
87940 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
87941 0 : ROSE_ASSERT(found == true);
87942 :
87943 0 : return found;
87944 : }
87945 : /* #line 87946 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
87946 :
87947 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
87948 :
87949 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
87950 :
87951 : /* #line 87952 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
87952 :
87953 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
87954 :
87955 : void
87956 0 : SgLockStatement::checkDataMemberPointersIfInMemoryPool()
87957 : {
87958 : // ------------ checking pointers of SgLockStatement -------------------
87959 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
87960 :
87961 0 : if ( p_lock_variable != NULL )
87962 : {
87963 0 : if ( p_lock_variable->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87964 : {
87965 0 : if ( p_lock_variable->isInMemoryPool() == false )
87966 : {
87967 0 : std::cout << "SgLockStatement :: ";
87968 0 : std::cout << " p_lock_variable is not in memory pool of ";
87969 0 : std::cout << p_lock_variable->class_name() << std::endl;
87970 : }
87971 : }
87972 : else
87973 : {
87974 0 : std::cout << "SgLockStatement :: " << std::flush;
87975 0 : std::cout << "SgExpression* p_lock_variable = " << p_lock_variable << " --> " << std::flush;
87976 0 : std::cout << " not valid " << std::endl;
87977 : }
87978 : }
87979 :
87980 0 : if ( p_stat != NULL )
87981 : {
87982 0 : if ( p_stat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
87983 : {
87984 0 : if ( p_stat->isInMemoryPool() == false )
87985 : {
87986 0 : std::cout << "SgLockStatement :: ";
87987 0 : std::cout << " p_stat is not in memory pool of ";
87988 0 : std::cout << p_stat->class_name() << std::endl;
87989 : }
87990 : }
87991 : else
87992 : {
87993 0 : std::cout << "SgLockStatement :: " << std::flush;
87994 0 : std::cout << "SgExpression* p_stat = " << p_stat << " --> " << std::flush;
87995 0 : std::cout << " not valid " << std::endl;
87996 : }
87997 : }
87998 :
87999 0 : if ( p_err_msg != NULL )
88000 : {
88001 0 : if ( p_err_msg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88002 : {
88003 0 : if ( p_err_msg->isInMemoryPool() == false )
88004 : {
88005 0 : std::cout << "SgLockStatement :: ";
88006 0 : std::cout << " p_err_msg is not in memory pool of ";
88007 0 : std::cout << p_err_msg->class_name() << std::endl;
88008 : }
88009 : }
88010 : else
88011 : {
88012 0 : std::cout << "SgLockStatement :: " << std::flush;
88013 0 : std::cout << "SgExpression* p_err_msg = " << p_err_msg << " --> " << std::flush;
88014 0 : std::cout << " not valid " << std::endl;
88015 : }
88016 : }
88017 :
88018 0 : if ( p_acquired_lock != NULL )
88019 : {
88020 0 : if ( p_acquired_lock->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88021 : {
88022 0 : if ( p_acquired_lock->isInMemoryPool() == false )
88023 : {
88024 0 : std::cout << "SgLockStatement :: ";
88025 0 : std::cout << " p_acquired_lock is not in memory pool of ";
88026 0 : std::cout << p_acquired_lock->class_name() << std::endl;
88027 : }
88028 : }
88029 : else
88030 : {
88031 0 : std::cout << "SgLockStatement :: " << std::flush;
88032 0 : std::cout << "SgExpression* p_acquired_lock = " << p_acquired_lock << " --> " << std::flush;
88033 0 : std::cout << " not valid " << std::endl;
88034 : }
88035 : }
88036 :
88037 0 : if ( p_numeric_label != NULL )
88038 : {
88039 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88040 : {
88041 0 : if ( p_numeric_label->isInMemoryPool() == false )
88042 : {
88043 0 : std::cout << "SgLockStatement :: ";
88044 0 : std::cout << " p_numeric_label is not in memory pool of ";
88045 0 : std::cout << p_numeric_label->class_name() << std::endl;
88046 : }
88047 : }
88048 : else
88049 : {
88050 0 : std::cout << "SgLockStatement :: " << std::flush;
88051 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
88052 0 : std::cout << " not valid " << std::endl;
88053 : }
88054 : }
88055 :
88056 0 : if ( p_startOfConstruct != NULL )
88057 : {
88058 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88059 : {
88060 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
88061 : {
88062 0 : std::cout << "SgLockStatement :: ";
88063 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
88064 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
88065 : }
88066 : }
88067 : else
88068 : {
88069 0 : std::cout << "SgLockStatement :: " << std::flush;
88070 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
88071 0 : std::cout << " not valid " << std::endl;
88072 : }
88073 : }
88074 :
88075 0 : if ( p_endOfConstruct != NULL )
88076 : {
88077 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88078 : {
88079 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
88080 : {
88081 0 : std::cout << "SgLockStatement :: ";
88082 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
88083 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
88084 : }
88085 : }
88086 : else
88087 : {
88088 0 : std::cout << "SgLockStatement :: " << std::flush;
88089 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
88090 0 : std::cout << " not valid " << std::endl;
88091 : }
88092 : }
88093 :
88094 0 : if ( p_parent != NULL )
88095 : {
88096 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88097 : {
88098 0 : if ( p_parent->isInMemoryPool() == false )
88099 : {
88100 0 : std::cout << "SgLockStatement :: ";
88101 0 : std::cout << " p_parent is not in memory pool of ";
88102 0 : std::cout << p_parent->class_name() << std::endl;
88103 : }
88104 : }
88105 : else
88106 : {
88107 0 : std::cout << "SgLockStatement :: " << std::flush;
88108 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
88109 0 : std::cout << " not valid " << std::endl;
88110 : }
88111 : }
88112 :
88113 :
88114 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
88115 :
88116 0 : }
88117 :
88118 :
88119 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
88120 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
88121 : bool
88122 0 : SgLockStatement::isInMemoryPool ()
88123 : {
88124 0 : typedef unsigned char* TestType;
88125 :
88126 0 : bool found = false;
88127 :
88128 0 : ROSE_ASSERT(this != NULL);
88129 :
88130 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
88131 :
88132 0 : TestType tested = (TestType) ( this ) ;
88133 :
88134 0 : std::vector < unsigned char* > :: const_iterator block = SgLockStatement::pools.begin();
88135 :
88136 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
88137 : // while (found == false && block < Memory_Block_List.end())
88138 0 : while ( (found == false) && (block != SgLockStatement::pools.end()) )
88139 : {
88140 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLockStatement::pool_size * sizeof(SgLockStatement) ) ) ;
88141 0 : ++block;
88142 : }
88143 :
88144 : // Special handling for static data
88145 :
88146 :
88147 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
88148 0 : ROSE_ASSERT(found == true);
88149 :
88150 0 : return found;
88151 : }
88152 : /* #line 88153 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
88153 :
88154 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
88155 :
88156 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
88157 :
88158 : /* #line 88159 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
88159 :
88160 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
88161 :
88162 : void
88163 0 : SgUnlockStatement::checkDataMemberPointersIfInMemoryPool()
88164 : {
88165 : // ------------ checking pointers of SgUnlockStatement -------------------
88166 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
88167 :
88168 0 : if ( p_lock_variable != NULL )
88169 : {
88170 0 : if ( p_lock_variable->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88171 : {
88172 0 : if ( p_lock_variable->isInMemoryPool() == false )
88173 : {
88174 0 : std::cout << "SgUnlockStatement :: ";
88175 0 : std::cout << " p_lock_variable is not in memory pool of ";
88176 0 : std::cout << p_lock_variable->class_name() << std::endl;
88177 : }
88178 : }
88179 : else
88180 : {
88181 0 : std::cout << "SgUnlockStatement :: " << std::flush;
88182 0 : std::cout << "SgExpression* p_lock_variable = " << p_lock_variable << " --> " << std::flush;
88183 0 : std::cout << " not valid " << std::endl;
88184 : }
88185 : }
88186 :
88187 0 : if ( p_stat != NULL )
88188 : {
88189 0 : if ( p_stat->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88190 : {
88191 0 : if ( p_stat->isInMemoryPool() == false )
88192 : {
88193 0 : std::cout << "SgUnlockStatement :: ";
88194 0 : std::cout << " p_stat is not in memory pool of ";
88195 0 : std::cout << p_stat->class_name() << std::endl;
88196 : }
88197 : }
88198 : else
88199 : {
88200 0 : std::cout << "SgUnlockStatement :: " << std::flush;
88201 0 : std::cout << "SgExpression* p_stat = " << p_stat << " --> " << std::flush;
88202 0 : std::cout << " not valid " << std::endl;
88203 : }
88204 : }
88205 :
88206 0 : if ( p_err_msg != NULL )
88207 : {
88208 0 : if ( p_err_msg->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88209 : {
88210 0 : if ( p_err_msg->isInMemoryPool() == false )
88211 : {
88212 0 : std::cout << "SgUnlockStatement :: ";
88213 0 : std::cout << " p_err_msg is not in memory pool of ";
88214 0 : std::cout << p_err_msg->class_name() << std::endl;
88215 : }
88216 : }
88217 : else
88218 : {
88219 0 : std::cout << "SgUnlockStatement :: " << std::flush;
88220 0 : std::cout << "SgExpression* p_err_msg = " << p_err_msg << " --> " << std::flush;
88221 0 : std::cout << " not valid " << std::endl;
88222 : }
88223 : }
88224 :
88225 0 : if ( p_acquired_lock != NULL )
88226 : {
88227 0 : if ( p_acquired_lock->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88228 : {
88229 0 : if ( p_acquired_lock->isInMemoryPool() == false )
88230 : {
88231 0 : std::cout << "SgUnlockStatement :: ";
88232 0 : std::cout << " p_acquired_lock is not in memory pool of ";
88233 0 : std::cout << p_acquired_lock->class_name() << std::endl;
88234 : }
88235 : }
88236 : else
88237 : {
88238 0 : std::cout << "SgUnlockStatement :: " << std::flush;
88239 0 : std::cout << "SgExpression* p_acquired_lock = " << p_acquired_lock << " --> " << std::flush;
88240 0 : std::cout << " not valid " << std::endl;
88241 : }
88242 : }
88243 :
88244 0 : if ( p_numeric_label != NULL )
88245 : {
88246 0 : if ( p_numeric_label->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88247 : {
88248 0 : if ( p_numeric_label->isInMemoryPool() == false )
88249 : {
88250 0 : std::cout << "SgUnlockStatement :: ";
88251 0 : std::cout << " p_numeric_label is not in memory pool of ";
88252 0 : std::cout << p_numeric_label->class_name() << std::endl;
88253 : }
88254 : }
88255 : else
88256 : {
88257 0 : std::cout << "SgUnlockStatement :: " << std::flush;
88258 0 : std::cout << "SgLabelRefExp* p_numeric_label = " << p_numeric_label << " --> " << std::flush;
88259 0 : std::cout << " not valid " << std::endl;
88260 : }
88261 : }
88262 :
88263 0 : if ( p_startOfConstruct != NULL )
88264 : {
88265 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88266 : {
88267 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
88268 : {
88269 0 : std::cout << "SgUnlockStatement :: ";
88270 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
88271 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
88272 : }
88273 : }
88274 : else
88275 : {
88276 0 : std::cout << "SgUnlockStatement :: " << std::flush;
88277 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
88278 0 : std::cout << " not valid " << std::endl;
88279 : }
88280 : }
88281 :
88282 0 : if ( p_endOfConstruct != NULL )
88283 : {
88284 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88285 : {
88286 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
88287 : {
88288 0 : std::cout << "SgUnlockStatement :: ";
88289 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
88290 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
88291 : }
88292 : }
88293 : else
88294 : {
88295 0 : std::cout << "SgUnlockStatement :: " << std::flush;
88296 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
88297 0 : std::cout << " not valid " << std::endl;
88298 : }
88299 : }
88300 :
88301 0 : if ( p_parent != NULL )
88302 : {
88303 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88304 : {
88305 0 : if ( p_parent->isInMemoryPool() == false )
88306 : {
88307 0 : std::cout << "SgUnlockStatement :: ";
88308 0 : std::cout << " p_parent is not in memory pool of ";
88309 0 : std::cout << p_parent->class_name() << std::endl;
88310 : }
88311 : }
88312 : else
88313 : {
88314 0 : std::cout << "SgUnlockStatement :: " << std::flush;
88315 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
88316 0 : std::cout << " not valid " << std::endl;
88317 : }
88318 : }
88319 :
88320 :
88321 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
88322 :
88323 0 : }
88324 :
88325 :
88326 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
88327 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
88328 : bool
88329 0 : SgUnlockStatement::isInMemoryPool ()
88330 : {
88331 0 : typedef unsigned char* TestType;
88332 :
88333 0 : bool found = false;
88334 :
88335 0 : ROSE_ASSERT(this != NULL);
88336 :
88337 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
88338 :
88339 0 : TestType tested = (TestType) ( this ) ;
88340 :
88341 0 : std::vector < unsigned char* > :: const_iterator block = SgUnlockStatement::pools.begin();
88342 :
88343 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
88344 : // while (found == false && block < Memory_Block_List.end())
88345 0 : while ( (found == false) && (block != SgUnlockStatement::pools.end()) )
88346 : {
88347 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUnlockStatement::pool_size * sizeof(SgUnlockStatement) ) ) ;
88348 0 : ++block;
88349 : }
88350 :
88351 : // Special handling for static data
88352 :
88353 :
88354 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
88355 0 : ROSE_ASSERT(found == true);
88356 :
88357 0 : return found;
88358 : }
88359 : /* #line 88360 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
88360 :
88361 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
88362 :
88363 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
88364 :
88365 : /* #line 88366 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
88366 :
88367 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
88368 :
88369 : void
88370 0 : SgExpression::checkDataMemberPointersIfInMemoryPool()
88371 : {
88372 : // ------------ checking pointers of SgExpression -------------------
88373 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
88374 :
88375 0 : if ( p_operatorPosition != NULL )
88376 : {
88377 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88378 : {
88379 0 : if ( p_operatorPosition->isInMemoryPool() == false )
88380 : {
88381 0 : std::cout << "SgExpression :: ";
88382 0 : std::cout << " p_operatorPosition is not in memory pool of ";
88383 0 : std::cout << p_operatorPosition->class_name() << std::endl;
88384 : }
88385 : }
88386 : else
88387 : {
88388 0 : std::cout << "SgExpression :: " << std::flush;
88389 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
88390 0 : std::cout << " not valid " << std::endl;
88391 : }
88392 : }
88393 :
88394 0 : if ( p_startOfConstruct != NULL )
88395 : {
88396 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88397 : {
88398 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
88399 : {
88400 0 : std::cout << "SgExpression :: ";
88401 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
88402 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
88403 : }
88404 : }
88405 : else
88406 : {
88407 0 : std::cout << "SgExpression :: " << std::flush;
88408 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
88409 0 : std::cout << " not valid " << std::endl;
88410 : }
88411 : }
88412 :
88413 0 : if ( p_endOfConstruct != NULL )
88414 : {
88415 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88416 : {
88417 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
88418 : {
88419 0 : std::cout << "SgExpression :: ";
88420 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
88421 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
88422 : }
88423 : }
88424 : else
88425 : {
88426 0 : std::cout << "SgExpression :: " << std::flush;
88427 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
88428 0 : std::cout << " not valid " << std::endl;
88429 : }
88430 : }
88431 :
88432 0 : if ( p_parent != NULL )
88433 : {
88434 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88435 : {
88436 0 : if ( p_parent->isInMemoryPool() == false )
88437 : {
88438 0 : std::cout << "SgExpression :: ";
88439 0 : std::cout << " p_parent is not in memory pool of ";
88440 0 : std::cout << p_parent->class_name() << std::endl;
88441 : }
88442 : }
88443 : else
88444 : {
88445 0 : std::cout << "SgExpression :: " << std::flush;
88446 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
88447 0 : std::cout << " not valid " << std::endl;
88448 : }
88449 : }
88450 :
88451 :
88452 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
88453 :
88454 0 : }
88455 :
88456 :
88457 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
88458 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
88459 : bool
88460 0 : SgExpression::isInMemoryPool ()
88461 : {
88462 0 : typedef unsigned char* TestType;
88463 :
88464 0 : bool found = false;
88465 :
88466 0 : ROSE_ASSERT(this != NULL);
88467 :
88468 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
88469 :
88470 0 : TestType tested = (TestType) ( this ) ;
88471 :
88472 0 : std::vector < unsigned char* > :: const_iterator block = SgExpression::pools.begin();
88473 :
88474 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
88475 : // while (found == false && block < Memory_Block_List.end())
88476 0 : while ( (found == false) && (block != SgExpression::pools.end()) )
88477 : {
88478 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgExpression::pool_size * sizeof(SgExpression) ) ) ;
88479 0 : ++block;
88480 : }
88481 :
88482 : // Special handling for static data
88483 :
88484 :
88485 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
88486 0 : ROSE_ASSERT(found == true);
88487 :
88488 0 : return found;
88489 : }
88490 : /* #line 88491 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
88491 :
88492 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
88493 :
88494 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
88495 :
88496 : /* #line 88497 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
88497 :
88498 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
88499 :
88500 : void
88501 0 : SgUnaryOp::checkDataMemberPointersIfInMemoryPool()
88502 : {
88503 : // ------------ checking pointers of SgUnaryOp -------------------
88504 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
88505 :
88506 0 : if ( p_operand_i != NULL )
88507 : {
88508 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88509 : {
88510 0 : if ( p_operand_i->isInMemoryPool() == false )
88511 : {
88512 0 : std::cout << "SgUnaryOp :: ";
88513 0 : std::cout << " p_operand_i is not in memory pool of ";
88514 0 : std::cout << p_operand_i->class_name() << std::endl;
88515 : }
88516 : }
88517 : else
88518 : {
88519 0 : std::cout << "SgUnaryOp :: " << std::flush;
88520 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
88521 0 : std::cout << " not valid " << std::endl;
88522 : }
88523 : }
88524 :
88525 0 : if ( p_expression_type != NULL )
88526 : {
88527 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88528 : {
88529 0 : if ( p_expression_type->isInMemoryPool() == false )
88530 : {
88531 0 : std::cout << "SgUnaryOp :: ";
88532 0 : std::cout << " p_expression_type is not in memory pool of ";
88533 0 : std::cout << p_expression_type->class_name() << std::endl;
88534 : }
88535 : }
88536 : else
88537 : {
88538 0 : std::cout << "SgUnaryOp :: " << std::flush;
88539 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
88540 0 : std::cout << " not valid " << std::endl;
88541 : }
88542 : }
88543 :
88544 0 : if ( p_operatorPosition != NULL )
88545 : {
88546 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88547 : {
88548 0 : if ( p_operatorPosition->isInMemoryPool() == false )
88549 : {
88550 0 : std::cout << "SgUnaryOp :: ";
88551 0 : std::cout << " p_operatorPosition is not in memory pool of ";
88552 0 : std::cout << p_operatorPosition->class_name() << std::endl;
88553 : }
88554 : }
88555 : else
88556 : {
88557 0 : std::cout << "SgUnaryOp :: " << std::flush;
88558 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
88559 0 : std::cout << " not valid " << std::endl;
88560 : }
88561 : }
88562 :
88563 0 : if ( p_startOfConstruct != NULL )
88564 : {
88565 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88566 : {
88567 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
88568 : {
88569 0 : std::cout << "SgUnaryOp :: ";
88570 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
88571 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
88572 : }
88573 : }
88574 : else
88575 : {
88576 0 : std::cout << "SgUnaryOp :: " << std::flush;
88577 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
88578 0 : std::cout << " not valid " << std::endl;
88579 : }
88580 : }
88581 :
88582 0 : if ( p_endOfConstruct != NULL )
88583 : {
88584 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88585 : {
88586 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
88587 : {
88588 0 : std::cout << "SgUnaryOp :: ";
88589 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
88590 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
88591 : }
88592 : }
88593 : else
88594 : {
88595 0 : std::cout << "SgUnaryOp :: " << std::flush;
88596 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
88597 0 : std::cout << " not valid " << std::endl;
88598 : }
88599 : }
88600 :
88601 0 : if ( p_parent != NULL )
88602 : {
88603 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88604 : {
88605 0 : if ( p_parent->isInMemoryPool() == false )
88606 : {
88607 0 : std::cout << "SgUnaryOp :: ";
88608 0 : std::cout << " p_parent is not in memory pool of ";
88609 0 : std::cout << p_parent->class_name() << std::endl;
88610 : }
88611 : }
88612 : else
88613 : {
88614 0 : std::cout << "SgUnaryOp :: " << std::flush;
88615 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
88616 0 : std::cout << " not valid " << std::endl;
88617 : }
88618 : }
88619 :
88620 :
88621 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
88622 :
88623 0 : }
88624 :
88625 :
88626 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
88627 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
88628 : bool
88629 0 : SgUnaryOp::isInMemoryPool ()
88630 : {
88631 0 : typedef unsigned char* TestType;
88632 :
88633 0 : bool found = false;
88634 :
88635 0 : ROSE_ASSERT(this != NULL);
88636 :
88637 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
88638 :
88639 0 : TestType tested = (TestType) ( this ) ;
88640 :
88641 0 : std::vector < unsigned char* > :: const_iterator block = SgUnaryOp::pools.begin();
88642 :
88643 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
88644 : // while (found == false && block < Memory_Block_List.end())
88645 0 : while ( (found == false) && (block != SgUnaryOp::pools.end()) )
88646 : {
88647 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUnaryOp::pool_size * sizeof(SgUnaryOp) ) ) ;
88648 0 : ++block;
88649 : }
88650 :
88651 : // Special handling for static data
88652 :
88653 :
88654 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
88655 0 : ROSE_ASSERT(found == true);
88656 :
88657 0 : return found;
88658 : }
88659 : /* #line 88660 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
88660 :
88661 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
88662 :
88663 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
88664 :
88665 : /* #line 88666 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
88666 :
88667 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
88668 :
88669 : void
88670 0 : SgExpressionRoot::checkDataMemberPointersIfInMemoryPool()
88671 : {
88672 : // ------------ checking pointers of SgExpressionRoot -------------------
88673 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
88674 :
88675 0 : if ( p_operand_i != NULL )
88676 : {
88677 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88678 : {
88679 0 : if ( p_operand_i->isInMemoryPool() == false )
88680 : {
88681 0 : std::cout << "SgExpressionRoot :: ";
88682 0 : std::cout << " p_operand_i is not in memory pool of ";
88683 0 : std::cout << p_operand_i->class_name() << std::endl;
88684 : }
88685 : }
88686 : else
88687 : {
88688 0 : std::cout << "SgExpressionRoot :: " << std::flush;
88689 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
88690 0 : std::cout << " not valid " << std::endl;
88691 : }
88692 : }
88693 :
88694 0 : if ( p_expression_type != NULL )
88695 : {
88696 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88697 : {
88698 0 : if ( p_expression_type->isInMemoryPool() == false )
88699 : {
88700 0 : std::cout << "SgExpressionRoot :: ";
88701 0 : std::cout << " p_expression_type is not in memory pool of ";
88702 0 : std::cout << p_expression_type->class_name() << std::endl;
88703 : }
88704 : }
88705 : else
88706 : {
88707 0 : std::cout << "SgExpressionRoot :: " << std::flush;
88708 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
88709 0 : std::cout << " not valid " << std::endl;
88710 : }
88711 : }
88712 :
88713 0 : if ( p_operatorPosition != NULL )
88714 : {
88715 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88716 : {
88717 0 : if ( p_operatorPosition->isInMemoryPool() == false )
88718 : {
88719 0 : std::cout << "SgExpressionRoot :: ";
88720 0 : std::cout << " p_operatorPosition is not in memory pool of ";
88721 0 : std::cout << p_operatorPosition->class_name() << std::endl;
88722 : }
88723 : }
88724 : else
88725 : {
88726 0 : std::cout << "SgExpressionRoot :: " << std::flush;
88727 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
88728 0 : std::cout << " not valid " << std::endl;
88729 : }
88730 : }
88731 :
88732 0 : if ( p_startOfConstruct != NULL )
88733 : {
88734 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88735 : {
88736 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
88737 : {
88738 0 : std::cout << "SgExpressionRoot :: ";
88739 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
88740 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
88741 : }
88742 : }
88743 : else
88744 : {
88745 0 : std::cout << "SgExpressionRoot :: " << std::flush;
88746 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
88747 0 : std::cout << " not valid " << std::endl;
88748 : }
88749 : }
88750 :
88751 0 : if ( p_endOfConstruct != NULL )
88752 : {
88753 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88754 : {
88755 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
88756 : {
88757 0 : std::cout << "SgExpressionRoot :: ";
88758 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
88759 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
88760 : }
88761 : }
88762 : else
88763 : {
88764 0 : std::cout << "SgExpressionRoot :: " << std::flush;
88765 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
88766 0 : std::cout << " not valid " << std::endl;
88767 : }
88768 : }
88769 :
88770 0 : if ( p_parent != NULL )
88771 : {
88772 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88773 : {
88774 0 : if ( p_parent->isInMemoryPool() == false )
88775 : {
88776 0 : std::cout << "SgExpressionRoot :: ";
88777 0 : std::cout << " p_parent is not in memory pool of ";
88778 0 : std::cout << p_parent->class_name() << std::endl;
88779 : }
88780 : }
88781 : else
88782 : {
88783 0 : std::cout << "SgExpressionRoot :: " << std::flush;
88784 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
88785 0 : std::cout << " not valid " << std::endl;
88786 : }
88787 : }
88788 :
88789 :
88790 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
88791 :
88792 0 : }
88793 :
88794 :
88795 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
88796 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
88797 : bool
88798 0 : SgExpressionRoot::isInMemoryPool ()
88799 : {
88800 0 : typedef unsigned char* TestType;
88801 :
88802 0 : bool found = false;
88803 :
88804 0 : ROSE_ASSERT(this != NULL);
88805 :
88806 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
88807 :
88808 0 : TestType tested = (TestType) ( this ) ;
88809 :
88810 0 : std::vector < unsigned char* > :: const_iterator block = SgExpressionRoot::pools.begin();
88811 :
88812 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
88813 : // while (found == false && block < Memory_Block_List.end())
88814 0 : while ( (found == false) && (block != SgExpressionRoot::pools.end()) )
88815 : {
88816 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgExpressionRoot::pool_size * sizeof(SgExpressionRoot) ) ) ;
88817 0 : ++block;
88818 : }
88819 :
88820 : // Special handling for static data
88821 :
88822 :
88823 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
88824 0 : ROSE_ASSERT(found == true);
88825 :
88826 0 : return found;
88827 : }
88828 : /* #line 88829 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
88829 :
88830 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
88831 :
88832 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
88833 :
88834 : /* #line 88835 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
88835 :
88836 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
88837 :
88838 : void
88839 0 : SgMinusOp::checkDataMemberPointersIfInMemoryPool()
88840 : {
88841 : // ------------ checking pointers of SgMinusOp -------------------
88842 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
88843 :
88844 0 : if ( p_operand_i != NULL )
88845 : {
88846 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88847 : {
88848 0 : if ( p_operand_i->isInMemoryPool() == false )
88849 : {
88850 0 : std::cout << "SgMinusOp :: ";
88851 0 : std::cout << " p_operand_i is not in memory pool of ";
88852 0 : std::cout << p_operand_i->class_name() << std::endl;
88853 : }
88854 : }
88855 : else
88856 : {
88857 0 : std::cout << "SgMinusOp :: " << std::flush;
88858 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
88859 0 : std::cout << " not valid " << std::endl;
88860 : }
88861 : }
88862 :
88863 0 : if ( p_expression_type != NULL )
88864 : {
88865 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88866 : {
88867 0 : if ( p_expression_type->isInMemoryPool() == false )
88868 : {
88869 0 : std::cout << "SgMinusOp :: ";
88870 0 : std::cout << " p_expression_type is not in memory pool of ";
88871 0 : std::cout << p_expression_type->class_name() << std::endl;
88872 : }
88873 : }
88874 : else
88875 : {
88876 0 : std::cout << "SgMinusOp :: " << std::flush;
88877 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
88878 0 : std::cout << " not valid " << std::endl;
88879 : }
88880 : }
88881 :
88882 0 : if ( p_operatorPosition != NULL )
88883 : {
88884 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88885 : {
88886 0 : if ( p_operatorPosition->isInMemoryPool() == false )
88887 : {
88888 0 : std::cout << "SgMinusOp :: ";
88889 0 : std::cout << " p_operatorPosition is not in memory pool of ";
88890 0 : std::cout << p_operatorPosition->class_name() << std::endl;
88891 : }
88892 : }
88893 : else
88894 : {
88895 0 : std::cout << "SgMinusOp :: " << std::flush;
88896 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
88897 0 : std::cout << " not valid " << std::endl;
88898 : }
88899 : }
88900 :
88901 0 : if ( p_startOfConstruct != NULL )
88902 : {
88903 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88904 : {
88905 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
88906 : {
88907 0 : std::cout << "SgMinusOp :: ";
88908 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
88909 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
88910 : }
88911 : }
88912 : else
88913 : {
88914 0 : std::cout << "SgMinusOp :: " << std::flush;
88915 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
88916 0 : std::cout << " not valid " << std::endl;
88917 : }
88918 : }
88919 :
88920 0 : if ( p_endOfConstruct != NULL )
88921 : {
88922 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88923 : {
88924 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
88925 : {
88926 0 : std::cout << "SgMinusOp :: ";
88927 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
88928 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
88929 : }
88930 : }
88931 : else
88932 : {
88933 0 : std::cout << "SgMinusOp :: " << std::flush;
88934 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
88935 0 : std::cout << " not valid " << std::endl;
88936 : }
88937 : }
88938 :
88939 0 : if ( p_parent != NULL )
88940 : {
88941 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
88942 : {
88943 0 : if ( p_parent->isInMemoryPool() == false )
88944 : {
88945 0 : std::cout << "SgMinusOp :: ";
88946 0 : std::cout << " p_parent is not in memory pool of ";
88947 0 : std::cout << p_parent->class_name() << std::endl;
88948 : }
88949 : }
88950 : else
88951 : {
88952 0 : std::cout << "SgMinusOp :: " << std::flush;
88953 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
88954 0 : std::cout << " not valid " << std::endl;
88955 : }
88956 : }
88957 :
88958 :
88959 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
88960 :
88961 0 : }
88962 :
88963 :
88964 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
88965 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
88966 : bool
88967 0 : SgMinusOp::isInMemoryPool ()
88968 : {
88969 0 : typedef unsigned char* TestType;
88970 :
88971 0 : bool found = false;
88972 :
88973 0 : ROSE_ASSERT(this != NULL);
88974 :
88975 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
88976 :
88977 0 : TestType tested = (TestType) ( this ) ;
88978 :
88979 0 : std::vector < unsigned char* > :: const_iterator block = SgMinusOp::pools.begin();
88980 :
88981 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
88982 : // while (found == false && block < Memory_Block_List.end())
88983 0 : while ( (found == false) && (block != SgMinusOp::pools.end()) )
88984 : {
88985 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgMinusOp::pool_size * sizeof(SgMinusOp) ) ) ;
88986 0 : ++block;
88987 : }
88988 :
88989 : // Special handling for static data
88990 :
88991 :
88992 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
88993 0 : ROSE_ASSERT(found == true);
88994 :
88995 0 : return found;
88996 : }
88997 : /* #line 88998 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
88998 :
88999 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
89000 :
89001 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89002 :
89003 : /* #line 89004 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
89004 :
89005 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89006 :
89007 : void
89008 0 : SgUnaryAddOp::checkDataMemberPointersIfInMemoryPool()
89009 : {
89010 : // ------------ checking pointers of SgUnaryAddOp -------------------
89011 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
89012 :
89013 0 : if ( p_operand_i != NULL )
89014 : {
89015 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89016 : {
89017 0 : if ( p_operand_i->isInMemoryPool() == false )
89018 : {
89019 0 : std::cout << "SgUnaryAddOp :: ";
89020 0 : std::cout << " p_operand_i is not in memory pool of ";
89021 0 : std::cout << p_operand_i->class_name() << std::endl;
89022 : }
89023 : }
89024 : else
89025 : {
89026 0 : std::cout << "SgUnaryAddOp :: " << std::flush;
89027 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
89028 0 : std::cout << " not valid " << std::endl;
89029 : }
89030 : }
89031 :
89032 0 : if ( p_expression_type != NULL )
89033 : {
89034 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89035 : {
89036 0 : if ( p_expression_type->isInMemoryPool() == false )
89037 : {
89038 0 : std::cout << "SgUnaryAddOp :: ";
89039 0 : std::cout << " p_expression_type is not in memory pool of ";
89040 0 : std::cout << p_expression_type->class_name() << std::endl;
89041 : }
89042 : }
89043 : else
89044 : {
89045 0 : std::cout << "SgUnaryAddOp :: " << std::flush;
89046 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
89047 0 : std::cout << " not valid " << std::endl;
89048 : }
89049 : }
89050 :
89051 0 : if ( p_operatorPosition != NULL )
89052 : {
89053 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89054 : {
89055 0 : if ( p_operatorPosition->isInMemoryPool() == false )
89056 : {
89057 0 : std::cout << "SgUnaryAddOp :: ";
89058 0 : std::cout << " p_operatorPosition is not in memory pool of ";
89059 0 : std::cout << p_operatorPosition->class_name() << std::endl;
89060 : }
89061 : }
89062 : else
89063 : {
89064 0 : std::cout << "SgUnaryAddOp :: " << std::flush;
89065 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
89066 0 : std::cout << " not valid " << std::endl;
89067 : }
89068 : }
89069 :
89070 0 : if ( p_startOfConstruct != NULL )
89071 : {
89072 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89073 : {
89074 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
89075 : {
89076 0 : std::cout << "SgUnaryAddOp :: ";
89077 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
89078 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
89079 : }
89080 : }
89081 : else
89082 : {
89083 0 : std::cout << "SgUnaryAddOp :: " << std::flush;
89084 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
89085 0 : std::cout << " not valid " << std::endl;
89086 : }
89087 : }
89088 :
89089 0 : if ( p_endOfConstruct != NULL )
89090 : {
89091 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89092 : {
89093 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
89094 : {
89095 0 : std::cout << "SgUnaryAddOp :: ";
89096 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
89097 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
89098 : }
89099 : }
89100 : else
89101 : {
89102 0 : std::cout << "SgUnaryAddOp :: " << std::flush;
89103 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
89104 0 : std::cout << " not valid " << std::endl;
89105 : }
89106 : }
89107 :
89108 0 : if ( p_parent != NULL )
89109 : {
89110 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89111 : {
89112 0 : if ( p_parent->isInMemoryPool() == false )
89113 : {
89114 0 : std::cout << "SgUnaryAddOp :: ";
89115 0 : std::cout << " p_parent is not in memory pool of ";
89116 0 : std::cout << p_parent->class_name() << std::endl;
89117 : }
89118 : }
89119 : else
89120 : {
89121 0 : std::cout << "SgUnaryAddOp :: " << std::flush;
89122 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
89123 0 : std::cout << " not valid " << std::endl;
89124 : }
89125 : }
89126 :
89127 :
89128 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89129 :
89130 0 : }
89131 :
89132 :
89133 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
89134 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
89135 : bool
89136 0 : SgUnaryAddOp::isInMemoryPool ()
89137 : {
89138 0 : typedef unsigned char* TestType;
89139 :
89140 0 : bool found = false;
89141 :
89142 0 : ROSE_ASSERT(this != NULL);
89143 :
89144 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
89145 :
89146 0 : TestType tested = (TestType) ( this ) ;
89147 :
89148 0 : std::vector < unsigned char* > :: const_iterator block = SgUnaryAddOp::pools.begin();
89149 :
89150 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
89151 : // while (found == false && block < Memory_Block_List.end())
89152 0 : while ( (found == false) && (block != SgUnaryAddOp::pools.end()) )
89153 : {
89154 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUnaryAddOp::pool_size * sizeof(SgUnaryAddOp) ) ) ;
89155 0 : ++block;
89156 : }
89157 :
89158 : // Special handling for static data
89159 :
89160 :
89161 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
89162 0 : ROSE_ASSERT(found == true);
89163 :
89164 0 : return found;
89165 : }
89166 : /* #line 89167 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
89167 :
89168 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
89169 :
89170 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89171 :
89172 : /* #line 89173 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
89173 :
89174 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89175 :
89176 : void
89177 0 : SgNotOp::checkDataMemberPointersIfInMemoryPool()
89178 : {
89179 : // ------------ checking pointers of SgNotOp -------------------
89180 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
89181 :
89182 0 : if ( p_operand_i != NULL )
89183 : {
89184 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89185 : {
89186 0 : if ( p_operand_i->isInMemoryPool() == false )
89187 : {
89188 0 : std::cout << "SgNotOp :: ";
89189 0 : std::cout << " p_operand_i is not in memory pool of ";
89190 0 : std::cout << p_operand_i->class_name() << std::endl;
89191 : }
89192 : }
89193 : else
89194 : {
89195 0 : std::cout << "SgNotOp :: " << std::flush;
89196 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
89197 0 : std::cout << " not valid " << std::endl;
89198 : }
89199 : }
89200 :
89201 0 : if ( p_expression_type != NULL )
89202 : {
89203 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89204 : {
89205 0 : if ( p_expression_type->isInMemoryPool() == false )
89206 : {
89207 0 : std::cout << "SgNotOp :: ";
89208 0 : std::cout << " p_expression_type is not in memory pool of ";
89209 0 : std::cout << p_expression_type->class_name() << std::endl;
89210 : }
89211 : }
89212 : else
89213 : {
89214 0 : std::cout << "SgNotOp :: " << std::flush;
89215 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
89216 0 : std::cout << " not valid " << std::endl;
89217 : }
89218 : }
89219 :
89220 0 : if ( p_operatorPosition != NULL )
89221 : {
89222 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89223 : {
89224 0 : if ( p_operatorPosition->isInMemoryPool() == false )
89225 : {
89226 0 : std::cout << "SgNotOp :: ";
89227 0 : std::cout << " p_operatorPosition is not in memory pool of ";
89228 0 : std::cout << p_operatorPosition->class_name() << std::endl;
89229 : }
89230 : }
89231 : else
89232 : {
89233 0 : std::cout << "SgNotOp :: " << std::flush;
89234 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
89235 0 : std::cout << " not valid " << std::endl;
89236 : }
89237 : }
89238 :
89239 0 : if ( p_startOfConstruct != NULL )
89240 : {
89241 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89242 : {
89243 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
89244 : {
89245 0 : std::cout << "SgNotOp :: ";
89246 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
89247 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
89248 : }
89249 : }
89250 : else
89251 : {
89252 0 : std::cout << "SgNotOp :: " << std::flush;
89253 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
89254 0 : std::cout << " not valid " << std::endl;
89255 : }
89256 : }
89257 :
89258 0 : if ( p_endOfConstruct != NULL )
89259 : {
89260 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89261 : {
89262 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
89263 : {
89264 0 : std::cout << "SgNotOp :: ";
89265 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
89266 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
89267 : }
89268 : }
89269 : else
89270 : {
89271 0 : std::cout << "SgNotOp :: " << std::flush;
89272 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
89273 0 : std::cout << " not valid " << std::endl;
89274 : }
89275 : }
89276 :
89277 0 : if ( p_parent != NULL )
89278 : {
89279 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89280 : {
89281 0 : if ( p_parent->isInMemoryPool() == false )
89282 : {
89283 0 : std::cout << "SgNotOp :: ";
89284 0 : std::cout << " p_parent is not in memory pool of ";
89285 0 : std::cout << p_parent->class_name() << std::endl;
89286 : }
89287 : }
89288 : else
89289 : {
89290 0 : std::cout << "SgNotOp :: " << std::flush;
89291 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
89292 0 : std::cout << " not valid " << std::endl;
89293 : }
89294 : }
89295 :
89296 :
89297 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89298 :
89299 0 : }
89300 :
89301 :
89302 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
89303 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
89304 : bool
89305 0 : SgNotOp::isInMemoryPool ()
89306 : {
89307 0 : typedef unsigned char* TestType;
89308 :
89309 0 : bool found = false;
89310 :
89311 0 : ROSE_ASSERT(this != NULL);
89312 :
89313 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
89314 :
89315 0 : TestType tested = (TestType) ( this ) ;
89316 :
89317 0 : std::vector < unsigned char* > :: const_iterator block = SgNotOp::pools.begin();
89318 :
89319 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
89320 : // while (found == false && block < Memory_Block_List.end())
89321 0 : while ( (found == false) && (block != SgNotOp::pools.end()) )
89322 : {
89323 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNotOp::pool_size * sizeof(SgNotOp) ) ) ;
89324 0 : ++block;
89325 : }
89326 :
89327 : // Special handling for static data
89328 :
89329 :
89330 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
89331 0 : ROSE_ASSERT(found == true);
89332 :
89333 0 : return found;
89334 : }
89335 : /* #line 89336 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
89336 :
89337 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
89338 :
89339 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89340 :
89341 : /* #line 89342 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
89342 :
89343 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89344 :
89345 : void
89346 0 : SgPointerDerefExp::checkDataMemberPointersIfInMemoryPool()
89347 : {
89348 : // ------------ checking pointers of SgPointerDerefExp -------------------
89349 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
89350 :
89351 0 : if ( p_operand_i != NULL )
89352 : {
89353 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89354 : {
89355 0 : if ( p_operand_i->isInMemoryPool() == false )
89356 : {
89357 0 : std::cout << "SgPointerDerefExp :: ";
89358 0 : std::cout << " p_operand_i is not in memory pool of ";
89359 0 : std::cout << p_operand_i->class_name() << std::endl;
89360 : }
89361 : }
89362 : else
89363 : {
89364 0 : std::cout << "SgPointerDerefExp :: " << std::flush;
89365 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
89366 0 : std::cout << " not valid " << std::endl;
89367 : }
89368 : }
89369 :
89370 0 : if ( p_expression_type != NULL )
89371 : {
89372 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89373 : {
89374 0 : if ( p_expression_type->isInMemoryPool() == false )
89375 : {
89376 0 : std::cout << "SgPointerDerefExp :: ";
89377 0 : std::cout << " p_expression_type is not in memory pool of ";
89378 0 : std::cout << p_expression_type->class_name() << std::endl;
89379 : }
89380 : }
89381 : else
89382 : {
89383 0 : std::cout << "SgPointerDerefExp :: " << std::flush;
89384 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
89385 0 : std::cout << " not valid " << std::endl;
89386 : }
89387 : }
89388 :
89389 0 : if ( p_operatorPosition != NULL )
89390 : {
89391 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89392 : {
89393 0 : if ( p_operatorPosition->isInMemoryPool() == false )
89394 : {
89395 0 : std::cout << "SgPointerDerefExp :: ";
89396 0 : std::cout << " p_operatorPosition is not in memory pool of ";
89397 0 : std::cout << p_operatorPosition->class_name() << std::endl;
89398 : }
89399 : }
89400 : else
89401 : {
89402 0 : std::cout << "SgPointerDerefExp :: " << std::flush;
89403 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
89404 0 : std::cout << " not valid " << std::endl;
89405 : }
89406 : }
89407 :
89408 0 : if ( p_startOfConstruct != NULL )
89409 : {
89410 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89411 : {
89412 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
89413 : {
89414 0 : std::cout << "SgPointerDerefExp :: ";
89415 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
89416 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
89417 : }
89418 : }
89419 : else
89420 : {
89421 0 : std::cout << "SgPointerDerefExp :: " << std::flush;
89422 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
89423 0 : std::cout << " not valid " << std::endl;
89424 : }
89425 : }
89426 :
89427 0 : if ( p_endOfConstruct != NULL )
89428 : {
89429 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89430 : {
89431 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
89432 : {
89433 0 : std::cout << "SgPointerDerefExp :: ";
89434 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
89435 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
89436 : }
89437 : }
89438 : else
89439 : {
89440 0 : std::cout << "SgPointerDerefExp :: " << std::flush;
89441 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
89442 0 : std::cout << " not valid " << std::endl;
89443 : }
89444 : }
89445 :
89446 0 : if ( p_parent != NULL )
89447 : {
89448 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89449 : {
89450 0 : if ( p_parent->isInMemoryPool() == false )
89451 : {
89452 0 : std::cout << "SgPointerDerefExp :: ";
89453 0 : std::cout << " p_parent is not in memory pool of ";
89454 0 : std::cout << p_parent->class_name() << std::endl;
89455 : }
89456 : }
89457 : else
89458 : {
89459 0 : std::cout << "SgPointerDerefExp :: " << std::flush;
89460 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
89461 0 : std::cout << " not valid " << std::endl;
89462 : }
89463 : }
89464 :
89465 :
89466 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89467 :
89468 0 : }
89469 :
89470 :
89471 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
89472 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
89473 : bool
89474 0 : SgPointerDerefExp::isInMemoryPool ()
89475 : {
89476 0 : typedef unsigned char* TestType;
89477 :
89478 0 : bool found = false;
89479 :
89480 0 : ROSE_ASSERT(this != NULL);
89481 :
89482 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
89483 :
89484 0 : TestType tested = (TestType) ( this ) ;
89485 :
89486 0 : std::vector < unsigned char* > :: const_iterator block = SgPointerDerefExp::pools.begin();
89487 :
89488 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
89489 : // while (found == false && block < Memory_Block_List.end())
89490 0 : while ( (found == false) && (block != SgPointerDerefExp::pools.end()) )
89491 : {
89492 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgPointerDerefExp::pool_size * sizeof(SgPointerDerefExp) ) ) ;
89493 0 : ++block;
89494 : }
89495 :
89496 : // Special handling for static data
89497 :
89498 :
89499 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
89500 0 : ROSE_ASSERT(found == true);
89501 :
89502 0 : return found;
89503 : }
89504 : /* #line 89505 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
89505 :
89506 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
89507 :
89508 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89509 :
89510 : /* #line 89511 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
89511 :
89512 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89513 :
89514 : void
89515 0 : SgAddressOfOp::checkDataMemberPointersIfInMemoryPool()
89516 : {
89517 : // ------------ checking pointers of SgAddressOfOp -------------------
89518 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
89519 :
89520 0 : if ( p_originalExpressionTree != NULL )
89521 : {
89522 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89523 : {
89524 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
89525 : {
89526 0 : std::cout << "SgAddressOfOp :: ";
89527 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
89528 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
89529 : }
89530 : }
89531 : else
89532 : {
89533 0 : std::cout << "SgAddressOfOp :: " << std::flush;
89534 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
89535 0 : std::cout << " not valid " << std::endl;
89536 : }
89537 : }
89538 :
89539 0 : if ( p_operand_i != NULL )
89540 : {
89541 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89542 : {
89543 0 : if ( p_operand_i->isInMemoryPool() == false )
89544 : {
89545 0 : std::cout << "SgAddressOfOp :: ";
89546 0 : std::cout << " p_operand_i is not in memory pool of ";
89547 0 : std::cout << p_operand_i->class_name() << std::endl;
89548 : }
89549 : }
89550 : else
89551 : {
89552 0 : std::cout << "SgAddressOfOp :: " << std::flush;
89553 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
89554 0 : std::cout << " not valid " << std::endl;
89555 : }
89556 : }
89557 :
89558 0 : if ( p_expression_type != NULL )
89559 : {
89560 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89561 : {
89562 0 : if ( p_expression_type->isInMemoryPool() == false )
89563 : {
89564 0 : std::cout << "SgAddressOfOp :: ";
89565 0 : std::cout << " p_expression_type is not in memory pool of ";
89566 0 : std::cout << p_expression_type->class_name() << std::endl;
89567 : }
89568 : }
89569 : else
89570 : {
89571 0 : std::cout << "SgAddressOfOp :: " << std::flush;
89572 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
89573 0 : std::cout << " not valid " << std::endl;
89574 : }
89575 : }
89576 :
89577 0 : if ( p_operatorPosition != NULL )
89578 : {
89579 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89580 : {
89581 0 : if ( p_operatorPosition->isInMemoryPool() == false )
89582 : {
89583 0 : std::cout << "SgAddressOfOp :: ";
89584 0 : std::cout << " p_operatorPosition is not in memory pool of ";
89585 0 : std::cout << p_operatorPosition->class_name() << std::endl;
89586 : }
89587 : }
89588 : else
89589 : {
89590 0 : std::cout << "SgAddressOfOp :: " << std::flush;
89591 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
89592 0 : std::cout << " not valid " << std::endl;
89593 : }
89594 : }
89595 :
89596 0 : if ( p_startOfConstruct != NULL )
89597 : {
89598 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89599 : {
89600 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
89601 : {
89602 0 : std::cout << "SgAddressOfOp :: ";
89603 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
89604 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
89605 : }
89606 : }
89607 : else
89608 : {
89609 0 : std::cout << "SgAddressOfOp :: " << std::flush;
89610 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
89611 0 : std::cout << " not valid " << std::endl;
89612 : }
89613 : }
89614 :
89615 0 : if ( p_endOfConstruct != NULL )
89616 : {
89617 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89618 : {
89619 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
89620 : {
89621 0 : std::cout << "SgAddressOfOp :: ";
89622 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
89623 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
89624 : }
89625 : }
89626 : else
89627 : {
89628 0 : std::cout << "SgAddressOfOp :: " << std::flush;
89629 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
89630 0 : std::cout << " not valid " << std::endl;
89631 : }
89632 : }
89633 :
89634 0 : if ( p_parent != NULL )
89635 : {
89636 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89637 : {
89638 0 : if ( p_parent->isInMemoryPool() == false )
89639 : {
89640 0 : std::cout << "SgAddressOfOp :: ";
89641 0 : std::cout << " p_parent is not in memory pool of ";
89642 0 : std::cout << p_parent->class_name() << std::endl;
89643 : }
89644 : }
89645 : else
89646 : {
89647 0 : std::cout << "SgAddressOfOp :: " << std::flush;
89648 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
89649 0 : std::cout << " not valid " << std::endl;
89650 : }
89651 : }
89652 :
89653 :
89654 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89655 :
89656 0 : }
89657 :
89658 :
89659 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
89660 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
89661 : bool
89662 0 : SgAddressOfOp::isInMemoryPool ()
89663 : {
89664 0 : typedef unsigned char* TestType;
89665 :
89666 0 : bool found = false;
89667 :
89668 0 : ROSE_ASSERT(this != NULL);
89669 :
89670 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
89671 :
89672 0 : TestType tested = (TestType) ( this ) ;
89673 :
89674 0 : std::vector < unsigned char* > :: const_iterator block = SgAddressOfOp::pools.begin();
89675 :
89676 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
89677 : // while (found == false && block < Memory_Block_List.end())
89678 0 : while ( (found == false) && (block != SgAddressOfOp::pools.end()) )
89679 : {
89680 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAddressOfOp::pool_size * sizeof(SgAddressOfOp) ) ) ;
89681 0 : ++block;
89682 : }
89683 :
89684 : // Special handling for static data
89685 :
89686 :
89687 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
89688 0 : ROSE_ASSERT(found == true);
89689 :
89690 0 : return found;
89691 : }
89692 : /* #line 89693 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
89693 :
89694 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
89695 :
89696 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89697 :
89698 : /* #line 89699 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
89699 :
89700 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89701 :
89702 : void
89703 0 : SgMinusMinusOp::checkDataMemberPointersIfInMemoryPool()
89704 : {
89705 : // ------------ checking pointers of SgMinusMinusOp -------------------
89706 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
89707 :
89708 0 : if ( p_operand_i != NULL )
89709 : {
89710 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89711 : {
89712 0 : if ( p_operand_i->isInMemoryPool() == false )
89713 : {
89714 0 : std::cout << "SgMinusMinusOp :: ";
89715 0 : std::cout << " p_operand_i is not in memory pool of ";
89716 0 : std::cout << p_operand_i->class_name() << std::endl;
89717 : }
89718 : }
89719 : else
89720 : {
89721 0 : std::cout << "SgMinusMinusOp :: " << std::flush;
89722 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
89723 0 : std::cout << " not valid " << std::endl;
89724 : }
89725 : }
89726 :
89727 0 : if ( p_expression_type != NULL )
89728 : {
89729 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89730 : {
89731 0 : if ( p_expression_type->isInMemoryPool() == false )
89732 : {
89733 0 : std::cout << "SgMinusMinusOp :: ";
89734 0 : std::cout << " p_expression_type is not in memory pool of ";
89735 0 : std::cout << p_expression_type->class_name() << std::endl;
89736 : }
89737 : }
89738 : else
89739 : {
89740 0 : std::cout << "SgMinusMinusOp :: " << std::flush;
89741 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
89742 0 : std::cout << " not valid " << std::endl;
89743 : }
89744 : }
89745 :
89746 0 : if ( p_operatorPosition != NULL )
89747 : {
89748 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89749 : {
89750 0 : if ( p_operatorPosition->isInMemoryPool() == false )
89751 : {
89752 0 : std::cout << "SgMinusMinusOp :: ";
89753 0 : std::cout << " p_operatorPosition is not in memory pool of ";
89754 0 : std::cout << p_operatorPosition->class_name() << std::endl;
89755 : }
89756 : }
89757 : else
89758 : {
89759 0 : std::cout << "SgMinusMinusOp :: " << std::flush;
89760 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
89761 0 : std::cout << " not valid " << std::endl;
89762 : }
89763 : }
89764 :
89765 0 : if ( p_startOfConstruct != NULL )
89766 : {
89767 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89768 : {
89769 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
89770 : {
89771 0 : std::cout << "SgMinusMinusOp :: ";
89772 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
89773 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
89774 : }
89775 : }
89776 : else
89777 : {
89778 0 : std::cout << "SgMinusMinusOp :: " << std::flush;
89779 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
89780 0 : std::cout << " not valid " << std::endl;
89781 : }
89782 : }
89783 :
89784 0 : if ( p_endOfConstruct != NULL )
89785 : {
89786 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89787 : {
89788 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
89789 : {
89790 0 : std::cout << "SgMinusMinusOp :: ";
89791 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
89792 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
89793 : }
89794 : }
89795 : else
89796 : {
89797 0 : std::cout << "SgMinusMinusOp :: " << std::flush;
89798 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
89799 0 : std::cout << " not valid " << std::endl;
89800 : }
89801 : }
89802 :
89803 0 : if ( p_parent != NULL )
89804 : {
89805 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89806 : {
89807 0 : if ( p_parent->isInMemoryPool() == false )
89808 : {
89809 0 : std::cout << "SgMinusMinusOp :: ";
89810 0 : std::cout << " p_parent is not in memory pool of ";
89811 0 : std::cout << p_parent->class_name() << std::endl;
89812 : }
89813 : }
89814 : else
89815 : {
89816 0 : std::cout << "SgMinusMinusOp :: " << std::flush;
89817 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
89818 0 : std::cout << " not valid " << std::endl;
89819 : }
89820 : }
89821 :
89822 :
89823 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89824 :
89825 0 : }
89826 :
89827 :
89828 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
89829 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
89830 : bool
89831 0 : SgMinusMinusOp::isInMemoryPool ()
89832 : {
89833 0 : typedef unsigned char* TestType;
89834 :
89835 0 : bool found = false;
89836 :
89837 0 : ROSE_ASSERT(this != NULL);
89838 :
89839 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
89840 :
89841 0 : TestType tested = (TestType) ( this ) ;
89842 :
89843 0 : std::vector < unsigned char* > :: const_iterator block = SgMinusMinusOp::pools.begin();
89844 :
89845 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
89846 : // while (found == false && block < Memory_Block_List.end())
89847 0 : while ( (found == false) && (block != SgMinusMinusOp::pools.end()) )
89848 : {
89849 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgMinusMinusOp::pool_size * sizeof(SgMinusMinusOp) ) ) ;
89850 0 : ++block;
89851 : }
89852 :
89853 : // Special handling for static data
89854 :
89855 :
89856 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
89857 0 : ROSE_ASSERT(found == true);
89858 :
89859 0 : return found;
89860 : }
89861 : /* #line 89862 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
89862 :
89863 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
89864 :
89865 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89866 :
89867 : /* #line 89868 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
89868 :
89869 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89870 :
89871 : void
89872 0 : SgPlusPlusOp::checkDataMemberPointersIfInMemoryPool()
89873 : {
89874 : // ------------ checking pointers of SgPlusPlusOp -------------------
89875 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
89876 :
89877 0 : if ( p_operand_i != NULL )
89878 : {
89879 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89880 : {
89881 0 : if ( p_operand_i->isInMemoryPool() == false )
89882 : {
89883 0 : std::cout << "SgPlusPlusOp :: ";
89884 0 : std::cout << " p_operand_i is not in memory pool of ";
89885 0 : std::cout << p_operand_i->class_name() << std::endl;
89886 : }
89887 : }
89888 : else
89889 : {
89890 0 : std::cout << "SgPlusPlusOp :: " << std::flush;
89891 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
89892 0 : std::cout << " not valid " << std::endl;
89893 : }
89894 : }
89895 :
89896 0 : if ( p_expression_type != NULL )
89897 : {
89898 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89899 : {
89900 0 : if ( p_expression_type->isInMemoryPool() == false )
89901 : {
89902 0 : std::cout << "SgPlusPlusOp :: ";
89903 0 : std::cout << " p_expression_type is not in memory pool of ";
89904 0 : std::cout << p_expression_type->class_name() << std::endl;
89905 : }
89906 : }
89907 : else
89908 : {
89909 0 : std::cout << "SgPlusPlusOp :: " << std::flush;
89910 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
89911 0 : std::cout << " not valid " << std::endl;
89912 : }
89913 : }
89914 :
89915 0 : if ( p_operatorPosition != NULL )
89916 : {
89917 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89918 : {
89919 0 : if ( p_operatorPosition->isInMemoryPool() == false )
89920 : {
89921 0 : std::cout << "SgPlusPlusOp :: ";
89922 0 : std::cout << " p_operatorPosition is not in memory pool of ";
89923 0 : std::cout << p_operatorPosition->class_name() << std::endl;
89924 : }
89925 : }
89926 : else
89927 : {
89928 0 : std::cout << "SgPlusPlusOp :: " << std::flush;
89929 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
89930 0 : std::cout << " not valid " << std::endl;
89931 : }
89932 : }
89933 :
89934 0 : if ( p_startOfConstruct != NULL )
89935 : {
89936 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89937 : {
89938 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
89939 : {
89940 0 : std::cout << "SgPlusPlusOp :: ";
89941 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
89942 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
89943 : }
89944 : }
89945 : else
89946 : {
89947 0 : std::cout << "SgPlusPlusOp :: " << std::flush;
89948 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
89949 0 : std::cout << " not valid " << std::endl;
89950 : }
89951 : }
89952 :
89953 0 : if ( p_endOfConstruct != NULL )
89954 : {
89955 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89956 : {
89957 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
89958 : {
89959 0 : std::cout << "SgPlusPlusOp :: ";
89960 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
89961 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
89962 : }
89963 : }
89964 : else
89965 : {
89966 0 : std::cout << "SgPlusPlusOp :: " << std::flush;
89967 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
89968 0 : std::cout << " not valid " << std::endl;
89969 : }
89970 : }
89971 :
89972 0 : if ( p_parent != NULL )
89973 : {
89974 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
89975 : {
89976 0 : if ( p_parent->isInMemoryPool() == false )
89977 : {
89978 0 : std::cout << "SgPlusPlusOp :: ";
89979 0 : std::cout << " p_parent is not in memory pool of ";
89980 0 : std::cout << p_parent->class_name() << std::endl;
89981 : }
89982 : }
89983 : else
89984 : {
89985 0 : std::cout << "SgPlusPlusOp :: " << std::flush;
89986 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
89987 0 : std::cout << " not valid " << std::endl;
89988 : }
89989 : }
89990 :
89991 :
89992 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
89993 :
89994 0 : }
89995 :
89996 :
89997 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
89998 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
89999 : bool
90000 0 : SgPlusPlusOp::isInMemoryPool ()
90001 : {
90002 0 : typedef unsigned char* TestType;
90003 :
90004 0 : bool found = false;
90005 :
90006 0 : ROSE_ASSERT(this != NULL);
90007 :
90008 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
90009 :
90010 0 : TestType tested = (TestType) ( this ) ;
90011 :
90012 0 : std::vector < unsigned char* > :: const_iterator block = SgPlusPlusOp::pools.begin();
90013 :
90014 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
90015 : // while (found == false && block < Memory_Block_List.end())
90016 0 : while ( (found == false) && (block != SgPlusPlusOp::pools.end()) )
90017 : {
90018 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgPlusPlusOp::pool_size * sizeof(SgPlusPlusOp) ) ) ;
90019 0 : ++block;
90020 : }
90021 :
90022 : // Special handling for static data
90023 :
90024 :
90025 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
90026 0 : ROSE_ASSERT(found == true);
90027 :
90028 0 : return found;
90029 : }
90030 : /* #line 90031 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
90031 :
90032 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
90033 :
90034 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90035 :
90036 : /* #line 90037 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
90037 :
90038 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90039 :
90040 : void
90041 0 : SgBitComplementOp::checkDataMemberPointersIfInMemoryPool()
90042 : {
90043 : // ------------ checking pointers of SgBitComplementOp -------------------
90044 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
90045 :
90046 0 : if ( p_operand_i != NULL )
90047 : {
90048 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90049 : {
90050 0 : if ( p_operand_i->isInMemoryPool() == false )
90051 : {
90052 0 : std::cout << "SgBitComplementOp :: ";
90053 0 : std::cout << " p_operand_i is not in memory pool of ";
90054 0 : std::cout << p_operand_i->class_name() << std::endl;
90055 : }
90056 : }
90057 : else
90058 : {
90059 0 : std::cout << "SgBitComplementOp :: " << std::flush;
90060 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
90061 0 : std::cout << " not valid " << std::endl;
90062 : }
90063 : }
90064 :
90065 0 : if ( p_expression_type != NULL )
90066 : {
90067 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90068 : {
90069 0 : if ( p_expression_type->isInMemoryPool() == false )
90070 : {
90071 0 : std::cout << "SgBitComplementOp :: ";
90072 0 : std::cout << " p_expression_type is not in memory pool of ";
90073 0 : std::cout << p_expression_type->class_name() << std::endl;
90074 : }
90075 : }
90076 : else
90077 : {
90078 0 : std::cout << "SgBitComplementOp :: " << std::flush;
90079 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
90080 0 : std::cout << " not valid " << std::endl;
90081 : }
90082 : }
90083 :
90084 0 : if ( p_operatorPosition != NULL )
90085 : {
90086 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90087 : {
90088 0 : if ( p_operatorPosition->isInMemoryPool() == false )
90089 : {
90090 0 : std::cout << "SgBitComplementOp :: ";
90091 0 : std::cout << " p_operatorPosition is not in memory pool of ";
90092 0 : std::cout << p_operatorPosition->class_name() << std::endl;
90093 : }
90094 : }
90095 : else
90096 : {
90097 0 : std::cout << "SgBitComplementOp :: " << std::flush;
90098 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
90099 0 : std::cout << " not valid " << std::endl;
90100 : }
90101 : }
90102 :
90103 0 : if ( p_startOfConstruct != NULL )
90104 : {
90105 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90106 : {
90107 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
90108 : {
90109 0 : std::cout << "SgBitComplementOp :: ";
90110 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
90111 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
90112 : }
90113 : }
90114 : else
90115 : {
90116 0 : std::cout << "SgBitComplementOp :: " << std::flush;
90117 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
90118 0 : std::cout << " not valid " << std::endl;
90119 : }
90120 : }
90121 :
90122 0 : if ( p_endOfConstruct != NULL )
90123 : {
90124 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90125 : {
90126 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
90127 : {
90128 0 : std::cout << "SgBitComplementOp :: ";
90129 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
90130 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
90131 : }
90132 : }
90133 : else
90134 : {
90135 0 : std::cout << "SgBitComplementOp :: " << std::flush;
90136 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
90137 0 : std::cout << " not valid " << std::endl;
90138 : }
90139 : }
90140 :
90141 0 : if ( p_parent != NULL )
90142 : {
90143 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90144 : {
90145 0 : if ( p_parent->isInMemoryPool() == false )
90146 : {
90147 0 : std::cout << "SgBitComplementOp :: ";
90148 0 : std::cout << " p_parent is not in memory pool of ";
90149 0 : std::cout << p_parent->class_name() << std::endl;
90150 : }
90151 : }
90152 : else
90153 : {
90154 0 : std::cout << "SgBitComplementOp :: " << std::flush;
90155 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
90156 0 : std::cout << " not valid " << std::endl;
90157 : }
90158 : }
90159 :
90160 :
90161 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90162 :
90163 0 : }
90164 :
90165 :
90166 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
90167 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
90168 : bool
90169 0 : SgBitComplementOp::isInMemoryPool ()
90170 : {
90171 0 : typedef unsigned char* TestType;
90172 :
90173 0 : bool found = false;
90174 :
90175 0 : ROSE_ASSERT(this != NULL);
90176 :
90177 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
90178 :
90179 0 : TestType tested = (TestType) ( this ) ;
90180 :
90181 0 : std::vector < unsigned char* > :: const_iterator block = SgBitComplementOp::pools.begin();
90182 :
90183 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
90184 : // while (found == false && block < Memory_Block_List.end())
90185 0 : while ( (found == false) && (block != SgBitComplementOp::pools.end()) )
90186 : {
90187 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgBitComplementOp::pool_size * sizeof(SgBitComplementOp) ) ) ;
90188 0 : ++block;
90189 : }
90190 :
90191 : // Special handling for static data
90192 :
90193 :
90194 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
90195 0 : ROSE_ASSERT(found == true);
90196 :
90197 0 : return found;
90198 : }
90199 : /* #line 90200 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
90200 :
90201 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
90202 :
90203 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90204 :
90205 : /* #line 90206 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
90206 :
90207 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90208 :
90209 : void
90210 0 : SgCastExp::checkDataMemberPointersIfInMemoryPool()
90211 : {
90212 : // ------------ checking pointers of SgCastExp -------------------
90213 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
90214 :
90215 0 : if ( p_originalExpressionTree != NULL )
90216 : {
90217 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90218 : {
90219 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
90220 : {
90221 0 : std::cout << "SgCastExp :: ";
90222 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
90223 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
90224 : }
90225 : }
90226 : else
90227 : {
90228 0 : std::cout << "SgCastExp :: " << std::flush;
90229 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
90230 0 : std::cout << " not valid " << std::endl;
90231 : }
90232 : }
90233 :
90234 0 : if ( p_operand_i != NULL )
90235 : {
90236 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90237 : {
90238 0 : if ( p_operand_i->isInMemoryPool() == false )
90239 : {
90240 0 : std::cout << "SgCastExp :: ";
90241 0 : std::cout << " p_operand_i is not in memory pool of ";
90242 0 : std::cout << p_operand_i->class_name() << std::endl;
90243 : }
90244 : }
90245 : else
90246 : {
90247 0 : std::cout << "SgCastExp :: " << std::flush;
90248 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
90249 0 : std::cout << " not valid " << std::endl;
90250 : }
90251 : }
90252 :
90253 0 : if ( p_expression_type != NULL )
90254 : {
90255 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90256 : {
90257 0 : if ( p_expression_type->isInMemoryPool() == false )
90258 : {
90259 0 : std::cout << "SgCastExp :: ";
90260 0 : std::cout << " p_expression_type is not in memory pool of ";
90261 0 : std::cout << p_expression_type->class_name() << std::endl;
90262 : }
90263 : }
90264 : else
90265 : {
90266 0 : std::cout << "SgCastExp :: " << std::flush;
90267 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
90268 0 : std::cout << " not valid " << std::endl;
90269 : }
90270 : }
90271 :
90272 0 : if ( p_operatorPosition != NULL )
90273 : {
90274 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90275 : {
90276 0 : if ( p_operatorPosition->isInMemoryPool() == false )
90277 : {
90278 0 : std::cout << "SgCastExp :: ";
90279 0 : std::cout << " p_operatorPosition is not in memory pool of ";
90280 0 : std::cout << p_operatorPosition->class_name() << std::endl;
90281 : }
90282 : }
90283 : else
90284 : {
90285 0 : std::cout << "SgCastExp :: " << std::flush;
90286 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
90287 0 : std::cout << " not valid " << std::endl;
90288 : }
90289 : }
90290 :
90291 0 : if ( p_startOfConstruct != NULL )
90292 : {
90293 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90294 : {
90295 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
90296 : {
90297 0 : std::cout << "SgCastExp :: ";
90298 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
90299 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
90300 : }
90301 : }
90302 : else
90303 : {
90304 0 : std::cout << "SgCastExp :: " << std::flush;
90305 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
90306 0 : std::cout << " not valid " << std::endl;
90307 : }
90308 : }
90309 :
90310 0 : if ( p_endOfConstruct != NULL )
90311 : {
90312 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90313 : {
90314 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
90315 : {
90316 0 : std::cout << "SgCastExp :: ";
90317 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
90318 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
90319 : }
90320 : }
90321 : else
90322 : {
90323 0 : std::cout << "SgCastExp :: " << std::flush;
90324 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
90325 0 : std::cout << " not valid " << std::endl;
90326 : }
90327 : }
90328 :
90329 0 : if ( p_parent != NULL )
90330 : {
90331 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90332 : {
90333 0 : if ( p_parent->isInMemoryPool() == false )
90334 : {
90335 0 : std::cout << "SgCastExp :: ";
90336 0 : std::cout << " p_parent is not in memory pool of ";
90337 0 : std::cout << p_parent->class_name() << std::endl;
90338 : }
90339 : }
90340 : else
90341 : {
90342 0 : std::cout << "SgCastExp :: " << std::flush;
90343 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
90344 0 : std::cout << " not valid " << std::endl;
90345 : }
90346 : }
90347 :
90348 :
90349 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90350 :
90351 0 : }
90352 :
90353 :
90354 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
90355 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
90356 : bool
90357 0 : SgCastExp::isInMemoryPool ()
90358 : {
90359 0 : typedef unsigned char* TestType;
90360 :
90361 0 : bool found = false;
90362 :
90363 0 : ROSE_ASSERT(this != NULL);
90364 :
90365 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
90366 :
90367 0 : TestType tested = (TestType) ( this ) ;
90368 :
90369 0 : std::vector < unsigned char* > :: const_iterator block = SgCastExp::pools.begin();
90370 :
90371 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
90372 : // while (found == false && block < Memory_Block_List.end())
90373 0 : while ( (found == false) && (block != SgCastExp::pools.end()) )
90374 : {
90375 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCastExp::pool_size * sizeof(SgCastExp) ) ) ;
90376 0 : ++block;
90377 : }
90378 :
90379 : // Special handling for static data
90380 :
90381 :
90382 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
90383 0 : ROSE_ASSERT(found == true);
90384 :
90385 0 : return found;
90386 : }
90387 : /* #line 90388 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
90388 :
90389 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
90390 :
90391 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90392 :
90393 : /* #line 90394 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
90394 :
90395 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90396 :
90397 : void
90398 0 : SgThrowOp::checkDataMemberPointersIfInMemoryPool()
90399 : {
90400 : // ------------ checking pointers of SgThrowOp -------------------
90401 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
90402 :
90403 0 : if ( p_operand_i != NULL )
90404 : {
90405 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90406 : {
90407 0 : if ( p_operand_i->isInMemoryPool() == false )
90408 : {
90409 0 : std::cout << "SgThrowOp :: ";
90410 0 : std::cout << " p_operand_i is not in memory pool of ";
90411 0 : std::cout << p_operand_i->class_name() << std::endl;
90412 : }
90413 : }
90414 : else
90415 : {
90416 0 : std::cout << "SgThrowOp :: " << std::flush;
90417 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
90418 0 : std::cout << " not valid " << std::endl;
90419 : }
90420 : }
90421 :
90422 0 : if ( p_expression_type != NULL )
90423 : {
90424 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90425 : {
90426 0 : if ( p_expression_type->isInMemoryPool() == false )
90427 : {
90428 0 : std::cout << "SgThrowOp :: ";
90429 0 : std::cout << " p_expression_type is not in memory pool of ";
90430 0 : std::cout << p_expression_type->class_name() << std::endl;
90431 : }
90432 : }
90433 : else
90434 : {
90435 0 : std::cout << "SgThrowOp :: " << std::flush;
90436 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
90437 0 : std::cout << " not valid " << std::endl;
90438 : }
90439 : }
90440 :
90441 0 : if ( p_operatorPosition != NULL )
90442 : {
90443 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90444 : {
90445 0 : if ( p_operatorPosition->isInMemoryPool() == false )
90446 : {
90447 0 : std::cout << "SgThrowOp :: ";
90448 0 : std::cout << " p_operatorPosition is not in memory pool of ";
90449 0 : std::cout << p_operatorPosition->class_name() << std::endl;
90450 : }
90451 : }
90452 : else
90453 : {
90454 0 : std::cout << "SgThrowOp :: " << std::flush;
90455 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
90456 0 : std::cout << " not valid " << std::endl;
90457 : }
90458 : }
90459 :
90460 0 : if ( p_startOfConstruct != NULL )
90461 : {
90462 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90463 : {
90464 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
90465 : {
90466 0 : std::cout << "SgThrowOp :: ";
90467 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
90468 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
90469 : }
90470 : }
90471 : else
90472 : {
90473 0 : std::cout << "SgThrowOp :: " << std::flush;
90474 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
90475 0 : std::cout << " not valid " << std::endl;
90476 : }
90477 : }
90478 :
90479 0 : if ( p_endOfConstruct != NULL )
90480 : {
90481 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90482 : {
90483 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
90484 : {
90485 0 : std::cout << "SgThrowOp :: ";
90486 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
90487 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
90488 : }
90489 : }
90490 : else
90491 : {
90492 0 : std::cout << "SgThrowOp :: " << std::flush;
90493 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
90494 0 : std::cout << " not valid " << std::endl;
90495 : }
90496 : }
90497 :
90498 0 : if ( p_parent != NULL )
90499 : {
90500 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90501 : {
90502 0 : if ( p_parent->isInMemoryPool() == false )
90503 : {
90504 0 : std::cout << "SgThrowOp :: ";
90505 0 : std::cout << " p_parent is not in memory pool of ";
90506 0 : std::cout << p_parent->class_name() << std::endl;
90507 : }
90508 : }
90509 : else
90510 : {
90511 0 : std::cout << "SgThrowOp :: " << std::flush;
90512 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
90513 0 : std::cout << " not valid " << std::endl;
90514 : }
90515 : }
90516 :
90517 :
90518 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90519 :
90520 0 : }
90521 :
90522 :
90523 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
90524 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
90525 : bool
90526 0 : SgThrowOp::isInMemoryPool ()
90527 : {
90528 0 : typedef unsigned char* TestType;
90529 :
90530 0 : bool found = false;
90531 :
90532 0 : ROSE_ASSERT(this != NULL);
90533 :
90534 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
90535 :
90536 0 : TestType tested = (TestType) ( this ) ;
90537 :
90538 0 : std::vector < unsigned char* > :: const_iterator block = SgThrowOp::pools.begin();
90539 :
90540 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
90541 : // while (found == false && block < Memory_Block_List.end())
90542 0 : while ( (found == false) && (block != SgThrowOp::pools.end()) )
90543 : {
90544 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgThrowOp::pool_size * sizeof(SgThrowOp) ) ) ;
90545 0 : ++block;
90546 : }
90547 :
90548 : // Special handling for static data
90549 :
90550 :
90551 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
90552 0 : ROSE_ASSERT(found == true);
90553 :
90554 0 : return found;
90555 : }
90556 : /* #line 90557 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
90557 :
90558 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
90559 :
90560 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90561 :
90562 : /* #line 90563 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
90563 :
90564 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90565 :
90566 : void
90567 0 : SgRealPartOp::checkDataMemberPointersIfInMemoryPool()
90568 : {
90569 : // ------------ checking pointers of SgRealPartOp -------------------
90570 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
90571 :
90572 0 : if ( p_operand_i != NULL )
90573 : {
90574 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90575 : {
90576 0 : if ( p_operand_i->isInMemoryPool() == false )
90577 : {
90578 0 : std::cout << "SgRealPartOp :: ";
90579 0 : std::cout << " p_operand_i is not in memory pool of ";
90580 0 : std::cout << p_operand_i->class_name() << std::endl;
90581 : }
90582 : }
90583 : else
90584 : {
90585 0 : std::cout << "SgRealPartOp :: " << std::flush;
90586 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
90587 0 : std::cout << " not valid " << std::endl;
90588 : }
90589 : }
90590 :
90591 0 : if ( p_expression_type != NULL )
90592 : {
90593 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90594 : {
90595 0 : if ( p_expression_type->isInMemoryPool() == false )
90596 : {
90597 0 : std::cout << "SgRealPartOp :: ";
90598 0 : std::cout << " p_expression_type is not in memory pool of ";
90599 0 : std::cout << p_expression_type->class_name() << std::endl;
90600 : }
90601 : }
90602 : else
90603 : {
90604 0 : std::cout << "SgRealPartOp :: " << std::flush;
90605 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
90606 0 : std::cout << " not valid " << std::endl;
90607 : }
90608 : }
90609 :
90610 0 : if ( p_operatorPosition != NULL )
90611 : {
90612 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90613 : {
90614 0 : if ( p_operatorPosition->isInMemoryPool() == false )
90615 : {
90616 0 : std::cout << "SgRealPartOp :: ";
90617 0 : std::cout << " p_operatorPosition is not in memory pool of ";
90618 0 : std::cout << p_operatorPosition->class_name() << std::endl;
90619 : }
90620 : }
90621 : else
90622 : {
90623 0 : std::cout << "SgRealPartOp :: " << std::flush;
90624 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
90625 0 : std::cout << " not valid " << std::endl;
90626 : }
90627 : }
90628 :
90629 0 : if ( p_startOfConstruct != NULL )
90630 : {
90631 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90632 : {
90633 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
90634 : {
90635 0 : std::cout << "SgRealPartOp :: ";
90636 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
90637 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
90638 : }
90639 : }
90640 : else
90641 : {
90642 0 : std::cout << "SgRealPartOp :: " << std::flush;
90643 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
90644 0 : std::cout << " not valid " << std::endl;
90645 : }
90646 : }
90647 :
90648 0 : if ( p_endOfConstruct != NULL )
90649 : {
90650 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90651 : {
90652 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
90653 : {
90654 0 : std::cout << "SgRealPartOp :: ";
90655 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
90656 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
90657 : }
90658 : }
90659 : else
90660 : {
90661 0 : std::cout << "SgRealPartOp :: " << std::flush;
90662 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
90663 0 : std::cout << " not valid " << std::endl;
90664 : }
90665 : }
90666 :
90667 0 : if ( p_parent != NULL )
90668 : {
90669 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90670 : {
90671 0 : if ( p_parent->isInMemoryPool() == false )
90672 : {
90673 0 : std::cout << "SgRealPartOp :: ";
90674 0 : std::cout << " p_parent is not in memory pool of ";
90675 0 : std::cout << p_parent->class_name() << std::endl;
90676 : }
90677 : }
90678 : else
90679 : {
90680 0 : std::cout << "SgRealPartOp :: " << std::flush;
90681 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
90682 0 : std::cout << " not valid " << std::endl;
90683 : }
90684 : }
90685 :
90686 :
90687 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90688 :
90689 0 : }
90690 :
90691 :
90692 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
90693 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
90694 : bool
90695 0 : SgRealPartOp::isInMemoryPool ()
90696 : {
90697 0 : typedef unsigned char* TestType;
90698 :
90699 0 : bool found = false;
90700 :
90701 0 : ROSE_ASSERT(this != NULL);
90702 :
90703 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
90704 :
90705 0 : TestType tested = (TestType) ( this ) ;
90706 :
90707 0 : std::vector < unsigned char* > :: const_iterator block = SgRealPartOp::pools.begin();
90708 :
90709 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
90710 : // while (found == false && block < Memory_Block_List.end())
90711 0 : while ( (found == false) && (block != SgRealPartOp::pools.end()) )
90712 : {
90713 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgRealPartOp::pool_size * sizeof(SgRealPartOp) ) ) ;
90714 0 : ++block;
90715 : }
90716 :
90717 : // Special handling for static data
90718 :
90719 :
90720 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
90721 0 : ROSE_ASSERT(found == true);
90722 :
90723 0 : return found;
90724 : }
90725 : /* #line 90726 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
90726 :
90727 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
90728 :
90729 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90730 :
90731 : /* #line 90732 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
90732 :
90733 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90734 :
90735 : void
90736 0 : SgImagPartOp::checkDataMemberPointersIfInMemoryPool()
90737 : {
90738 : // ------------ checking pointers of SgImagPartOp -------------------
90739 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
90740 :
90741 0 : if ( p_operand_i != NULL )
90742 : {
90743 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90744 : {
90745 0 : if ( p_operand_i->isInMemoryPool() == false )
90746 : {
90747 0 : std::cout << "SgImagPartOp :: ";
90748 0 : std::cout << " p_operand_i is not in memory pool of ";
90749 0 : std::cout << p_operand_i->class_name() << std::endl;
90750 : }
90751 : }
90752 : else
90753 : {
90754 0 : std::cout << "SgImagPartOp :: " << std::flush;
90755 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
90756 0 : std::cout << " not valid " << std::endl;
90757 : }
90758 : }
90759 :
90760 0 : if ( p_expression_type != NULL )
90761 : {
90762 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90763 : {
90764 0 : if ( p_expression_type->isInMemoryPool() == false )
90765 : {
90766 0 : std::cout << "SgImagPartOp :: ";
90767 0 : std::cout << " p_expression_type is not in memory pool of ";
90768 0 : std::cout << p_expression_type->class_name() << std::endl;
90769 : }
90770 : }
90771 : else
90772 : {
90773 0 : std::cout << "SgImagPartOp :: " << std::flush;
90774 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
90775 0 : std::cout << " not valid " << std::endl;
90776 : }
90777 : }
90778 :
90779 0 : if ( p_operatorPosition != NULL )
90780 : {
90781 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90782 : {
90783 0 : if ( p_operatorPosition->isInMemoryPool() == false )
90784 : {
90785 0 : std::cout << "SgImagPartOp :: ";
90786 0 : std::cout << " p_operatorPosition is not in memory pool of ";
90787 0 : std::cout << p_operatorPosition->class_name() << std::endl;
90788 : }
90789 : }
90790 : else
90791 : {
90792 0 : std::cout << "SgImagPartOp :: " << std::flush;
90793 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
90794 0 : std::cout << " not valid " << std::endl;
90795 : }
90796 : }
90797 :
90798 0 : if ( p_startOfConstruct != NULL )
90799 : {
90800 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90801 : {
90802 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
90803 : {
90804 0 : std::cout << "SgImagPartOp :: ";
90805 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
90806 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
90807 : }
90808 : }
90809 : else
90810 : {
90811 0 : std::cout << "SgImagPartOp :: " << std::flush;
90812 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
90813 0 : std::cout << " not valid " << std::endl;
90814 : }
90815 : }
90816 :
90817 0 : if ( p_endOfConstruct != NULL )
90818 : {
90819 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90820 : {
90821 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
90822 : {
90823 0 : std::cout << "SgImagPartOp :: ";
90824 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
90825 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
90826 : }
90827 : }
90828 : else
90829 : {
90830 0 : std::cout << "SgImagPartOp :: " << std::flush;
90831 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
90832 0 : std::cout << " not valid " << std::endl;
90833 : }
90834 : }
90835 :
90836 0 : if ( p_parent != NULL )
90837 : {
90838 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90839 : {
90840 0 : if ( p_parent->isInMemoryPool() == false )
90841 : {
90842 0 : std::cout << "SgImagPartOp :: ";
90843 0 : std::cout << " p_parent is not in memory pool of ";
90844 0 : std::cout << p_parent->class_name() << std::endl;
90845 : }
90846 : }
90847 : else
90848 : {
90849 0 : std::cout << "SgImagPartOp :: " << std::flush;
90850 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
90851 0 : std::cout << " not valid " << std::endl;
90852 : }
90853 : }
90854 :
90855 :
90856 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90857 :
90858 0 : }
90859 :
90860 :
90861 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
90862 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
90863 : bool
90864 0 : SgImagPartOp::isInMemoryPool ()
90865 : {
90866 0 : typedef unsigned char* TestType;
90867 :
90868 0 : bool found = false;
90869 :
90870 0 : ROSE_ASSERT(this != NULL);
90871 :
90872 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
90873 :
90874 0 : TestType tested = (TestType) ( this ) ;
90875 :
90876 0 : std::vector < unsigned char* > :: const_iterator block = SgImagPartOp::pools.begin();
90877 :
90878 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
90879 : // while (found == false && block < Memory_Block_List.end())
90880 0 : while ( (found == false) && (block != SgImagPartOp::pools.end()) )
90881 : {
90882 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgImagPartOp::pool_size * sizeof(SgImagPartOp) ) ) ;
90883 0 : ++block;
90884 : }
90885 :
90886 : // Special handling for static data
90887 :
90888 :
90889 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
90890 0 : ROSE_ASSERT(found == true);
90891 :
90892 0 : return found;
90893 : }
90894 : /* #line 90895 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
90895 :
90896 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
90897 :
90898 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90899 :
90900 : /* #line 90901 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
90901 :
90902 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
90903 :
90904 : void
90905 0 : SgConjugateOp::checkDataMemberPointersIfInMemoryPool()
90906 : {
90907 : // ------------ checking pointers of SgConjugateOp -------------------
90908 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
90909 :
90910 0 : if ( p_operand_i != NULL )
90911 : {
90912 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90913 : {
90914 0 : if ( p_operand_i->isInMemoryPool() == false )
90915 : {
90916 0 : std::cout << "SgConjugateOp :: ";
90917 0 : std::cout << " p_operand_i is not in memory pool of ";
90918 0 : std::cout << p_operand_i->class_name() << std::endl;
90919 : }
90920 : }
90921 : else
90922 : {
90923 0 : std::cout << "SgConjugateOp :: " << std::flush;
90924 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
90925 0 : std::cout << " not valid " << std::endl;
90926 : }
90927 : }
90928 :
90929 0 : if ( p_expression_type != NULL )
90930 : {
90931 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90932 : {
90933 0 : if ( p_expression_type->isInMemoryPool() == false )
90934 : {
90935 0 : std::cout << "SgConjugateOp :: ";
90936 0 : std::cout << " p_expression_type is not in memory pool of ";
90937 0 : std::cout << p_expression_type->class_name() << std::endl;
90938 : }
90939 : }
90940 : else
90941 : {
90942 0 : std::cout << "SgConjugateOp :: " << std::flush;
90943 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
90944 0 : std::cout << " not valid " << std::endl;
90945 : }
90946 : }
90947 :
90948 0 : if ( p_operatorPosition != NULL )
90949 : {
90950 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90951 : {
90952 0 : if ( p_operatorPosition->isInMemoryPool() == false )
90953 : {
90954 0 : std::cout << "SgConjugateOp :: ";
90955 0 : std::cout << " p_operatorPosition is not in memory pool of ";
90956 0 : std::cout << p_operatorPosition->class_name() << std::endl;
90957 : }
90958 : }
90959 : else
90960 : {
90961 0 : std::cout << "SgConjugateOp :: " << std::flush;
90962 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
90963 0 : std::cout << " not valid " << std::endl;
90964 : }
90965 : }
90966 :
90967 0 : if ( p_startOfConstruct != NULL )
90968 : {
90969 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90970 : {
90971 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
90972 : {
90973 0 : std::cout << "SgConjugateOp :: ";
90974 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
90975 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
90976 : }
90977 : }
90978 : else
90979 : {
90980 0 : std::cout << "SgConjugateOp :: " << std::flush;
90981 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
90982 0 : std::cout << " not valid " << std::endl;
90983 : }
90984 : }
90985 :
90986 0 : if ( p_endOfConstruct != NULL )
90987 : {
90988 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
90989 : {
90990 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
90991 : {
90992 0 : std::cout << "SgConjugateOp :: ";
90993 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
90994 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
90995 : }
90996 : }
90997 : else
90998 : {
90999 0 : std::cout << "SgConjugateOp :: " << std::flush;
91000 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
91001 0 : std::cout << " not valid " << std::endl;
91002 : }
91003 : }
91004 :
91005 0 : if ( p_parent != NULL )
91006 : {
91007 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91008 : {
91009 0 : if ( p_parent->isInMemoryPool() == false )
91010 : {
91011 0 : std::cout << "SgConjugateOp :: ";
91012 0 : std::cout << " p_parent is not in memory pool of ";
91013 0 : std::cout << p_parent->class_name() << std::endl;
91014 : }
91015 : }
91016 : else
91017 : {
91018 0 : std::cout << "SgConjugateOp :: " << std::flush;
91019 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
91020 0 : std::cout << " not valid " << std::endl;
91021 : }
91022 : }
91023 :
91024 :
91025 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
91026 :
91027 0 : }
91028 :
91029 :
91030 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
91031 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
91032 : bool
91033 0 : SgConjugateOp::isInMemoryPool ()
91034 : {
91035 0 : typedef unsigned char* TestType;
91036 :
91037 0 : bool found = false;
91038 :
91039 0 : ROSE_ASSERT(this != NULL);
91040 :
91041 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
91042 :
91043 0 : TestType tested = (TestType) ( this ) ;
91044 :
91045 0 : std::vector < unsigned char* > :: const_iterator block = SgConjugateOp::pools.begin();
91046 :
91047 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
91048 : // while (found == false && block < Memory_Block_List.end())
91049 0 : while ( (found == false) && (block != SgConjugateOp::pools.end()) )
91050 : {
91051 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgConjugateOp::pool_size * sizeof(SgConjugateOp) ) ) ;
91052 0 : ++block;
91053 : }
91054 :
91055 : // Special handling for static data
91056 :
91057 :
91058 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
91059 0 : ROSE_ASSERT(found == true);
91060 :
91061 0 : return found;
91062 : }
91063 : /* #line 91064 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
91064 :
91065 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
91066 :
91067 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
91068 :
91069 : /* #line 91070 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
91070 :
91071 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
91072 :
91073 : void
91074 0 : SgUserDefinedUnaryOp::checkDataMemberPointersIfInMemoryPool()
91075 : {
91076 : // ------------ checking pointers of SgUserDefinedUnaryOp -------------------
91077 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
91078 :
91079 0 : if ( p_symbol != NULL )
91080 : {
91081 0 : if ( p_symbol->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91082 : {
91083 0 : if ( p_symbol->isInMemoryPool() == false )
91084 : {
91085 0 : std::cout << "SgUserDefinedUnaryOp :: ";
91086 0 : std::cout << " p_symbol is not in memory pool of ";
91087 0 : std::cout << p_symbol->class_name() << std::endl;
91088 : }
91089 : }
91090 : else
91091 : {
91092 0 : std::cout << "SgUserDefinedUnaryOp :: " << std::flush;
91093 0 : std::cout << "SgFunctionSymbol* p_symbol = " << p_symbol << " --> " << std::flush;
91094 0 : std::cout << " not valid " << std::endl;
91095 : }
91096 : }
91097 :
91098 0 : if ( p_operand_i != NULL )
91099 : {
91100 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91101 : {
91102 0 : if ( p_operand_i->isInMemoryPool() == false )
91103 : {
91104 0 : std::cout << "SgUserDefinedUnaryOp :: ";
91105 0 : std::cout << " p_operand_i is not in memory pool of ";
91106 0 : std::cout << p_operand_i->class_name() << std::endl;
91107 : }
91108 : }
91109 : else
91110 : {
91111 0 : std::cout << "SgUserDefinedUnaryOp :: " << std::flush;
91112 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
91113 0 : std::cout << " not valid " << std::endl;
91114 : }
91115 : }
91116 :
91117 0 : if ( p_expression_type != NULL )
91118 : {
91119 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91120 : {
91121 0 : if ( p_expression_type->isInMemoryPool() == false )
91122 : {
91123 0 : std::cout << "SgUserDefinedUnaryOp :: ";
91124 0 : std::cout << " p_expression_type is not in memory pool of ";
91125 0 : std::cout << p_expression_type->class_name() << std::endl;
91126 : }
91127 : }
91128 : else
91129 : {
91130 0 : std::cout << "SgUserDefinedUnaryOp :: " << std::flush;
91131 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
91132 0 : std::cout << " not valid " << std::endl;
91133 : }
91134 : }
91135 :
91136 0 : if ( p_operatorPosition != NULL )
91137 : {
91138 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91139 : {
91140 0 : if ( p_operatorPosition->isInMemoryPool() == false )
91141 : {
91142 0 : std::cout << "SgUserDefinedUnaryOp :: ";
91143 0 : std::cout << " p_operatorPosition is not in memory pool of ";
91144 0 : std::cout << p_operatorPosition->class_name() << std::endl;
91145 : }
91146 : }
91147 : else
91148 : {
91149 0 : std::cout << "SgUserDefinedUnaryOp :: " << std::flush;
91150 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
91151 0 : std::cout << " not valid " << std::endl;
91152 : }
91153 : }
91154 :
91155 0 : if ( p_startOfConstruct != NULL )
91156 : {
91157 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91158 : {
91159 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
91160 : {
91161 0 : std::cout << "SgUserDefinedUnaryOp :: ";
91162 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
91163 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
91164 : }
91165 : }
91166 : else
91167 : {
91168 0 : std::cout << "SgUserDefinedUnaryOp :: " << std::flush;
91169 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
91170 0 : std::cout << " not valid " << std::endl;
91171 : }
91172 : }
91173 :
91174 0 : if ( p_endOfConstruct != NULL )
91175 : {
91176 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91177 : {
91178 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
91179 : {
91180 0 : std::cout << "SgUserDefinedUnaryOp :: ";
91181 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
91182 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
91183 : }
91184 : }
91185 : else
91186 : {
91187 0 : std::cout << "SgUserDefinedUnaryOp :: " << std::flush;
91188 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
91189 0 : std::cout << " not valid " << std::endl;
91190 : }
91191 : }
91192 :
91193 0 : if ( p_parent != NULL )
91194 : {
91195 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91196 : {
91197 0 : if ( p_parent->isInMemoryPool() == false )
91198 : {
91199 0 : std::cout << "SgUserDefinedUnaryOp :: ";
91200 0 : std::cout << " p_parent is not in memory pool of ";
91201 0 : std::cout << p_parent->class_name() << std::endl;
91202 : }
91203 : }
91204 : else
91205 : {
91206 0 : std::cout << "SgUserDefinedUnaryOp :: " << std::flush;
91207 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
91208 0 : std::cout << " not valid " << std::endl;
91209 : }
91210 : }
91211 :
91212 :
91213 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
91214 :
91215 0 : }
91216 :
91217 :
91218 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
91219 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
91220 : bool
91221 0 : SgUserDefinedUnaryOp::isInMemoryPool ()
91222 : {
91223 0 : typedef unsigned char* TestType;
91224 :
91225 0 : bool found = false;
91226 :
91227 0 : ROSE_ASSERT(this != NULL);
91228 :
91229 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
91230 :
91231 0 : TestType tested = (TestType) ( this ) ;
91232 :
91233 0 : std::vector < unsigned char* > :: const_iterator block = SgUserDefinedUnaryOp::pools.begin();
91234 :
91235 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
91236 : // while (found == false && block < Memory_Block_List.end())
91237 0 : while ( (found == false) && (block != SgUserDefinedUnaryOp::pools.end()) )
91238 : {
91239 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUserDefinedUnaryOp::pool_size * sizeof(SgUserDefinedUnaryOp) ) ) ;
91240 0 : ++block;
91241 : }
91242 :
91243 : // Special handling for static data
91244 :
91245 :
91246 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
91247 0 : ROSE_ASSERT(found == true);
91248 :
91249 0 : return found;
91250 : }
91251 : /* #line 91252 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
91252 :
91253 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
91254 :
91255 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
91256 :
91257 : /* #line 91258 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
91258 :
91259 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
91260 :
91261 : void
91262 0 : SgMatrixTransposeOp::checkDataMemberPointersIfInMemoryPool()
91263 : {
91264 : // ------------ checking pointers of SgMatrixTransposeOp -------------------
91265 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
91266 :
91267 0 : if ( p_operand_i != NULL )
91268 : {
91269 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91270 : {
91271 0 : if ( p_operand_i->isInMemoryPool() == false )
91272 : {
91273 0 : std::cout << "SgMatrixTransposeOp :: ";
91274 0 : std::cout << " p_operand_i is not in memory pool of ";
91275 0 : std::cout << p_operand_i->class_name() << std::endl;
91276 : }
91277 : }
91278 : else
91279 : {
91280 0 : std::cout << "SgMatrixTransposeOp :: " << std::flush;
91281 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
91282 0 : std::cout << " not valid " << std::endl;
91283 : }
91284 : }
91285 :
91286 0 : if ( p_expression_type != NULL )
91287 : {
91288 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91289 : {
91290 0 : if ( p_expression_type->isInMemoryPool() == false )
91291 : {
91292 0 : std::cout << "SgMatrixTransposeOp :: ";
91293 0 : std::cout << " p_expression_type is not in memory pool of ";
91294 0 : std::cout << p_expression_type->class_name() << std::endl;
91295 : }
91296 : }
91297 : else
91298 : {
91299 0 : std::cout << "SgMatrixTransposeOp :: " << std::flush;
91300 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
91301 0 : std::cout << " not valid " << std::endl;
91302 : }
91303 : }
91304 :
91305 0 : if ( p_operatorPosition != NULL )
91306 : {
91307 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91308 : {
91309 0 : if ( p_operatorPosition->isInMemoryPool() == false )
91310 : {
91311 0 : std::cout << "SgMatrixTransposeOp :: ";
91312 0 : std::cout << " p_operatorPosition is not in memory pool of ";
91313 0 : std::cout << p_operatorPosition->class_name() << std::endl;
91314 : }
91315 : }
91316 : else
91317 : {
91318 0 : std::cout << "SgMatrixTransposeOp :: " << std::flush;
91319 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
91320 0 : std::cout << " not valid " << std::endl;
91321 : }
91322 : }
91323 :
91324 0 : if ( p_startOfConstruct != NULL )
91325 : {
91326 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91327 : {
91328 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
91329 : {
91330 0 : std::cout << "SgMatrixTransposeOp :: ";
91331 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
91332 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
91333 : }
91334 : }
91335 : else
91336 : {
91337 0 : std::cout << "SgMatrixTransposeOp :: " << std::flush;
91338 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
91339 0 : std::cout << " not valid " << std::endl;
91340 : }
91341 : }
91342 :
91343 0 : if ( p_endOfConstruct != NULL )
91344 : {
91345 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91346 : {
91347 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
91348 : {
91349 0 : std::cout << "SgMatrixTransposeOp :: ";
91350 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
91351 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
91352 : }
91353 : }
91354 : else
91355 : {
91356 0 : std::cout << "SgMatrixTransposeOp :: " << std::flush;
91357 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
91358 0 : std::cout << " not valid " << std::endl;
91359 : }
91360 : }
91361 :
91362 0 : if ( p_parent != NULL )
91363 : {
91364 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91365 : {
91366 0 : if ( p_parent->isInMemoryPool() == false )
91367 : {
91368 0 : std::cout << "SgMatrixTransposeOp :: ";
91369 0 : std::cout << " p_parent is not in memory pool of ";
91370 0 : std::cout << p_parent->class_name() << std::endl;
91371 : }
91372 : }
91373 : else
91374 : {
91375 0 : std::cout << "SgMatrixTransposeOp :: " << std::flush;
91376 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
91377 0 : std::cout << " not valid " << std::endl;
91378 : }
91379 : }
91380 :
91381 :
91382 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
91383 :
91384 0 : }
91385 :
91386 :
91387 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
91388 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
91389 : bool
91390 0 : SgMatrixTransposeOp::isInMemoryPool ()
91391 : {
91392 0 : typedef unsigned char* TestType;
91393 :
91394 0 : bool found = false;
91395 :
91396 0 : ROSE_ASSERT(this != NULL);
91397 :
91398 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
91399 :
91400 0 : TestType tested = (TestType) ( this ) ;
91401 :
91402 0 : std::vector < unsigned char* > :: const_iterator block = SgMatrixTransposeOp::pools.begin();
91403 :
91404 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
91405 : // while (found == false && block < Memory_Block_List.end())
91406 0 : while ( (found == false) && (block != SgMatrixTransposeOp::pools.end()) )
91407 : {
91408 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgMatrixTransposeOp::pool_size * sizeof(SgMatrixTransposeOp) ) ) ;
91409 0 : ++block;
91410 : }
91411 :
91412 : // Special handling for static data
91413 :
91414 :
91415 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
91416 0 : ROSE_ASSERT(found == true);
91417 :
91418 0 : return found;
91419 : }
91420 : /* #line 91421 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
91421 :
91422 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
91423 :
91424 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
91425 :
91426 : /* #line 91427 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
91427 :
91428 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
91429 :
91430 : void
91431 0 : SgBinaryOp::checkDataMemberPointersIfInMemoryPool()
91432 : {
91433 : // ------------ checking pointers of SgBinaryOp -------------------
91434 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
91435 :
91436 0 : if ( p_lhs_operand_i != NULL )
91437 : {
91438 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91439 : {
91440 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
91441 : {
91442 0 : std::cout << "SgBinaryOp :: ";
91443 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
91444 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
91445 : }
91446 : }
91447 : else
91448 : {
91449 0 : std::cout << "SgBinaryOp :: " << std::flush;
91450 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
91451 0 : std::cout << " not valid " << std::endl;
91452 : }
91453 : }
91454 :
91455 0 : if ( p_rhs_operand_i != NULL )
91456 : {
91457 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91458 : {
91459 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
91460 : {
91461 0 : std::cout << "SgBinaryOp :: ";
91462 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
91463 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
91464 : }
91465 : }
91466 : else
91467 : {
91468 0 : std::cout << "SgBinaryOp :: " << std::flush;
91469 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
91470 0 : std::cout << " not valid " << std::endl;
91471 : }
91472 : }
91473 :
91474 0 : if ( p_expression_type != NULL )
91475 : {
91476 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91477 : {
91478 0 : if ( p_expression_type->isInMemoryPool() == false )
91479 : {
91480 0 : std::cout << "SgBinaryOp :: ";
91481 0 : std::cout << " p_expression_type is not in memory pool of ";
91482 0 : std::cout << p_expression_type->class_name() << std::endl;
91483 : }
91484 : }
91485 : else
91486 : {
91487 0 : std::cout << "SgBinaryOp :: " << std::flush;
91488 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
91489 0 : std::cout << " not valid " << std::endl;
91490 : }
91491 : }
91492 :
91493 0 : if ( p_originalExpressionTree != NULL )
91494 : {
91495 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91496 : {
91497 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
91498 : {
91499 0 : std::cout << "SgBinaryOp :: ";
91500 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
91501 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
91502 : }
91503 : }
91504 : else
91505 : {
91506 0 : std::cout << "SgBinaryOp :: " << std::flush;
91507 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
91508 0 : std::cout << " not valid " << std::endl;
91509 : }
91510 : }
91511 :
91512 0 : if ( p_operatorPosition != NULL )
91513 : {
91514 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91515 : {
91516 0 : if ( p_operatorPosition->isInMemoryPool() == false )
91517 : {
91518 0 : std::cout << "SgBinaryOp :: ";
91519 0 : std::cout << " p_operatorPosition is not in memory pool of ";
91520 0 : std::cout << p_operatorPosition->class_name() << std::endl;
91521 : }
91522 : }
91523 : else
91524 : {
91525 0 : std::cout << "SgBinaryOp :: " << std::flush;
91526 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
91527 0 : std::cout << " not valid " << std::endl;
91528 : }
91529 : }
91530 :
91531 0 : if ( p_startOfConstruct != NULL )
91532 : {
91533 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91534 : {
91535 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
91536 : {
91537 0 : std::cout << "SgBinaryOp :: ";
91538 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
91539 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
91540 : }
91541 : }
91542 : else
91543 : {
91544 0 : std::cout << "SgBinaryOp :: " << std::flush;
91545 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
91546 0 : std::cout << " not valid " << std::endl;
91547 : }
91548 : }
91549 :
91550 0 : if ( p_endOfConstruct != NULL )
91551 : {
91552 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91553 : {
91554 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
91555 : {
91556 0 : std::cout << "SgBinaryOp :: ";
91557 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
91558 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
91559 : }
91560 : }
91561 : else
91562 : {
91563 0 : std::cout << "SgBinaryOp :: " << std::flush;
91564 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
91565 0 : std::cout << " not valid " << std::endl;
91566 : }
91567 : }
91568 :
91569 0 : if ( p_parent != NULL )
91570 : {
91571 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91572 : {
91573 0 : if ( p_parent->isInMemoryPool() == false )
91574 : {
91575 0 : std::cout << "SgBinaryOp :: ";
91576 0 : std::cout << " p_parent is not in memory pool of ";
91577 0 : std::cout << p_parent->class_name() << std::endl;
91578 : }
91579 : }
91580 : else
91581 : {
91582 0 : std::cout << "SgBinaryOp :: " << std::flush;
91583 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
91584 0 : std::cout << " not valid " << std::endl;
91585 : }
91586 : }
91587 :
91588 :
91589 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
91590 :
91591 0 : }
91592 :
91593 :
91594 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
91595 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
91596 : bool
91597 0 : SgBinaryOp::isInMemoryPool ()
91598 : {
91599 0 : typedef unsigned char* TestType;
91600 :
91601 0 : bool found = false;
91602 :
91603 0 : ROSE_ASSERT(this != NULL);
91604 :
91605 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
91606 :
91607 0 : TestType tested = (TestType) ( this ) ;
91608 :
91609 0 : std::vector < unsigned char* > :: const_iterator block = SgBinaryOp::pools.begin();
91610 :
91611 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
91612 : // while (found == false && block < Memory_Block_List.end())
91613 0 : while ( (found == false) && (block != SgBinaryOp::pools.end()) )
91614 : {
91615 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgBinaryOp::pool_size * sizeof(SgBinaryOp) ) ) ;
91616 0 : ++block;
91617 : }
91618 :
91619 : // Special handling for static data
91620 :
91621 :
91622 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
91623 0 : ROSE_ASSERT(found == true);
91624 :
91625 0 : return found;
91626 : }
91627 : /* #line 91628 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
91628 :
91629 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
91630 :
91631 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
91632 :
91633 : /* #line 91634 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
91634 :
91635 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
91636 :
91637 : void
91638 0 : SgArrowExp::checkDataMemberPointersIfInMemoryPool()
91639 : {
91640 : // ------------ checking pointers of SgArrowExp -------------------
91641 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
91642 :
91643 0 : if ( p_lhs_operand_i != NULL )
91644 : {
91645 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91646 : {
91647 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
91648 : {
91649 0 : std::cout << "SgArrowExp :: ";
91650 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
91651 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
91652 : }
91653 : }
91654 : else
91655 : {
91656 0 : std::cout << "SgArrowExp :: " << std::flush;
91657 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
91658 0 : std::cout << " not valid " << std::endl;
91659 : }
91660 : }
91661 :
91662 0 : if ( p_rhs_operand_i != NULL )
91663 : {
91664 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91665 : {
91666 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
91667 : {
91668 0 : std::cout << "SgArrowExp :: ";
91669 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
91670 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
91671 : }
91672 : }
91673 : else
91674 : {
91675 0 : std::cout << "SgArrowExp :: " << std::flush;
91676 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
91677 0 : std::cout << " not valid " << std::endl;
91678 : }
91679 : }
91680 :
91681 0 : if ( p_expression_type != NULL )
91682 : {
91683 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91684 : {
91685 0 : if ( p_expression_type->isInMemoryPool() == false )
91686 : {
91687 0 : std::cout << "SgArrowExp :: ";
91688 0 : std::cout << " p_expression_type is not in memory pool of ";
91689 0 : std::cout << p_expression_type->class_name() << std::endl;
91690 : }
91691 : }
91692 : else
91693 : {
91694 0 : std::cout << "SgArrowExp :: " << std::flush;
91695 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
91696 0 : std::cout << " not valid " << std::endl;
91697 : }
91698 : }
91699 :
91700 0 : if ( p_originalExpressionTree != NULL )
91701 : {
91702 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91703 : {
91704 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
91705 : {
91706 0 : std::cout << "SgArrowExp :: ";
91707 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
91708 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
91709 : }
91710 : }
91711 : else
91712 : {
91713 0 : std::cout << "SgArrowExp :: " << std::flush;
91714 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
91715 0 : std::cout << " not valid " << std::endl;
91716 : }
91717 : }
91718 :
91719 0 : if ( p_operatorPosition != NULL )
91720 : {
91721 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91722 : {
91723 0 : if ( p_operatorPosition->isInMemoryPool() == false )
91724 : {
91725 0 : std::cout << "SgArrowExp :: ";
91726 0 : std::cout << " p_operatorPosition is not in memory pool of ";
91727 0 : std::cout << p_operatorPosition->class_name() << std::endl;
91728 : }
91729 : }
91730 : else
91731 : {
91732 0 : std::cout << "SgArrowExp :: " << std::flush;
91733 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
91734 0 : std::cout << " not valid " << std::endl;
91735 : }
91736 : }
91737 :
91738 0 : if ( p_startOfConstruct != NULL )
91739 : {
91740 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91741 : {
91742 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
91743 : {
91744 0 : std::cout << "SgArrowExp :: ";
91745 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
91746 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
91747 : }
91748 : }
91749 : else
91750 : {
91751 0 : std::cout << "SgArrowExp :: " << std::flush;
91752 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
91753 0 : std::cout << " not valid " << std::endl;
91754 : }
91755 : }
91756 :
91757 0 : if ( p_endOfConstruct != NULL )
91758 : {
91759 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91760 : {
91761 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
91762 : {
91763 0 : std::cout << "SgArrowExp :: ";
91764 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
91765 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
91766 : }
91767 : }
91768 : else
91769 : {
91770 0 : std::cout << "SgArrowExp :: " << std::flush;
91771 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
91772 0 : std::cout << " not valid " << std::endl;
91773 : }
91774 : }
91775 :
91776 0 : if ( p_parent != NULL )
91777 : {
91778 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91779 : {
91780 0 : if ( p_parent->isInMemoryPool() == false )
91781 : {
91782 0 : std::cout << "SgArrowExp :: ";
91783 0 : std::cout << " p_parent is not in memory pool of ";
91784 0 : std::cout << p_parent->class_name() << std::endl;
91785 : }
91786 : }
91787 : else
91788 : {
91789 0 : std::cout << "SgArrowExp :: " << std::flush;
91790 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
91791 0 : std::cout << " not valid " << std::endl;
91792 : }
91793 : }
91794 :
91795 :
91796 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
91797 :
91798 0 : }
91799 :
91800 :
91801 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
91802 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
91803 : bool
91804 0 : SgArrowExp::isInMemoryPool ()
91805 : {
91806 0 : typedef unsigned char* TestType;
91807 :
91808 0 : bool found = false;
91809 :
91810 0 : ROSE_ASSERT(this != NULL);
91811 :
91812 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
91813 :
91814 0 : TestType tested = (TestType) ( this ) ;
91815 :
91816 0 : std::vector < unsigned char* > :: const_iterator block = SgArrowExp::pools.begin();
91817 :
91818 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
91819 : // while (found == false && block < Memory_Block_List.end())
91820 0 : while ( (found == false) && (block != SgArrowExp::pools.end()) )
91821 : {
91822 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgArrowExp::pool_size * sizeof(SgArrowExp) ) ) ;
91823 0 : ++block;
91824 : }
91825 :
91826 : // Special handling for static data
91827 :
91828 :
91829 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
91830 0 : ROSE_ASSERT(found == true);
91831 :
91832 0 : return found;
91833 : }
91834 : /* #line 91835 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
91835 :
91836 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
91837 :
91838 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
91839 :
91840 : /* #line 91841 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
91841 :
91842 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
91843 :
91844 : void
91845 0 : SgDotExp::checkDataMemberPointersIfInMemoryPool()
91846 : {
91847 : // ------------ checking pointers of SgDotExp -------------------
91848 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
91849 :
91850 0 : if ( p_lhs_operand_i != NULL )
91851 : {
91852 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91853 : {
91854 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
91855 : {
91856 0 : std::cout << "SgDotExp :: ";
91857 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
91858 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
91859 : }
91860 : }
91861 : else
91862 : {
91863 0 : std::cout << "SgDotExp :: " << std::flush;
91864 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
91865 0 : std::cout << " not valid " << std::endl;
91866 : }
91867 : }
91868 :
91869 0 : if ( p_rhs_operand_i != NULL )
91870 : {
91871 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91872 : {
91873 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
91874 : {
91875 0 : std::cout << "SgDotExp :: ";
91876 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
91877 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
91878 : }
91879 : }
91880 : else
91881 : {
91882 0 : std::cout << "SgDotExp :: " << std::flush;
91883 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
91884 0 : std::cout << " not valid " << std::endl;
91885 : }
91886 : }
91887 :
91888 0 : if ( p_expression_type != NULL )
91889 : {
91890 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91891 : {
91892 0 : if ( p_expression_type->isInMemoryPool() == false )
91893 : {
91894 0 : std::cout << "SgDotExp :: ";
91895 0 : std::cout << " p_expression_type is not in memory pool of ";
91896 0 : std::cout << p_expression_type->class_name() << std::endl;
91897 : }
91898 : }
91899 : else
91900 : {
91901 0 : std::cout << "SgDotExp :: " << std::flush;
91902 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
91903 0 : std::cout << " not valid " << std::endl;
91904 : }
91905 : }
91906 :
91907 0 : if ( p_originalExpressionTree != NULL )
91908 : {
91909 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91910 : {
91911 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
91912 : {
91913 0 : std::cout << "SgDotExp :: ";
91914 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
91915 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
91916 : }
91917 : }
91918 : else
91919 : {
91920 0 : std::cout << "SgDotExp :: " << std::flush;
91921 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
91922 0 : std::cout << " not valid " << std::endl;
91923 : }
91924 : }
91925 :
91926 0 : if ( p_operatorPosition != NULL )
91927 : {
91928 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91929 : {
91930 0 : if ( p_operatorPosition->isInMemoryPool() == false )
91931 : {
91932 0 : std::cout << "SgDotExp :: ";
91933 0 : std::cout << " p_operatorPosition is not in memory pool of ";
91934 0 : std::cout << p_operatorPosition->class_name() << std::endl;
91935 : }
91936 : }
91937 : else
91938 : {
91939 0 : std::cout << "SgDotExp :: " << std::flush;
91940 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
91941 0 : std::cout << " not valid " << std::endl;
91942 : }
91943 : }
91944 :
91945 0 : if ( p_startOfConstruct != NULL )
91946 : {
91947 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91948 : {
91949 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
91950 : {
91951 0 : std::cout << "SgDotExp :: ";
91952 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
91953 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
91954 : }
91955 : }
91956 : else
91957 : {
91958 0 : std::cout << "SgDotExp :: " << std::flush;
91959 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
91960 0 : std::cout << " not valid " << std::endl;
91961 : }
91962 : }
91963 :
91964 0 : if ( p_endOfConstruct != NULL )
91965 : {
91966 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91967 : {
91968 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
91969 : {
91970 0 : std::cout << "SgDotExp :: ";
91971 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
91972 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
91973 : }
91974 : }
91975 : else
91976 : {
91977 0 : std::cout << "SgDotExp :: " << std::flush;
91978 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
91979 0 : std::cout << " not valid " << std::endl;
91980 : }
91981 : }
91982 :
91983 0 : if ( p_parent != NULL )
91984 : {
91985 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
91986 : {
91987 0 : if ( p_parent->isInMemoryPool() == false )
91988 : {
91989 0 : std::cout << "SgDotExp :: ";
91990 0 : std::cout << " p_parent is not in memory pool of ";
91991 0 : std::cout << p_parent->class_name() << std::endl;
91992 : }
91993 : }
91994 : else
91995 : {
91996 0 : std::cout << "SgDotExp :: " << std::flush;
91997 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
91998 0 : std::cout << " not valid " << std::endl;
91999 : }
92000 : }
92001 :
92002 :
92003 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
92004 :
92005 0 : }
92006 :
92007 :
92008 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
92009 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
92010 : bool
92011 0 : SgDotExp::isInMemoryPool ()
92012 : {
92013 0 : typedef unsigned char* TestType;
92014 :
92015 0 : bool found = false;
92016 :
92017 0 : ROSE_ASSERT(this != NULL);
92018 :
92019 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
92020 :
92021 0 : TestType tested = (TestType) ( this ) ;
92022 :
92023 0 : std::vector < unsigned char* > :: const_iterator block = SgDotExp::pools.begin();
92024 :
92025 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
92026 : // while (found == false && block < Memory_Block_List.end())
92027 0 : while ( (found == false) && (block != SgDotExp::pools.end()) )
92028 : {
92029 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDotExp::pool_size * sizeof(SgDotExp) ) ) ;
92030 0 : ++block;
92031 : }
92032 :
92033 : // Special handling for static data
92034 :
92035 :
92036 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
92037 0 : ROSE_ASSERT(found == true);
92038 :
92039 0 : return found;
92040 : }
92041 : /* #line 92042 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
92042 :
92043 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
92044 :
92045 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
92046 :
92047 : /* #line 92048 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
92048 :
92049 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
92050 :
92051 : void
92052 0 : SgDotStarOp::checkDataMemberPointersIfInMemoryPool()
92053 : {
92054 : // ------------ checking pointers of SgDotStarOp -------------------
92055 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
92056 :
92057 0 : if ( p_lhs_operand_i != NULL )
92058 : {
92059 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92060 : {
92061 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
92062 : {
92063 0 : std::cout << "SgDotStarOp :: ";
92064 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
92065 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
92066 : }
92067 : }
92068 : else
92069 : {
92070 0 : std::cout << "SgDotStarOp :: " << std::flush;
92071 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
92072 0 : std::cout << " not valid " << std::endl;
92073 : }
92074 : }
92075 :
92076 0 : if ( p_rhs_operand_i != NULL )
92077 : {
92078 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92079 : {
92080 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
92081 : {
92082 0 : std::cout << "SgDotStarOp :: ";
92083 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
92084 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
92085 : }
92086 : }
92087 : else
92088 : {
92089 0 : std::cout << "SgDotStarOp :: " << std::flush;
92090 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
92091 0 : std::cout << " not valid " << std::endl;
92092 : }
92093 : }
92094 :
92095 0 : if ( p_expression_type != NULL )
92096 : {
92097 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92098 : {
92099 0 : if ( p_expression_type->isInMemoryPool() == false )
92100 : {
92101 0 : std::cout << "SgDotStarOp :: ";
92102 0 : std::cout << " p_expression_type is not in memory pool of ";
92103 0 : std::cout << p_expression_type->class_name() << std::endl;
92104 : }
92105 : }
92106 : else
92107 : {
92108 0 : std::cout << "SgDotStarOp :: " << std::flush;
92109 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
92110 0 : std::cout << " not valid " << std::endl;
92111 : }
92112 : }
92113 :
92114 0 : if ( p_originalExpressionTree != NULL )
92115 : {
92116 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92117 : {
92118 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
92119 : {
92120 0 : std::cout << "SgDotStarOp :: ";
92121 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
92122 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
92123 : }
92124 : }
92125 : else
92126 : {
92127 0 : std::cout << "SgDotStarOp :: " << std::flush;
92128 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
92129 0 : std::cout << " not valid " << std::endl;
92130 : }
92131 : }
92132 :
92133 0 : if ( p_operatorPosition != NULL )
92134 : {
92135 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92136 : {
92137 0 : if ( p_operatorPosition->isInMemoryPool() == false )
92138 : {
92139 0 : std::cout << "SgDotStarOp :: ";
92140 0 : std::cout << " p_operatorPosition is not in memory pool of ";
92141 0 : std::cout << p_operatorPosition->class_name() << std::endl;
92142 : }
92143 : }
92144 : else
92145 : {
92146 0 : std::cout << "SgDotStarOp :: " << std::flush;
92147 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
92148 0 : std::cout << " not valid " << std::endl;
92149 : }
92150 : }
92151 :
92152 0 : if ( p_startOfConstruct != NULL )
92153 : {
92154 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92155 : {
92156 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
92157 : {
92158 0 : std::cout << "SgDotStarOp :: ";
92159 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
92160 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
92161 : }
92162 : }
92163 : else
92164 : {
92165 0 : std::cout << "SgDotStarOp :: " << std::flush;
92166 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
92167 0 : std::cout << " not valid " << std::endl;
92168 : }
92169 : }
92170 :
92171 0 : if ( p_endOfConstruct != NULL )
92172 : {
92173 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92174 : {
92175 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
92176 : {
92177 0 : std::cout << "SgDotStarOp :: ";
92178 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
92179 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
92180 : }
92181 : }
92182 : else
92183 : {
92184 0 : std::cout << "SgDotStarOp :: " << std::flush;
92185 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
92186 0 : std::cout << " not valid " << std::endl;
92187 : }
92188 : }
92189 :
92190 0 : if ( p_parent != NULL )
92191 : {
92192 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92193 : {
92194 0 : if ( p_parent->isInMemoryPool() == false )
92195 : {
92196 0 : std::cout << "SgDotStarOp :: ";
92197 0 : std::cout << " p_parent is not in memory pool of ";
92198 0 : std::cout << p_parent->class_name() << std::endl;
92199 : }
92200 : }
92201 : else
92202 : {
92203 0 : std::cout << "SgDotStarOp :: " << std::flush;
92204 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
92205 0 : std::cout << " not valid " << std::endl;
92206 : }
92207 : }
92208 :
92209 :
92210 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
92211 :
92212 0 : }
92213 :
92214 :
92215 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
92216 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
92217 : bool
92218 0 : SgDotStarOp::isInMemoryPool ()
92219 : {
92220 0 : typedef unsigned char* TestType;
92221 :
92222 0 : bool found = false;
92223 :
92224 0 : ROSE_ASSERT(this != NULL);
92225 :
92226 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
92227 :
92228 0 : TestType tested = (TestType) ( this ) ;
92229 :
92230 0 : std::vector < unsigned char* > :: const_iterator block = SgDotStarOp::pools.begin();
92231 :
92232 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
92233 : // while (found == false && block < Memory_Block_List.end())
92234 0 : while ( (found == false) && (block != SgDotStarOp::pools.end()) )
92235 : {
92236 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDotStarOp::pool_size * sizeof(SgDotStarOp) ) ) ;
92237 0 : ++block;
92238 : }
92239 :
92240 : // Special handling for static data
92241 :
92242 :
92243 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
92244 0 : ROSE_ASSERT(found == true);
92245 :
92246 0 : return found;
92247 : }
92248 : /* #line 92249 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
92249 :
92250 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
92251 :
92252 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
92253 :
92254 : /* #line 92255 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
92255 :
92256 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
92257 :
92258 : void
92259 0 : SgArrowStarOp::checkDataMemberPointersIfInMemoryPool()
92260 : {
92261 : // ------------ checking pointers of SgArrowStarOp -------------------
92262 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
92263 :
92264 0 : if ( p_lhs_operand_i != NULL )
92265 : {
92266 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92267 : {
92268 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
92269 : {
92270 0 : std::cout << "SgArrowStarOp :: ";
92271 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
92272 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
92273 : }
92274 : }
92275 : else
92276 : {
92277 0 : std::cout << "SgArrowStarOp :: " << std::flush;
92278 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
92279 0 : std::cout << " not valid " << std::endl;
92280 : }
92281 : }
92282 :
92283 0 : if ( p_rhs_operand_i != NULL )
92284 : {
92285 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92286 : {
92287 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
92288 : {
92289 0 : std::cout << "SgArrowStarOp :: ";
92290 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
92291 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
92292 : }
92293 : }
92294 : else
92295 : {
92296 0 : std::cout << "SgArrowStarOp :: " << std::flush;
92297 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
92298 0 : std::cout << " not valid " << std::endl;
92299 : }
92300 : }
92301 :
92302 0 : if ( p_expression_type != NULL )
92303 : {
92304 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92305 : {
92306 0 : if ( p_expression_type->isInMemoryPool() == false )
92307 : {
92308 0 : std::cout << "SgArrowStarOp :: ";
92309 0 : std::cout << " p_expression_type is not in memory pool of ";
92310 0 : std::cout << p_expression_type->class_name() << std::endl;
92311 : }
92312 : }
92313 : else
92314 : {
92315 0 : std::cout << "SgArrowStarOp :: " << std::flush;
92316 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
92317 0 : std::cout << " not valid " << std::endl;
92318 : }
92319 : }
92320 :
92321 0 : if ( p_originalExpressionTree != NULL )
92322 : {
92323 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92324 : {
92325 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
92326 : {
92327 0 : std::cout << "SgArrowStarOp :: ";
92328 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
92329 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
92330 : }
92331 : }
92332 : else
92333 : {
92334 0 : std::cout << "SgArrowStarOp :: " << std::flush;
92335 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
92336 0 : std::cout << " not valid " << std::endl;
92337 : }
92338 : }
92339 :
92340 0 : if ( p_operatorPosition != NULL )
92341 : {
92342 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92343 : {
92344 0 : if ( p_operatorPosition->isInMemoryPool() == false )
92345 : {
92346 0 : std::cout << "SgArrowStarOp :: ";
92347 0 : std::cout << " p_operatorPosition is not in memory pool of ";
92348 0 : std::cout << p_operatorPosition->class_name() << std::endl;
92349 : }
92350 : }
92351 : else
92352 : {
92353 0 : std::cout << "SgArrowStarOp :: " << std::flush;
92354 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
92355 0 : std::cout << " not valid " << std::endl;
92356 : }
92357 : }
92358 :
92359 0 : if ( p_startOfConstruct != NULL )
92360 : {
92361 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92362 : {
92363 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
92364 : {
92365 0 : std::cout << "SgArrowStarOp :: ";
92366 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
92367 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
92368 : }
92369 : }
92370 : else
92371 : {
92372 0 : std::cout << "SgArrowStarOp :: " << std::flush;
92373 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
92374 0 : std::cout << " not valid " << std::endl;
92375 : }
92376 : }
92377 :
92378 0 : if ( p_endOfConstruct != NULL )
92379 : {
92380 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92381 : {
92382 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
92383 : {
92384 0 : std::cout << "SgArrowStarOp :: ";
92385 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
92386 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
92387 : }
92388 : }
92389 : else
92390 : {
92391 0 : std::cout << "SgArrowStarOp :: " << std::flush;
92392 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
92393 0 : std::cout << " not valid " << std::endl;
92394 : }
92395 : }
92396 :
92397 0 : if ( p_parent != NULL )
92398 : {
92399 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92400 : {
92401 0 : if ( p_parent->isInMemoryPool() == false )
92402 : {
92403 0 : std::cout << "SgArrowStarOp :: ";
92404 0 : std::cout << " p_parent is not in memory pool of ";
92405 0 : std::cout << p_parent->class_name() << std::endl;
92406 : }
92407 : }
92408 : else
92409 : {
92410 0 : std::cout << "SgArrowStarOp :: " << std::flush;
92411 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
92412 0 : std::cout << " not valid " << std::endl;
92413 : }
92414 : }
92415 :
92416 :
92417 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
92418 :
92419 0 : }
92420 :
92421 :
92422 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
92423 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
92424 : bool
92425 0 : SgArrowStarOp::isInMemoryPool ()
92426 : {
92427 0 : typedef unsigned char* TestType;
92428 :
92429 0 : bool found = false;
92430 :
92431 0 : ROSE_ASSERT(this != NULL);
92432 :
92433 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
92434 :
92435 0 : TestType tested = (TestType) ( this ) ;
92436 :
92437 0 : std::vector < unsigned char* > :: const_iterator block = SgArrowStarOp::pools.begin();
92438 :
92439 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
92440 : // while (found == false && block < Memory_Block_List.end())
92441 0 : while ( (found == false) && (block != SgArrowStarOp::pools.end()) )
92442 : {
92443 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgArrowStarOp::pool_size * sizeof(SgArrowStarOp) ) ) ;
92444 0 : ++block;
92445 : }
92446 :
92447 : // Special handling for static data
92448 :
92449 :
92450 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
92451 0 : ROSE_ASSERT(found == true);
92452 :
92453 0 : return found;
92454 : }
92455 : /* #line 92456 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
92456 :
92457 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
92458 :
92459 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
92460 :
92461 : /* #line 92462 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
92462 :
92463 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
92464 :
92465 : void
92466 0 : SgEqualityOp::checkDataMemberPointersIfInMemoryPool()
92467 : {
92468 : // ------------ checking pointers of SgEqualityOp -------------------
92469 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
92470 :
92471 0 : if ( p_lhs_operand_i != NULL )
92472 : {
92473 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92474 : {
92475 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
92476 : {
92477 0 : std::cout << "SgEqualityOp :: ";
92478 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
92479 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
92480 : }
92481 : }
92482 : else
92483 : {
92484 0 : std::cout << "SgEqualityOp :: " << std::flush;
92485 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
92486 0 : std::cout << " not valid " << std::endl;
92487 : }
92488 : }
92489 :
92490 0 : if ( p_rhs_operand_i != NULL )
92491 : {
92492 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92493 : {
92494 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
92495 : {
92496 0 : std::cout << "SgEqualityOp :: ";
92497 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
92498 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
92499 : }
92500 : }
92501 : else
92502 : {
92503 0 : std::cout << "SgEqualityOp :: " << std::flush;
92504 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
92505 0 : std::cout << " not valid " << std::endl;
92506 : }
92507 : }
92508 :
92509 0 : if ( p_expression_type != NULL )
92510 : {
92511 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92512 : {
92513 0 : if ( p_expression_type->isInMemoryPool() == false )
92514 : {
92515 0 : std::cout << "SgEqualityOp :: ";
92516 0 : std::cout << " p_expression_type is not in memory pool of ";
92517 0 : std::cout << p_expression_type->class_name() << std::endl;
92518 : }
92519 : }
92520 : else
92521 : {
92522 0 : std::cout << "SgEqualityOp :: " << std::flush;
92523 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
92524 0 : std::cout << " not valid " << std::endl;
92525 : }
92526 : }
92527 :
92528 0 : if ( p_originalExpressionTree != NULL )
92529 : {
92530 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92531 : {
92532 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
92533 : {
92534 0 : std::cout << "SgEqualityOp :: ";
92535 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
92536 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
92537 : }
92538 : }
92539 : else
92540 : {
92541 0 : std::cout << "SgEqualityOp :: " << std::flush;
92542 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
92543 0 : std::cout << " not valid " << std::endl;
92544 : }
92545 : }
92546 :
92547 0 : if ( p_operatorPosition != NULL )
92548 : {
92549 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92550 : {
92551 0 : if ( p_operatorPosition->isInMemoryPool() == false )
92552 : {
92553 0 : std::cout << "SgEqualityOp :: ";
92554 0 : std::cout << " p_operatorPosition is not in memory pool of ";
92555 0 : std::cout << p_operatorPosition->class_name() << std::endl;
92556 : }
92557 : }
92558 : else
92559 : {
92560 0 : std::cout << "SgEqualityOp :: " << std::flush;
92561 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
92562 0 : std::cout << " not valid " << std::endl;
92563 : }
92564 : }
92565 :
92566 0 : if ( p_startOfConstruct != NULL )
92567 : {
92568 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92569 : {
92570 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
92571 : {
92572 0 : std::cout << "SgEqualityOp :: ";
92573 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
92574 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
92575 : }
92576 : }
92577 : else
92578 : {
92579 0 : std::cout << "SgEqualityOp :: " << std::flush;
92580 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
92581 0 : std::cout << " not valid " << std::endl;
92582 : }
92583 : }
92584 :
92585 0 : if ( p_endOfConstruct != NULL )
92586 : {
92587 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92588 : {
92589 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
92590 : {
92591 0 : std::cout << "SgEqualityOp :: ";
92592 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
92593 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
92594 : }
92595 : }
92596 : else
92597 : {
92598 0 : std::cout << "SgEqualityOp :: " << std::flush;
92599 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
92600 0 : std::cout << " not valid " << std::endl;
92601 : }
92602 : }
92603 :
92604 0 : if ( p_parent != NULL )
92605 : {
92606 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92607 : {
92608 0 : if ( p_parent->isInMemoryPool() == false )
92609 : {
92610 0 : std::cout << "SgEqualityOp :: ";
92611 0 : std::cout << " p_parent is not in memory pool of ";
92612 0 : std::cout << p_parent->class_name() << std::endl;
92613 : }
92614 : }
92615 : else
92616 : {
92617 0 : std::cout << "SgEqualityOp :: " << std::flush;
92618 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
92619 0 : std::cout << " not valid " << std::endl;
92620 : }
92621 : }
92622 :
92623 :
92624 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
92625 :
92626 0 : }
92627 :
92628 :
92629 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
92630 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
92631 : bool
92632 0 : SgEqualityOp::isInMemoryPool ()
92633 : {
92634 0 : typedef unsigned char* TestType;
92635 :
92636 0 : bool found = false;
92637 :
92638 0 : ROSE_ASSERT(this != NULL);
92639 :
92640 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
92641 :
92642 0 : TestType tested = (TestType) ( this ) ;
92643 :
92644 0 : std::vector < unsigned char* > :: const_iterator block = SgEqualityOp::pools.begin();
92645 :
92646 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
92647 : // while (found == false && block < Memory_Block_List.end())
92648 0 : while ( (found == false) && (block != SgEqualityOp::pools.end()) )
92649 : {
92650 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgEqualityOp::pool_size * sizeof(SgEqualityOp) ) ) ;
92651 0 : ++block;
92652 : }
92653 :
92654 : // Special handling for static data
92655 :
92656 :
92657 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
92658 0 : ROSE_ASSERT(found == true);
92659 :
92660 0 : return found;
92661 : }
92662 : /* #line 92663 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
92663 :
92664 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
92665 :
92666 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
92667 :
92668 : /* #line 92669 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
92669 :
92670 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
92671 :
92672 : void
92673 0 : SgLessThanOp::checkDataMemberPointersIfInMemoryPool()
92674 : {
92675 : // ------------ checking pointers of SgLessThanOp -------------------
92676 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
92677 :
92678 0 : if ( p_lhs_operand_i != NULL )
92679 : {
92680 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92681 : {
92682 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
92683 : {
92684 0 : std::cout << "SgLessThanOp :: ";
92685 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
92686 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
92687 : }
92688 : }
92689 : else
92690 : {
92691 0 : std::cout << "SgLessThanOp :: " << std::flush;
92692 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
92693 0 : std::cout << " not valid " << std::endl;
92694 : }
92695 : }
92696 :
92697 0 : if ( p_rhs_operand_i != NULL )
92698 : {
92699 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92700 : {
92701 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
92702 : {
92703 0 : std::cout << "SgLessThanOp :: ";
92704 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
92705 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
92706 : }
92707 : }
92708 : else
92709 : {
92710 0 : std::cout << "SgLessThanOp :: " << std::flush;
92711 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
92712 0 : std::cout << " not valid " << std::endl;
92713 : }
92714 : }
92715 :
92716 0 : if ( p_expression_type != NULL )
92717 : {
92718 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92719 : {
92720 0 : if ( p_expression_type->isInMemoryPool() == false )
92721 : {
92722 0 : std::cout << "SgLessThanOp :: ";
92723 0 : std::cout << " p_expression_type is not in memory pool of ";
92724 0 : std::cout << p_expression_type->class_name() << std::endl;
92725 : }
92726 : }
92727 : else
92728 : {
92729 0 : std::cout << "SgLessThanOp :: " << std::flush;
92730 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
92731 0 : std::cout << " not valid " << std::endl;
92732 : }
92733 : }
92734 :
92735 0 : if ( p_originalExpressionTree != NULL )
92736 : {
92737 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92738 : {
92739 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
92740 : {
92741 0 : std::cout << "SgLessThanOp :: ";
92742 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
92743 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
92744 : }
92745 : }
92746 : else
92747 : {
92748 0 : std::cout << "SgLessThanOp :: " << std::flush;
92749 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
92750 0 : std::cout << " not valid " << std::endl;
92751 : }
92752 : }
92753 :
92754 0 : if ( p_operatorPosition != NULL )
92755 : {
92756 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92757 : {
92758 0 : if ( p_operatorPosition->isInMemoryPool() == false )
92759 : {
92760 0 : std::cout << "SgLessThanOp :: ";
92761 0 : std::cout << " p_operatorPosition is not in memory pool of ";
92762 0 : std::cout << p_operatorPosition->class_name() << std::endl;
92763 : }
92764 : }
92765 : else
92766 : {
92767 0 : std::cout << "SgLessThanOp :: " << std::flush;
92768 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
92769 0 : std::cout << " not valid " << std::endl;
92770 : }
92771 : }
92772 :
92773 0 : if ( p_startOfConstruct != NULL )
92774 : {
92775 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92776 : {
92777 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
92778 : {
92779 0 : std::cout << "SgLessThanOp :: ";
92780 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
92781 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
92782 : }
92783 : }
92784 : else
92785 : {
92786 0 : std::cout << "SgLessThanOp :: " << std::flush;
92787 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
92788 0 : std::cout << " not valid " << std::endl;
92789 : }
92790 : }
92791 :
92792 0 : if ( p_endOfConstruct != NULL )
92793 : {
92794 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92795 : {
92796 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
92797 : {
92798 0 : std::cout << "SgLessThanOp :: ";
92799 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
92800 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
92801 : }
92802 : }
92803 : else
92804 : {
92805 0 : std::cout << "SgLessThanOp :: " << std::flush;
92806 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
92807 0 : std::cout << " not valid " << std::endl;
92808 : }
92809 : }
92810 :
92811 0 : if ( p_parent != NULL )
92812 : {
92813 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92814 : {
92815 0 : if ( p_parent->isInMemoryPool() == false )
92816 : {
92817 0 : std::cout << "SgLessThanOp :: ";
92818 0 : std::cout << " p_parent is not in memory pool of ";
92819 0 : std::cout << p_parent->class_name() << std::endl;
92820 : }
92821 : }
92822 : else
92823 : {
92824 0 : std::cout << "SgLessThanOp :: " << std::flush;
92825 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
92826 0 : std::cout << " not valid " << std::endl;
92827 : }
92828 : }
92829 :
92830 :
92831 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
92832 :
92833 0 : }
92834 :
92835 :
92836 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
92837 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
92838 : bool
92839 0 : SgLessThanOp::isInMemoryPool ()
92840 : {
92841 0 : typedef unsigned char* TestType;
92842 :
92843 0 : bool found = false;
92844 :
92845 0 : ROSE_ASSERT(this != NULL);
92846 :
92847 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
92848 :
92849 0 : TestType tested = (TestType) ( this ) ;
92850 :
92851 0 : std::vector < unsigned char* > :: const_iterator block = SgLessThanOp::pools.begin();
92852 :
92853 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
92854 : // while (found == false && block < Memory_Block_List.end())
92855 0 : while ( (found == false) && (block != SgLessThanOp::pools.end()) )
92856 : {
92857 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLessThanOp::pool_size * sizeof(SgLessThanOp) ) ) ;
92858 0 : ++block;
92859 : }
92860 :
92861 : // Special handling for static data
92862 :
92863 :
92864 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
92865 0 : ROSE_ASSERT(found == true);
92866 :
92867 0 : return found;
92868 : }
92869 : /* #line 92870 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
92870 :
92871 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
92872 :
92873 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
92874 :
92875 : /* #line 92876 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
92876 :
92877 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
92878 :
92879 : void
92880 0 : SgGreaterThanOp::checkDataMemberPointersIfInMemoryPool()
92881 : {
92882 : // ------------ checking pointers of SgGreaterThanOp -------------------
92883 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
92884 :
92885 0 : if ( p_lhs_operand_i != NULL )
92886 : {
92887 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92888 : {
92889 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
92890 : {
92891 0 : std::cout << "SgGreaterThanOp :: ";
92892 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
92893 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
92894 : }
92895 : }
92896 : else
92897 : {
92898 0 : std::cout << "SgGreaterThanOp :: " << std::flush;
92899 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
92900 0 : std::cout << " not valid " << std::endl;
92901 : }
92902 : }
92903 :
92904 0 : if ( p_rhs_operand_i != NULL )
92905 : {
92906 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92907 : {
92908 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
92909 : {
92910 0 : std::cout << "SgGreaterThanOp :: ";
92911 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
92912 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
92913 : }
92914 : }
92915 : else
92916 : {
92917 0 : std::cout << "SgGreaterThanOp :: " << std::flush;
92918 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
92919 0 : std::cout << " not valid " << std::endl;
92920 : }
92921 : }
92922 :
92923 0 : if ( p_expression_type != NULL )
92924 : {
92925 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92926 : {
92927 0 : if ( p_expression_type->isInMemoryPool() == false )
92928 : {
92929 0 : std::cout << "SgGreaterThanOp :: ";
92930 0 : std::cout << " p_expression_type is not in memory pool of ";
92931 0 : std::cout << p_expression_type->class_name() << std::endl;
92932 : }
92933 : }
92934 : else
92935 : {
92936 0 : std::cout << "SgGreaterThanOp :: " << std::flush;
92937 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
92938 0 : std::cout << " not valid " << std::endl;
92939 : }
92940 : }
92941 :
92942 0 : if ( p_originalExpressionTree != NULL )
92943 : {
92944 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92945 : {
92946 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
92947 : {
92948 0 : std::cout << "SgGreaterThanOp :: ";
92949 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
92950 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
92951 : }
92952 : }
92953 : else
92954 : {
92955 0 : std::cout << "SgGreaterThanOp :: " << std::flush;
92956 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
92957 0 : std::cout << " not valid " << std::endl;
92958 : }
92959 : }
92960 :
92961 0 : if ( p_operatorPosition != NULL )
92962 : {
92963 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92964 : {
92965 0 : if ( p_operatorPosition->isInMemoryPool() == false )
92966 : {
92967 0 : std::cout << "SgGreaterThanOp :: ";
92968 0 : std::cout << " p_operatorPosition is not in memory pool of ";
92969 0 : std::cout << p_operatorPosition->class_name() << std::endl;
92970 : }
92971 : }
92972 : else
92973 : {
92974 0 : std::cout << "SgGreaterThanOp :: " << std::flush;
92975 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
92976 0 : std::cout << " not valid " << std::endl;
92977 : }
92978 : }
92979 :
92980 0 : if ( p_startOfConstruct != NULL )
92981 : {
92982 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
92983 : {
92984 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
92985 : {
92986 0 : std::cout << "SgGreaterThanOp :: ";
92987 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
92988 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
92989 : }
92990 : }
92991 : else
92992 : {
92993 0 : std::cout << "SgGreaterThanOp :: " << std::flush;
92994 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
92995 0 : std::cout << " not valid " << std::endl;
92996 : }
92997 : }
92998 :
92999 0 : if ( p_endOfConstruct != NULL )
93000 : {
93001 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93002 : {
93003 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
93004 : {
93005 0 : std::cout << "SgGreaterThanOp :: ";
93006 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
93007 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
93008 : }
93009 : }
93010 : else
93011 : {
93012 0 : std::cout << "SgGreaterThanOp :: " << std::flush;
93013 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
93014 0 : std::cout << " not valid " << std::endl;
93015 : }
93016 : }
93017 :
93018 0 : if ( p_parent != NULL )
93019 : {
93020 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93021 : {
93022 0 : if ( p_parent->isInMemoryPool() == false )
93023 : {
93024 0 : std::cout << "SgGreaterThanOp :: ";
93025 0 : std::cout << " p_parent is not in memory pool of ";
93026 0 : std::cout << p_parent->class_name() << std::endl;
93027 : }
93028 : }
93029 : else
93030 : {
93031 0 : std::cout << "SgGreaterThanOp :: " << std::flush;
93032 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
93033 0 : std::cout << " not valid " << std::endl;
93034 : }
93035 : }
93036 :
93037 :
93038 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
93039 :
93040 0 : }
93041 :
93042 :
93043 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
93044 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
93045 : bool
93046 0 : SgGreaterThanOp::isInMemoryPool ()
93047 : {
93048 0 : typedef unsigned char* TestType;
93049 :
93050 0 : bool found = false;
93051 :
93052 0 : ROSE_ASSERT(this != NULL);
93053 :
93054 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
93055 :
93056 0 : TestType tested = (TestType) ( this ) ;
93057 :
93058 0 : std::vector < unsigned char* > :: const_iterator block = SgGreaterThanOp::pools.begin();
93059 :
93060 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
93061 : // while (found == false && block < Memory_Block_List.end())
93062 0 : while ( (found == false) && (block != SgGreaterThanOp::pools.end()) )
93063 : {
93064 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgGreaterThanOp::pool_size * sizeof(SgGreaterThanOp) ) ) ;
93065 0 : ++block;
93066 : }
93067 :
93068 : // Special handling for static data
93069 :
93070 :
93071 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
93072 0 : ROSE_ASSERT(found == true);
93073 :
93074 0 : return found;
93075 : }
93076 : /* #line 93077 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
93077 :
93078 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
93079 :
93080 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
93081 :
93082 : /* #line 93083 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
93083 :
93084 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
93085 :
93086 : void
93087 0 : SgNotEqualOp::checkDataMemberPointersIfInMemoryPool()
93088 : {
93089 : // ------------ checking pointers of SgNotEqualOp -------------------
93090 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
93091 :
93092 0 : if ( p_lhs_operand_i != NULL )
93093 : {
93094 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93095 : {
93096 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
93097 : {
93098 0 : std::cout << "SgNotEqualOp :: ";
93099 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
93100 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
93101 : }
93102 : }
93103 : else
93104 : {
93105 0 : std::cout << "SgNotEqualOp :: " << std::flush;
93106 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
93107 0 : std::cout << " not valid " << std::endl;
93108 : }
93109 : }
93110 :
93111 0 : if ( p_rhs_operand_i != NULL )
93112 : {
93113 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93114 : {
93115 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
93116 : {
93117 0 : std::cout << "SgNotEqualOp :: ";
93118 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
93119 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
93120 : }
93121 : }
93122 : else
93123 : {
93124 0 : std::cout << "SgNotEqualOp :: " << std::flush;
93125 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
93126 0 : std::cout << " not valid " << std::endl;
93127 : }
93128 : }
93129 :
93130 0 : if ( p_expression_type != NULL )
93131 : {
93132 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93133 : {
93134 0 : if ( p_expression_type->isInMemoryPool() == false )
93135 : {
93136 0 : std::cout << "SgNotEqualOp :: ";
93137 0 : std::cout << " p_expression_type is not in memory pool of ";
93138 0 : std::cout << p_expression_type->class_name() << std::endl;
93139 : }
93140 : }
93141 : else
93142 : {
93143 0 : std::cout << "SgNotEqualOp :: " << std::flush;
93144 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
93145 0 : std::cout << " not valid " << std::endl;
93146 : }
93147 : }
93148 :
93149 0 : if ( p_originalExpressionTree != NULL )
93150 : {
93151 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93152 : {
93153 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
93154 : {
93155 0 : std::cout << "SgNotEqualOp :: ";
93156 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
93157 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
93158 : }
93159 : }
93160 : else
93161 : {
93162 0 : std::cout << "SgNotEqualOp :: " << std::flush;
93163 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
93164 0 : std::cout << " not valid " << std::endl;
93165 : }
93166 : }
93167 :
93168 0 : if ( p_operatorPosition != NULL )
93169 : {
93170 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93171 : {
93172 0 : if ( p_operatorPosition->isInMemoryPool() == false )
93173 : {
93174 0 : std::cout << "SgNotEqualOp :: ";
93175 0 : std::cout << " p_operatorPosition is not in memory pool of ";
93176 0 : std::cout << p_operatorPosition->class_name() << std::endl;
93177 : }
93178 : }
93179 : else
93180 : {
93181 0 : std::cout << "SgNotEqualOp :: " << std::flush;
93182 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
93183 0 : std::cout << " not valid " << std::endl;
93184 : }
93185 : }
93186 :
93187 0 : if ( p_startOfConstruct != NULL )
93188 : {
93189 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93190 : {
93191 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
93192 : {
93193 0 : std::cout << "SgNotEqualOp :: ";
93194 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
93195 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
93196 : }
93197 : }
93198 : else
93199 : {
93200 0 : std::cout << "SgNotEqualOp :: " << std::flush;
93201 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
93202 0 : std::cout << " not valid " << std::endl;
93203 : }
93204 : }
93205 :
93206 0 : if ( p_endOfConstruct != NULL )
93207 : {
93208 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93209 : {
93210 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
93211 : {
93212 0 : std::cout << "SgNotEqualOp :: ";
93213 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
93214 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
93215 : }
93216 : }
93217 : else
93218 : {
93219 0 : std::cout << "SgNotEqualOp :: " << std::flush;
93220 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
93221 0 : std::cout << " not valid " << std::endl;
93222 : }
93223 : }
93224 :
93225 0 : if ( p_parent != NULL )
93226 : {
93227 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93228 : {
93229 0 : if ( p_parent->isInMemoryPool() == false )
93230 : {
93231 0 : std::cout << "SgNotEqualOp :: ";
93232 0 : std::cout << " p_parent is not in memory pool of ";
93233 0 : std::cout << p_parent->class_name() << std::endl;
93234 : }
93235 : }
93236 : else
93237 : {
93238 0 : std::cout << "SgNotEqualOp :: " << std::flush;
93239 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
93240 0 : std::cout << " not valid " << std::endl;
93241 : }
93242 : }
93243 :
93244 :
93245 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
93246 :
93247 0 : }
93248 :
93249 :
93250 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
93251 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
93252 : bool
93253 0 : SgNotEqualOp::isInMemoryPool ()
93254 : {
93255 0 : typedef unsigned char* TestType;
93256 :
93257 0 : bool found = false;
93258 :
93259 0 : ROSE_ASSERT(this != NULL);
93260 :
93261 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
93262 :
93263 0 : TestType tested = (TestType) ( this ) ;
93264 :
93265 0 : std::vector < unsigned char* > :: const_iterator block = SgNotEqualOp::pools.begin();
93266 :
93267 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
93268 : // while (found == false && block < Memory_Block_List.end())
93269 0 : while ( (found == false) && (block != SgNotEqualOp::pools.end()) )
93270 : {
93271 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNotEqualOp::pool_size * sizeof(SgNotEqualOp) ) ) ;
93272 0 : ++block;
93273 : }
93274 :
93275 : // Special handling for static data
93276 :
93277 :
93278 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
93279 0 : ROSE_ASSERT(found == true);
93280 :
93281 0 : return found;
93282 : }
93283 : /* #line 93284 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
93284 :
93285 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
93286 :
93287 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
93288 :
93289 : /* #line 93290 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
93290 :
93291 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
93292 :
93293 : void
93294 0 : SgLessOrEqualOp::checkDataMemberPointersIfInMemoryPool()
93295 : {
93296 : // ------------ checking pointers of SgLessOrEqualOp -------------------
93297 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
93298 :
93299 0 : if ( p_lhs_operand_i != NULL )
93300 : {
93301 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93302 : {
93303 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
93304 : {
93305 0 : std::cout << "SgLessOrEqualOp :: ";
93306 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
93307 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
93308 : }
93309 : }
93310 : else
93311 : {
93312 0 : std::cout << "SgLessOrEqualOp :: " << std::flush;
93313 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
93314 0 : std::cout << " not valid " << std::endl;
93315 : }
93316 : }
93317 :
93318 0 : if ( p_rhs_operand_i != NULL )
93319 : {
93320 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93321 : {
93322 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
93323 : {
93324 0 : std::cout << "SgLessOrEqualOp :: ";
93325 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
93326 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
93327 : }
93328 : }
93329 : else
93330 : {
93331 0 : std::cout << "SgLessOrEqualOp :: " << std::flush;
93332 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
93333 0 : std::cout << " not valid " << std::endl;
93334 : }
93335 : }
93336 :
93337 0 : if ( p_expression_type != NULL )
93338 : {
93339 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93340 : {
93341 0 : if ( p_expression_type->isInMemoryPool() == false )
93342 : {
93343 0 : std::cout << "SgLessOrEqualOp :: ";
93344 0 : std::cout << " p_expression_type is not in memory pool of ";
93345 0 : std::cout << p_expression_type->class_name() << std::endl;
93346 : }
93347 : }
93348 : else
93349 : {
93350 0 : std::cout << "SgLessOrEqualOp :: " << std::flush;
93351 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
93352 0 : std::cout << " not valid " << std::endl;
93353 : }
93354 : }
93355 :
93356 0 : if ( p_originalExpressionTree != NULL )
93357 : {
93358 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93359 : {
93360 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
93361 : {
93362 0 : std::cout << "SgLessOrEqualOp :: ";
93363 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
93364 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
93365 : }
93366 : }
93367 : else
93368 : {
93369 0 : std::cout << "SgLessOrEqualOp :: " << std::flush;
93370 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
93371 0 : std::cout << " not valid " << std::endl;
93372 : }
93373 : }
93374 :
93375 0 : if ( p_operatorPosition != NULL )
93376 : {
93377 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93378 : {
93379 0 : if ( p_operatorPosition->isInMemoryPool() == false )
93380 : {
93381 0 : std::cout << "SgLessOrEqualOp :: ";
93382 0 : std::cout << " p_operatorPosition is not in memory pool of ";
93383 0 : std::cout << p_operatorPosition->class_name() << std::endl;
93384 : }
93385 : }
93386 : else
93387 : {
93388 0 : std::cout << "SgLessOrEqualOp :: " << std::flush;
93389 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
93390 0 : std::cout << " not valid " << std::endl;
93391 : }
93392 : }
93393 :
93394 0 : if ( p_startOfConstruct != NULL )
93395 : {
93396 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93397 : {
93398 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
93399 : {
93400 0 : std::cout << "SgLessOrEqualOp :: ";
93401 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
93402 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
93403 : }
93404 : }
93405 : else
93406 : {
93407 0 : std::cout << "SgLessOrEqualOp :: " << std::flush;
93408 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
93409 0 : std::cout << " not valid " << std::endl;
93410 : }
93411 : }
93412 :
93413 0 : if ( p_endOfConstruct != NULL )
93414 : {
93415 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93416 : {
93417 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
93418 : {
93419 0 : std::cout << "SgLessOrEqualOp :: ";
93420 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
93421 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
93422 : }
93423 : }
93424 : else
93425 : {
93426 0 : std::cout << "SgLessOrEqualOp :: " << std::flush;
93427 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
93428 0 : std::cout << " not valid " << std::endl;
93429 : }
93430 : }
93431 :
93432 0 : if ( p_parent != NULL )
93433 : {
93434 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93435 : {
93436 0 : if ( p_parent->isInMemoryPool() == false )
93437 : {
93438 0 : std::cout << "SgLessOrEqualOp :: ";
93439 0 : std::cout << " p_parent is not in memory pool of ";
93440 0 : std::cout << p_parent->class_name() << std::endl;
93441 : }
93442 : }
93443 : else
93444 : {
93445 0 : std::cout << "SgLessOrEqualOp :: " << std::flush;
93446 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
93447 0 : std::cout << " not valid " << std::endl;
93448 : }
93449 : }
93450 :
93451 :
93452 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
93453 :
93454 0 : }
93455 :
93456 :
93457 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
93458 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
93459 : bool
93460 0 : SgLessOrEqualOp::isInMemoryPool ()
93461 : {
93462 0 : typedef unsigned char* TestType;
93463 :
93464 0 : bool found = false;
93465 :
93466 0 : ROSE_ASSERT(this != NULL);
93467 :
93468 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
93469 :
93470 0 : TestType tested = (TestType) ( this ) ;
93471 :
93472 0 : std::vector < unsigned char* > :: const_iterator block = SgLessOrEqualOp::pools.begin();
93473 :
93474 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
93475 : // while (found == false && block < Memory_Block_List.end())
93476 0 : while ( (found == false) && (block != SgLessOrEqualOp::pools.end()) )
93477 : {
93478 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLessOrEqualOp::pool_size * sizeof(SgLessOrEqualOp) ) ) ;
93479 0 : ++block;
93480 : }
93481 :
93482 : // Special handling for static data
93483 :
93484 :
93485 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
93486 0 : ROSE_ASSERT(found == true);
93487 :
93488 0 : return found;
93489 : }
93490 : /* #line 93491 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
93491 :
93492 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
93493 :
93494 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
93495 :
93496 : /* #line 93497 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
93497 :
93498 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
93499 :
93500 : void
93501 0 : SgGreaterOrEqualOp::checkDataMemberPointersIfInMemoryPool()
93502 : {
93503 : // ------------ checking pointers of SgGreaterOrEqualOp -------------------
93504 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
93505 :
93506 0 : if ( p_lhs_operand_i != NULL )
93507 : {
93508 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93509 : {
93510 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
93511 : {
93512 0 : std::cout << "SgGreaterOrEqualOp :: ";
93513 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
93514 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
93515 : }
93516 : }
93517 : else
93518 : {
93519 0 : std::cout << "SgGreaterOrEqualOp :: " << std::flush;
93520 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
93521 0 : std::cout << " not valid " << std::endl;
93522 : }
93523 : }
93524 :
93525 0 : if ( p_rhs_operand_i != NULL )
93526 : {
93527 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93528 : {
93529 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
93530 : {
93531 0 : std::cout << "SgGreaterOrEqualOp :: ";
93532 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
93533 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
93534 : }
93535 : }
93536 : else
93537 : {
93538 0 : std::cout << "SgGreaterOrEqualOp :: " << std::flush;
93539 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
93540 0 : std::cout << " not valid " << std::endl;
93541 : }
93542 : }
93543 :
93544 0 : if ( p_expression_type != NULL )
93545 : {
93546 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93547 : {
93548 0 : if ( p_expression_type->isInMemoryPool() == false )
93549 : {
93550 0 : std::cout << "SgGreaterOrEqualOp :: ";
93551 0 : std::cout << " p_expression_type is not in memory pool of ";
93552 0 : std::cout << p_expression_type->class_name() << std::endl;
93553 : }
93554 : }
93555 : else
93556 : {
93557 0 : std::cout << "SgGreaterOrEqualOp :: " << std::flush;
93558 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
93559 0 : std::cout << " not valid " << std::endl;
93560 : }
93561 : }
93562 :
93563 0 : if ( p_originalExpressionTree != NULL )
93564 : {
93565 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93566 : {
93567 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
93568 : {
93569 0 : std::cout << "SgGreaterOrEqualOp :: ";
93570 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
93571 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
93572 : }
93573 : }
93574 : else
93575 : {
93576 0 : std::cout << "SgGreaterOrEqualOp :: " << std::flush;
93577 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
93578 0 : std::cout << " not valid " << std::endl;
93579 : }
93580 : }
93581 :
93582 0 : if ( p_operatorPosition != NULL )
93583 : {
93584 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93585 : {
93586 0 : if ( p_operatorPosition->isInMemoryPool() == false )
93587 : {
93588 0 : std::cout << "SgGreaterOrEqualOp :: ";
93589 0 : std::cout << " p_operatorPosition is not in memory pool of ";
93590 0 : std::cout << p_operatorPosition->class_name() << std::endl;
93591 : }
93592 : }
93593 : else
93594 : {
93595 0 : std::cout << "SgGreaterOrEqualOp :: " << std::flush;
93596 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
93597 0 : std::cout << " not valid " << std::endl;
93598 : }
93599 : }
93600 :
93601 0 : if ( p_startOfConstruct != NULL )
93602 : {
93603 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93604 : {
93605 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
93606 : {
93607 0 : std::cout << "SgGreaterOrEqualOp :: ";
93608 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
93609 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
93610 : }
93611 : }
93612 : else
93613 : {
93614 0 : std::cout << "SgGreaterOrEqualOp :: " << std::flush;
93615 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
93616 0 : std::cout << " not valid " << std::endl;
93617 : }
93618 : }
93619 :
93620 0 : if ( p_endOfConstruct != NULL )
93621 : {
93622 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93623 : {
93624 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
93625 : {
93626 0 : std::cout << "SgGreaterOrEqualOp :: ";
93627 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
93628 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
93629 : }
93630 : }
93631 : else
93632 : {
93633 0 : std::cout << "SgGreaterOrEqualOp :: " << std::flush;
93634 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
93635 0 : std::cout << " not valid " << std::endl;
93636 : }
93637 : }
93638 :
93639 0 : if ( p_parent != NULL )
93640 : {
93641 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93642 : {
93643 0 : if ( p_parent->isInMemoryPool() == false )
93644 : {
93645 0 : std::cout << "SgGreaterOrEqualOp :: ";
93646 0 : std::cout << " p_parent is not in memory pool of ";
93647 0 : std::cout << p_parent->class_name() << std::endl;
93648 : }
93649 : }
93650 : else
93651 : {
93652 0 : std::cout << "SgGreaterOrEqualOp :: " << std::flush;
93653 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
93654 0 : std::cout << " not valid " << std::endl;
93655 : }
93656 : }
93657 :
93658 :
93659 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
93660 :
93661 0 : }
93662 :
93663 :
93664 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
93665 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
93666 : bool
93667 0 : SgGreaterOrEqualOp::isInMemoryPool ()
93668 : {
93669 0 : typedef unsigned char* TestType;
93670 :
93671 0 : bool found = false;
93672 :
93673 0 : ROSE_ASSERT(this != NULL);
93674 :
93675 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
93676 :
93677 0 : TestType tested = (TestType) ( this ) ;
93678 :
93679 0 : std::vector < unsigned char* > :: const_iterator block = SgGreaterOrEqualOp::pools.begin();
93680 :
93681 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
93682 : // while (found == false && block < Memory_Block_List.end())
93683 0 : while ( (found == false) && (block != SgGreaterOrEqualOp::pools.end()) )
93684 : {
93685 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgGreaterOrEqualOp::pool_size * sizeof(SgGreaterOrEqualOp) ) ) ;
93686 0 : ++block;
93687 : }
93688 :
93689 : // Special handling for static data
93690 :
93691 :
93692 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
93693 0 : ROSE_ASSERT(found == true);
93694 :
93695 0 : return found;
93696 : }
93697 : /* #line 93698 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
93698 :
93699 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
93700 :
93701 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
93702 :
93703 : /* #line 93704 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
93704 :
93705 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
93706 :
93707 : void
93708 0 : SgAddOp::checkDataMemberPointersIfInMemoryPool()
93709 : {
93710 : // ------------ checking pointers of SgAddOp -------------------
93711 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
93712 :
93713 0 : if ( p_lhs_operand_i != NULL )
93714 : {
93715 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93716 : {
93717 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
93718 : {
93719 0 : std::cout << "SgAddOp :: ";
93720 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
93721 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
93722 : }
93723 : }
93724 : else
93725 : {
93726 0 : std::cout << "SgAddOp :: " << std::flush;
93727 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
93728 0 : std::cout << " not valid " << std::endl;
93729 : }
93730 : }
93731 :
93732 0 : if ( p_rhs_operand_i != NULL )
93733 : {
93734 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93735 : {
93736 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
93737 : {
93738 0 : std::cout << "SgAddOp :: ";
93739 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
93740 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
93741 : }
93742 : }
93743 : else
93744 : {
93745 0 : std::cout << "SgAddOp :: " << std::flush;
93746 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
93747 0 : std::cout << " not valid " << std::endl;
93748 : }
93749 : }
93750 :
93751 0 : if ( p_expression_type != NULL )
93752 : {
93753 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93754 : {
93755 0 : if ( p_expression_type->isInMemoryPool() == false )
93756 : {
93757 0 : std::cout << "SgAddOp :: ";
93758 0 : std::cout << " p_expression_type is not in memory pool of ";
93759 0 : std::cout << p_expression_type->class_name() << std::endl;
93760 : }
93761 : }
93762 : else
93763 : {
93764 0 : std::cout << "SgAddOp :: " << std::flush;
93765 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
93766 0 : std::cout << " not valid " << std::endl;
93767 : }
93768 : }
93769 :
93770 0 : if ( p_originalExpressionTree != NULL )
93771 : {
93772 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93773 : {
93774 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
93775 : {
93776 0 : std::cout << "SgAddOp :: ";
93777 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
93778 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
93779 : }
93780 : }
93781 : else
93782 : {
93783 0 : std::cout << "SgAddOp :: " << std::flush;
93784 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
93785 0 : std::cout << " not valid " << std::endl;
93786 : }
93787 : }
93788 :
93789 0 : if ( p_operatorPosition != NULL )
93790 : {
93791 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93792 : {
93793 0 : if ( p_operatorPosition->isInMemoryPool() == false )
93794 : {
93795 0 : std::cout << "SgAddOp :: ";
93796 0 : std::cout << " p_operatorPosition is not in memory pool of ";
93797 0 : std::cout << p_operatorPosition->class_name() << std::endl;
93798 : }
93799 : }
93800 : else
93801 : {
93802 0 : std::cout << "SgAddOp :: " << std::flush;
93803 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
93804 0 : std::cout << " not valid " << std::endl;
93805 : }
93806 : }
93807 :
93808 0 : if ( p_startOfConstruct != NULL )
93809 : {
93810 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93811 : {
93812 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
93813 : {
93814 0 : std::cout << "SgAddOp :: ";
93815 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
93816 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
93817 : }
93818 : }
93819 : else
93820 : {
93821 0 : std::cout << "SgAddOp :: " << std::flush;
93822 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
93823 0 : std::cout << " not valid " << std::endl;
93824 : }
93825 : }
93826 :
93827 0 : if ( p_endOfConstruct != NULL )
93828 : {
93829 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93830 : {
93831 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
93832 : {
93833 0 : std::cout << "SgAddOp :: ";
93834 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
93835 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
93836 : }
93837 : }
93838 : else
93839 : {
93840 0 : std::cout << "SgAddOp :: " << std::flush;
93841 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
93842 0 : std::cout << " not valid " << std::endl;
93843 : }
93844 : }
93845 :
93846 0 : if ( p_parent != NULL )
93847 : {
93848 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93849 : {
93850 0 : if ( p_parent->isInMemoryPool() == false )
93851 : {
93852 0 : std::cout << "SgAddOp :: ";
93853 0 : std::cout << " p_parent is not in memory pool of ";
93854 0 : std::cout << p_parent->class_name() << std::endl;
93855 : }
93856 : }
93857 : else
93858 : {
93859 0 : std::cout << "SgAddOp :: " << std::flush;
93860 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
93861 0 : std::cout << " not valid " << std::endl;
93862 : }
93863 : }
93864 :
93865 :
93866 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
93867 :
93868 0 : }
93869 :
93870 :
93871 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
93872 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
93873 : bool
93874 0 : SgAddOp::isInMemoryPool ()
93875 : {
93876 0 : typedef unsigned char* TestType;
93877 :
93878 0 : bool found = false;
93879 :
93880 0 : ROSE_ASSERT(this != NULL);
93881 :
93882 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
93883 :
93884 0 : TestType tested = (TestType) ( this ) ;
93885 :
93886 0 : std::vector < unsigned char* > :: const_iterator block = SgAddOp::pools.begin();
93887 :
93888 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
93889 : // while (found == false && block < Memory_Block_List.end())
93890 0 : while ( (found == false) && (block != SgAddOp::pools.end()) )
93891 : {
93892 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAddOp::pool_size * sizeof(SgAddOp) ) ) ;
93893 0 : ++block;
93894 : }
93895 :
93896 : // Special handling for static data
93897 :
93898 :
93899 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
93900 0 : ROSE_ASSERT(found == true);
93901 :
93902 0 : return found;
93903 : }
93904 : /* #line 93905 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
93905 :
93906 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
93907 :
93908 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
93909 :
93910 : /* #line 93911 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
93911 :
93912 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
93913 :
93914 : void
93915 0 : SgSubtractOp::checkDataMemberPointersIfInMemoryPool()
93916 : {
93917 : // ------------ checking pointers of SgSubtractOp -------------------
93918 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
93919 :
93920 0 : if ( p_lhs_operand_i != NULL )
93921 : {
93922 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93923 : {
93924 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
93925 : {
93926 0 : std::cout << "SgSubtractOp :: ";
93927 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
93928 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
93929 : }
93930 : }
93931 : else
93932 : {
93933 0 : std::cout << "SgSubtractOp :: " << std::flush;
93934 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
93935 0 : std::cout << " not valid " << std::endl;
93936 : }
93937 : }
93938 :
93939 0 : if ( p_rhs_operand_i != NULL )
93940 : {
93941 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93942 : {
93943 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
93944 : {
93945 0 : std::cout << "SgSubtractOp :: ";
93946 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
93947 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
93948 : }
93949 : }
93950 : else
93951 : {
93952 0 : std::cout << "SgSubtractOp :: " << std::flush;
93953 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
93954 0 : std::cout << " not valid " << std::endl;
93955 : }
93956 : }
93957 :
93958 0 : if ( p_expression_type != NULL )
93959 : {
93960 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93961 : {
93962 0 : if ( p_expression_type->isInMemoryPool() == false )
93963 : {
93964 0 : std::cout << "SgSubtractOp :: ";
93965 0 : std::cout << " p_expression_type is not in memory pool of ";
93966 0 : std::cout << p_expression_type->class_name() << std::endl;
93967 : }
93968 : }
93969 : else
93970 : {
93971 0 : std::cout << "SgSubtractOp :: " << std::flush;
93972 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
93973 0 : std::cout << " not valid " << std::endl;
93974 : }
93975 : }
93976 :
93977 0 : if ( p_originalExpressionTree != NULL )
93978 : {
93979 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93980 : {
93981 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
93982 : {
93983 0 : std::cout << "SgSubtractOp :: ";
93984 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
93985 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
93986 : }
93987 : }
93988 : else
93989 : {
93990 0 : std::cout << "SgSubtractOp :: " << std::flush;
93991 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
93992 0 : std::cout << " not valid " << std::endl;
93993 : }
93994 : }
93995 :
93996 0 : if ( p_operatorPosition != NULL )
93997 : {
93998 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
93999 : {
94000 0 : if ( p_operatorPosition->isInMemoryPool() == false )
94001 : {
94002 0 : std::cout << "SgSubtractOp :: ";
94003 0 : std::cout << " p_operatorPosition is not in memory pool of ";
94004 0 : std::cout << p_operatorPosition->class_name() << std::endl;
94005 : }
94006 : }
94007 : else
94008 : {
94009 0 : std::cout << "SgSubtractOp :: " << std::flush;
94010 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
94011 0 : std::cout << " not valid " << std::endl;
94012 : }
94013 : }
94014 :
94015 0 : if ( p_startOfConstruct != NULL )
94016 : {
94017 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94018 : {
94019 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
94020 : {
94021 0 : std::cout << "SgSubtractOp :: ";
94022 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
94023 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
94024 : }
94025 : }
94026 : else
94027 : {
94028 0 : std::cout << "SgSubtractOp :: " << std::flush;
94029 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
94030 0 : std::cout << " not valid " << std::endl;
94031 : }
94032 : }
94033 :
94034 0 : if ( p_endOfConstruct != NULL )
94035 : {
94036 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94037 : {
94038 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
94039 : {
94040 0 : std::cout << "SgSubtractOp :: ";
94041 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
94042 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
94043 : }
94044 : }
94045 : else
94046 : {
94047 0 : std::cout << "SgSubtractOp :: " << std::flush;
94048 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
94049 0 : std::cout << " not valid " << std::endl;
94050 : }
94051 : }
94052 :
94053 0 : if ( p_parent != NULL )
94054 : {
94055 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94056 : {
94057 0 : if ( p_parent->isInMemoryPool() == false )
94058 : {
94059 0 : std::cout << "SgSubtractOp :: ";
94060 0 : std::cout << " p_parent is not in memory pool of ";
94061 0 : std::cout << p_parent->class_name() << std::endl;
94062 : }
94063 : }
94064 : else
94065 : {
94066 0 : std::cout << "SgSubtractOp :: " << std::flush;
94067 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
94068 0 : std::cout << " not valid " << std::endl;
94069 : }
94070 : }
94071 :
94072 :
94073 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
94074 :
94075 0 : }
94076 :
94077 :
94078 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
94079 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
94080 : bool
94081 0 : SgSubtractOp::isInMemoryPool ()
94082 : {
94083 0 : typedef unsigned char* TestType;
94084 :
94085 0 : bool found = false;
94086 :
94087 0 : ROSE_ASSERT(this != NULL);
94088 :
94089 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
94090 :
94091 0 : TestType tested = (TestType) ( this ) ;
94092 :
94093 0 : std::vector < unsigned char* > :: const_iterator block = SgSubtractOp::pools.begin();
94094 :
94095 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
94096 : // while (found == false && block < Memory_Block_List.end())
94097 0 : while ( (found == false) && (block != SgSubtractOp::pools.end()) )
94098 : {
94099 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSubtractOp::pool_size * sizeof(SgSubtractOp) ) ) ;
94100 0 : ++block;
94101 : }
94102 :
94103 : // Special handling for static data
94104 :
94105 :
94106 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
94107 0 : ROSE_ASSERT(found == true);
94108 :
94109 0 : return found;
94110 : }
94111 : /* #line 94112 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
94112 :
94113 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
94114 :
94115 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
94116 :
94117 : /* #line 94118 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
94118 :
94119 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
94120 :
94121 : void
94122 0 : SgMultiplyOp::checkDataMemberPointersIfInMemoryPool()
94123 : {
94124 : // ------------ checking pointers of SgMultiplyOp -------------------
94125 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
94126 :
94127 0 : if ( p_lhs_operand_i != NULL )
94128 : {
94129 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94130 : {
94131 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
94132 : {
94133 0 : std::cout << "SgMultiplyOp :: ";
94134 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
94135 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
94136 : }
94137 : }
94138 : else
94139 : {
94140 0 : std::cout << "SgMultiplyOp :: " << std::flush;
94141 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
94142 0 : std::cout << " not valid " << std::endl;
94143 : }
94144 : }
94145 :
94146 0 : if ( p_rhs_operand_i != NULL )
94147 : {
94148 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94149 : {
94150 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
94151 : {
94152 0 : std::cout << "SgMultiplyOp :: ";
94153 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
94154 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
94155 : }
94156 : }
94157 : else
94158 : {
94159 0 : std::cout << "SgMultiplyOp :: " << std::flush;
94160 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
94161 0 : std::cout << " not valid " << std::endl;
94162 : }
94163 : }
94164 :
94165 0 : if ( p_expression_type != NULL )
94166 : {
94167 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94168 : {
94169 0 : if ( p_expression_type->isInMemoryPool() == false )
94170 : {
94171 0 : std::cout << "SgMultiplyOp :: ";
94172 0 : std::cout << " p_expression_type is not in memory pool of ";
94173 0 : std::cout << p_expression_type->class_name() << std::endl;
94174 : }
94175 : }
94176 : else
94177 : {
94178 0 : std::cout << "SgMultiplyOp :: " << std::flush;
94179 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
94180 0 : std::cout << " not valid " << std::endl;
94181 : }
94182 : }
94183 :
94184 0 : if ( p_originalExpressionTree != NULL )
94185 : {
94186 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94187 : {
94188 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
94189 : {
94190 0 : std::cout << "SgMultiplyOp :: ";
94191 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
94192 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
94193 : }
94194 : }
94195 : else
94196 : {
94197 0 : std::cout << "SgMultiplyOp :: " << std::flush;
94198 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
94199 0 : std::cout << " not valid " << std::endl;
94200 : }
94201 : }
94202 :
94203 0 : if ( p_operatorPosition != NULL )
94204 : {
94205 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94206 : {
94207 0 : if ( p_operatorPosition->isInMemoryPool() == false )
94208 : {
94209 0 : std::cout << "SgMultiplyOp :: ";
94210 0 : std::cout << " p_operatorPosition is not in memory pool of ";
94211 0 : std::cout << p_operatorPosition->class_name() << std::endl;
94212 : }
94213 : }
94214 : else
94215 : {
94216 0 : std::cout << "SgMultiplyOp :: " << std::flush;
94217 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
94218 0 : std::cout << " not valid " << std::endl;
94219 : }
94220 : }
94221 :
94222 0 : if ( p_startOfConstruct != NULL )
94223 : {
94224 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94225 : {
94226 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
94227 : {
94228 0 : std::cout << "SgMultiplyOp :: ";
94229 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
94230 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
94231 : }
94232 : }
94233 : else
94234 : {
94235 0 : std::cout << "SgMultiplyOp :: " << std::flush;
94236 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
94237 0 : std::cout << " not valid " << std::endl;
94238 : }
94239 : }
94240 :
94241 0 : if ( p_endOfConstruct != NULL )
94242 : {
94243 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94244 : {
94245 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
94246 : {
94247 0 : std::cout << "SgMultiplyOp :: ";
94248 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
94249 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
94250 : }
94251 : }
94252 : else
94253 : {
94254 0 : std::cout << "SgMultiplyOp :: " << std::flush;
94255 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
94256 0 : std::cout << " not valid " << std::endl;
94257 : }
94258 : }
94259 :
94260 0 : if ( p_parent != NULL )
94261 : {
94262 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94263 : {
94264 0 : if ( p_parent->isInMemoryPool() == false )
94265 : {
94266 0 : std::cout << "SgMultiplyOp :: ";
94267 0 : std::cout << " p_parent is not in memory pool of ";
94268 0 : std::cout << p_parent->class_name() << std::endl;
94269 : }
94270 : }
94271 : else
94272 : {
94273 0 : std::cout << "SgMultiplyOp :: " << std::flush;
94274 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
94275 0 : std::cout << " not valid " << std::endl;
94276 : }
94277 : }
94278 :
94279 :
94280 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
94281 :
94282 0 : }
94283 :
94284 :
94285 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
94286 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
94287 : bool
94288 0 : SgMultiplyOp::isInMemoryPool ()
94289 : {
94290 0 : typedef unsigned char* TestType;
94291 :
94292 0 : bool found = false;
94293 :
94294 0 : ROSE_ASSERT(this != NULL);
94295 :
94296 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
94297 :
94298 0 : TestType tested = (TestType) ( this ) ;
94299 :
94300 0 : std::vector < unsigned char* > :: const_iterator block = SgMultiplyOp::pools.begin();
94301 :
94302 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
94303 : // while (found == false && block < Memory_Block_List.end())
94304 0 : while ( (found == false) && (block != SgMultiplyOp::pools.end()) )
94305 : {
94306 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgMultiplyOp::pool_size * sizeof(SgMultiplyOp) ) ) ;
94307 0 : ++block;
94308 : }
94309 :
94310 : // Special handling for static data
94311 :
94312 :
94313 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
94314 0 : ROSE_ASSERT(found == true);
94315 :
94316 0 : return found;
94317 : }
94318 : /* #line 94319 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
94319 :
94320 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
94321 :
94322 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
94323 :
94324 : /* #line 94325 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
94325 :
94326 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
94327 :
94328 : void
94329 0 : SgDivideOp::checkDataMemberPointersIfInMemoryPool()
94330 : {
94331 : // ------------ checking pointers of SgDivideOp -------------------
94332 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
94333 :
94334 0 : if ( p_lhs_operand_i != NULL )
94335 : {
94336 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94337 : {
94338 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
94339 : {
94340 0 : std::cout << "SgDivideOp :: ";
94341 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
94342 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
94343 : }
94344 : }
94345 : else
94346 : {
94347 0 : std::cout << "SgDivideOp :: " << std::flush;
94348 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
94349 0 : std::cout << " not valid " << std::endl;
94350 : }
94351 : }
94352 :
94353 0 : if ( p_rhs_operand_i != NULL )
94354 : {
94355 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94356 : {
94357 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
94358 : {
94359 0 : std::cout << "SgDivideOp :: ";
94360 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
94361 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
94362 : }
94363 : }
94364 : else
94365 : {
94366 0 : std::cout << "SgDivideOp :: " << std::flush;
94367 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
94368 0 : std::cout << " not valid " << std::endl;
94369 : }
94370 : }
94371 :
94372 0 : if ( p_expression_type != NULL )
94373 : {
94374 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94375 : {
94376 0 : if ( p_expression_type->isInMemoryPool() == false )
94377 : {
94378 0 : std::cout << "SgDivideOp :: ";
94379 0 : std::cout << " p_expression_type is not in memory pool of ";
94380 0 : std::cout << p_expression_type->class_name() << std::endl;
94381 : }
94382 : }
94383 : else
94384 : {
94385 0 : std::cout << "SgDivideOp :: " << std::flush;
94386 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
94387 0 : std::cout << " not valid " << std::endl;
94388 : }
94389 : }
94390 :
94391 0 : if ( p_originalExpressionTree != NULL )
94392 : {
94393 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94394 : {
94395 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
94396 : {
94397 0 : std::cout << "SgDivideOp :: ";
94398 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
94399 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
94400 : }
94401 : }
94402 : else
94403 : {
94404 0 : std::cout << "SgDivideOp :: " << std::flush;
94405 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
94406 0 : std::cout << " not valid " << std::endl;
94407 : }
94408 : }
94409 :
94410 0 : if ( p_operatorPosition != NULL )
94411 : {
94412 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94413 : {
94414 0 : if ( p_operatorPosition->isInMemoryPool() == false )
94415 : {
94416 0 : std::cout << "SgDivideOp :: ";
94417 0 : std::cout << " p_operatorPosition is not in memory pool of ";
94418 0 : std::cout << p_operatorPosition->class_name() << std::endl;
94419 : }
94420 : }
94421 : else
94422 : {
94423 0 : std::cout << "SgDivideOp :: " << std::flush;
94424 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
94425 0 : std::cout << " not valid " << std::endl;
94426 : }
94427 : }
94428 :
94429 0 : if ( p_startOfConstruct != NULL )
94430 : {
94431 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94432 : {
94433 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
94434 : {
94435 0 : std::cout << "SgDivideOp :: ";
94436 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
94437 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
94438 : }
94439 : }
94440 : else
94441 : {
94442 0 : std::cout << "SgDivideOp :: " << std::flush;
94443 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
94444 0 : std::cout << " not valid " << std::endl;
94445 : }
94446 : }
94447 :
94448 0 : if ( p_endOfConstruct != NULL )
94449 : {
94450 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94451 : {
94452 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
94453 : {
94454 0 : std::cout << "SgDivideOp :: ";
94455 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
94456 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
94457 : }
94458 : }
94459 : else
94460 : {
94461 0 : std::cout << "SgDivideOp :: " << std::flush;
94462 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
94463 0 : std::cout << " not valid " << std::endl;
94464 : }
94465 : }
94466 :
94467 0 : if ( p_parent != NULL )
94468 : {
94469 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94470 : {
94471 0 : if ( p_parent->isInMemoryPool() == false )
94472 : {
94473 0 : std::cout << "SgDivideOp :: ";
94474 0 : std::cout << " p_parent is not in memory pool of ";
94475 0 : std::cout << p_parent->class_name() << std::endl;
94476 : }
94477 : }
94478 : else
94479 : {
94480 0 : std::cout << "SgDivideOp :: " << std::flush;
94481 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
94482 0 : std::cout << " not valid " << std::endl;
94483 : }
94484 : }
94485 :
94486 :
94487 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
94488 :
94489 0 : }
94490 :
94491 :
94492 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
94493 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
94494 : bool
94495 0 : SgDivideOp::isInMemoryPool ()
94496 : {
94497 0 : typedef unsigned char* TestType;
94498 :
94499 0 : bool found = false;
94500 :
94501 0 : ROSE_ASSERT(this != NULL);
94502 :
94503 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
94504 :
94505 0 : TestType tested = (TestType) ( this ) ;
94506 :
94507 0 : std::vector < unsigned char* > :: const_iterator block = SgDivideOp::pools.begin();
94508 :
94509 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
94510 : // while (found == false && block < Memory_Block_List.end())
94511 0 : while ( (found == false) && (block != SgDivideOp::pools.end()) )
94512 : {
94513 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDivideOp::pool_size * sizeof(SgDivideOp) ) ) ;
94514 0 : ++block;
94515 : }
94516 :
94517 : // Special handling for static data
94518 :
94519 :
94520 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
94521 0 : ROSE_ASSERT(found == true);
94522 :
94523 0 : return found;
94524 : }
94525 : /* #line 94526 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
94526 :
94527 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
94528 :
94529 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
94530 :
94531 : /* #line 94532 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
94532 :
94533 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
94534 :
94535 : void
94536 0 : SgIntegerDivideOp::checkDataMemberPointersIfInMemoryPool()
94537 : {
94538 : // ------------ checking pointers of SgIntegerDivideOp -------------------
94539 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
94540 :
94541 0 : if ( p_lhs_operand_i != NULL )
94542 : {
94543 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94544 : {
94545 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
94546 : {
94547 0 : std::cout << "SgIntegerDivideOp :: ";
94548 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
94549 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
94550 : }
94551 : }
94552 : else
94553 : {
94554 0 : std::cout << "SgIntegerDivideOp :: " << std::flush;
94555 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
94556 0 : std::cout << " not valid " << std::endl;
94557 : }
94558 : }
94559 :
94560 0 : if ( p_rhs_operand_i != NULL )
94561 : {
94562 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94563 : {
94564 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
94565 : {
94566 0 : std::cout << "SgIntegerDivideOp :: ";
94567 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
94568 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
94569 : }
94570 : }
94571 : else
94572 : {
94573 0 : std::cout << "SgIntegerDivideOp :: " << std::flush;
94574 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
94575 0 : std::cout << " not valid " << std::endl;
94576 : }
94577 : }
94578 :
94579 0 : if ( p_expression_type != NULL )
94580 : {
94581 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94582 : {
94583 0 : if ( p_expression_type->isInMemoryPool() == false )
94584 : {
94585 0 : std::cout << "SgIntegerDivideOp :: ";
94586 0 : std::cout << " p_expression_type is not in memory pool of ";
94587 0 : std::cout << p_expression_type->class_name() << std::endl;
94588 : }
94589 : }
94590 : else
94591 : {
94592 0 : std::cout << "SgIntegerDivideOp :: " << std::flush;
94593 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
94594 0 : std::cout << " not valid " << std::endl;
94595 : }
94596 : }
94597 :
94598 0 : if ( p_originalExpressionTree != NULL )
94599 : {
94600 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94601 : {
94602 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
94603 : {
94604 0 : std::cout << "SgIntegerDivideOp :: ";
94605 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
94606 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
94607 : }
94608 : }
94609 : else
94610 : {
94611 0 : std::cout << "SgIntegerDivideOp :: " << std::flush;
94612 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
94613 0 : std::cout << " not valid " << std::endl;
94614 : }
94615 : }
94616 :
94617 0 : if ( p_operatorPosition != NULL )
94618 : {
94619 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94620 : {
94621 0 : if ( p_operatorPosition->isInMemoryPool() == false )
94622 : {
94623 0 : std::cout << "SgIntegerDivideOp :: ";
94624 0 : std::cout << " p_operatorPosition is not in memory pool of ";
94625 0 : std::cout << p_operatorPosition->class_name() << std::endl;
94626 : }
94627 : }
94628 : else
94629 : {
94630 0 : std::cout << "SgIntegerDivideOp :: " << std::flush;
94631 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
94632 0 : std::cout << " not valid " << std::endl;
94633 : }
94634 : }
94635 :
94636 0 : if ( p_startOfConstruct != NULL )
94637 : {
94638 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94639 : {
94640 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
94641 : {
94642 0 : std::cout << "SgIntegerDivideOp :: ";
94643 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
94644 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
94645 : }
94646 : }
94647 : else
94648 : {
94649 0 : std::cout << "SgIntegerDivideOp :: " << std::flush;
94650 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
94651 0 : std::cout << " not valid " << std::endl;
94652 : }
94653 : }
94654 :
94655 0 : if ( p_endOfConstruct != NULL )
94656 : {
94657 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94658 : {
94659 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
94660 : {
94661 0 : std::cout << "SgIntegerDivideOp :: ";
94662 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
94663 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
94664 : }
94665 : }
94666 : else
94667 : {
94668 0 : std::cout << "SgIntegerDivideOp :: " << std::flush;
94669 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
94670 0 : std::cout << " not valid " << std::endl;
94671 : }
94672 : }
94673 :
94674 0 : if ( p_parent != NULL )
94675 : {
94676 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94677 : {
94678 0 : if ( p_parent->isInMemoryPool() == false )
94679 : {
94680 0 : std::cout << "SgIntegerDivideOp :: ";
94681 0 : std::cout << " p_parent is not in memory pool of ";
94682 0 : std::cout << p_parent->class_name() << std::endl;
94683 : }
94684 : }
94685 : else
94686 : {
94687 0 : std::cout << "SgIntegerDivideOp :: " << std::flush;
94688 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
94689 0 : std::cout << " not valid " << std::endl;
94690 : }
94691 : }
94692 :
94693 :
94694 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
94695 :
94696 0 : }
94697 :
94698 :
94699 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
94700 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
94701 : bool
94702 0 : SgIntegerDivideOp::isInMemoryPool ()
94703 : {
94704 0 : typedef unsigned char* TestType;
94705 :
94706 0 : bool found = false;
94707 :
94708 0 : ROSE_ASSERT(this != NULL);
94709 :
94710 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
94711 :
94712 0 : TestType tested = (TestType) ( this ) ;
94713 :
94714 0 : std::vector < unsigned char* > :: const_iterator block = SgIntegerDivideOp::pools.begin();
94715 :
94716 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
94717 : // while (found == false && block < Memory_Block_List.end())
94718 0 : while ( (found == false) && (block != SgIntegerDivideOp::pools.end()) )
94719 : {
94720 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIntegerDivideOp::pool_size * sizeof(SgIntegerDivideOp) ) ) ;
94721 0 : ++block;
94722 : }
94723 :
94724 : // Special handling for static data
94725 :
94726 :
94727 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
94728 0 : ROSE_ASSERT(found == true);
94729 :
94730 0 : return found;
94731 : }
94732 : /* #line 94733 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
94733 :
94734 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
94735 :
94736 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
94737 :
94738 : /* #line 94739 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
94739 :
94740 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
94741 :
94742 : void
94743 0 : SgModOp::checkDataMemberPointersIfInMemoryPool()
94744 : {
94745 : // ------------ checking pointers of SgModOp -------------------
94746 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
94747 :
94748 0 : if ( p_lhs_operand_i != NULL )
94749 : {
94750 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94751 : {
94752 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
94753 : {
94754 0 : std::cout << "SgModOp :: ";
94755 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
94756 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
94757 : }
94758 : }
94759 : else
94760 : {
94761 0 : std::cout << "SgModOp :: " << std::flush;
94762 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
94763 0 : std::cout << " not valid " << std::endl;
94764 : }
94765 : }
94766 :
94767 0 : if ( p_rhs_operand_i != NULL )
94768 : {
94769 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94770 : {
94771 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
94772 : {
94773 0 : std::cout << "SgModOp :: ";
94774 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
94775 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
94776 : }
94777 : }
94778 : else
94779 : {
94780 0 : std::cout << "SgModOp :: " << std::flush;
94781 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
94782 0 : std::cout << " not valid " << std::endl;
94783 : }
94784 : }
94785 :
94786 0 : if ( p_expression_type != NULL )
94787 : {
94788 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94789 : {
94790 0 : if ( p_expression_type->isInMemoryPool() == false )
94791 : {
94792 0 : std::cout << "SgModOp :: ";
94793 0 : std::cout << " p_expression_type is not in memory pool of ";
94794 0 : std::cout << p_expression_type->class_name() << std::endl;
94795 : }
94796 : }
94797 : else
94798 : {
94799 0 : std::cout << "SgModOp :: " << std::flush;
94800 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
94801 0 : std::cout << " not valid " << std::endl;
94802 : }
94803 : }
94804 :
94805 0 : if ( p_originalExpressionTree != NULL )
94806 : {
94807 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94808 : {
94809 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
94810 : {
94811 0 : std::cout << "SgModOp :: ";
94812 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
94813 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
94814 : }
94815 : }
94816 : else
94817 : {
94818 0 : std::cout << "SgModOp :: " << std::flush;
94819 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
94820 0 : std::cout << " not valid " << std::endl;
94821 : }
94822 : }
94823 :
94824 0 : if ( p_operatorPosition != NULL )
94825 : {
94826 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94827 : {
94828 0 : if ( p_operatorPosition->isInMemoryPool() == false )
94829 : {
94830 0 : std::cout << "SgModOp :: ";
94831 0 : std::cout << " p_operatorPosition is not in memory pool of ";
94832 0 : std::cout << p_operatorPosition->class_name() << std::endl;
94833 : }
94834 : }
94835 : else
94836 : {
94837 0 : std::cout << "SgModOp :: " << std::flush;
94838 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
94839 0 : std::cout << " not valid " << std::endl;
94840 : }
94841 : }
94842 :
94843 0 : if ( p_startOfConstruct != NULL )
94844 : {
94845 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94846 : {
94847 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
94848 : {
94849 0 : std::cout << "SgModOp :: ";
94850 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
94851 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
94852 : }
94853 : }
94854 : else
94855 : {
94856 0 : std::cout << "SgModOp :: " << std::flush;
94857 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
94858 0 : std::cout << " not valid " << std::endl;
94859 : }
94860 : }
94861 :
94862 0 : if ( p_endOfConstruct != NULL )
94863 : {
94864 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94865 : {
94866 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
94867 : {
94868 0 : std::cout << "SgModOp :: ";
94869 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
94870 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
94871 : }
94872 : }
94873 : else
94874 : {
94875 0 : std::cout << "SgModOp :: " << std::flush;
94876 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
94877 0 : std::cout << " not valid " << std::endl;
94878 : }
94879 : }
94880 :
94881 0 : if ( p_parent != NULL )
94882 : {
94883 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94884 : {
94885 0 : if ( p_parent->isInMemoryPool() == false )
94886 : {
94887 0 : std::cout << "SgModOp :: ";
94888 0 : std::cout << " p_parent is not in memory pool of ";
94889 0 : std::cout << p_parent->class_name() << std::endl;
94890 : }
94891 : }
94892 : else
94893 : {
94894 0 : std::cout << "SgModOp :: " << std::flush;
94895 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
94896 0 : std::cout << " not valid " << std::endl;
94897 : }
94898 : }
94899 :
94900 :
94901 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
94902 :
94903 0 : }
94904 :
94905 :
94906 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
94907 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
94908 : bool
94909 0 : SgModOp::isInMemoryPool ()
94910 : {
94911 0 : typedef unsigned char* TestType;
94912 :
94913 0 : bool found = false;
94914 :
94915 0 : ROSE_ASSERT(this != NULL);
94916 :
94917 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
94918 :
94919 0 : TestType tested = (TestType) ( this ) ;
94920 :
94921 0 : std::vector < unsigned char* > :: const_iterator block = SgModOp::pools.begin();
94922 :
94923 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
94924 : // while (found == false && block < Memory_Block_List.end())
94925 0 : while ( (found == false) && (block != SgModOp::pools.end()) )
94926 : {
94927 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgModOp::pool_size * sizeof(SgModOp) ) ) ;
94928 0 : ++block;
94929 : }
94930 :
94931 : // Special handling for static data
94932 :
94933 :
94934 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
94935 0 : ROSE_ASSERT(found == true);
94936 :
94937 0 : return found;
94938 : }
94939 : /* #line 94940 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
94940 :
94941 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
94942 :
94943 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
94944 :
94945 : /* #line 94946 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
94946 :
94947 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
94948 :
94949 : void
94950 0 : SgAndOp::checkDataMemberPointersIfInMemoryPool()
94951 : {
94952 : // ------------ checking pointers of SgAndOp -------------------
94953 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
94954 :
94955 0 : if ( p_lhs_operand_i != NULL )
94956 : {
94957 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94958 : {
94959 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
94960 : {
94961 0 : std::cout << "SgAndOp :: ";
94962 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
94963 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
94964 : }
94965 : }
94966 : else
94967 : {
94968 0 : std::cout << "SgAndOp :: " << std::flush;
94969 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
94970 0 : std::cout << " not valid " << std::endl;
94971 : }
94972 : }
94973 :
94974 0 : if ( p_rhs_operand_i != NULL )
94975 : {
94976 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94977 : {
94978 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
94979 : {
94980 0 : std::cout << "SgAndOp :: ";
94981 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
94982 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
94983 : }
94984 : }
94985 : else
94986 : {
94987 0 : std::cout << "SgAndOp :: " << std::flush;
94988 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
94989 0 : std::cout << " not valid " << std::endl;
94990 : }
94991 : }
94992 :
94993 0 : if ( p_expression_type != NULL )
94994 : {
94995 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
94996 : {
94997 0 : if ( p_expression_type->isInMemoryPool() == false )
94998 : {
94999 0 : std::cout << "SgAndOp :: ";
95000 0 : std::cout << " p_expression_type is not in memory pool of ";
95001 0 : std::cout << p_expression_type->class_name() << std::endl;
95002 : }
95003 : }
95004 : else
95005 : {
95006 0 : std::cout << "SgAndOp :: " << std::flush;
95007 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
95008 0 : std::cout << " not valid " << std::endl;
95009 : }
95010 : }
95011 :
95012 0 : if ( p_originalExpressionTree != NULL )
95013 : {
95014 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95015 : {
95016 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
95017 : {
95018 0 : std::cout << "SgAndOp :: ";
95019 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
95020 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
95021 : }
95022 : }
95023 : else
95024 : {
95025 0 : std::cout << "SgAndOp :: " << std::flush;
95026 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
95027 0 : std::cout << " not valid " << std::endl;
95028 : }
95029 : }
95030 :
95031 0 : if ( p_operatorPosition != NULL )
95032 : {
95033 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95034 : {
95035 0 : if ( p_operatorPosition->isInMemoryPool() == false )
95036 : {
95037 0 : std::cout << "SgAndOp :: ";
95038 0 : std::cout << " p_operatorPosition is not in memory pool of ";
95039 0 : std::cout << p_operatorPosition->class_name() << std::endl;
95040 : }
95041 : }
95042 : else
95043 : {
95044 0 : std::cout << "SgAndOp :: " << std::flush;
95045 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
95046 0 : std::cout << " not valid " << std::endl;
95047 : }
95048 : }
95049 :
95050 0 : if ( p_startOfConstruct != NULL )
95051 : {
95052 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95053 : {
95054 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
95055 : {
95056 0 : std::cout << "SgAndOp :: ";
95057 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
95058 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
95059 : }
95060 : }
95061 : else
95062 : {
95063 0 : std::cout << "SgAndOp :: " << std::flush;
95064 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
95065 0 : std::cout << " not valid " << std::endl;
95066 : }
95067 : }
95068 :
95069 0 : if ( p_endOfConstruct != NULL )
95070 : {
95071 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95072 : {
95073 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
95074 : {
95075 0 : std::cout << "SgAndOp :: ";
95076 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
95077 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
95078 : }
95079 : }
95080 : else
95081 : {
95082 0 : std::cout << "SgAndOp :: " << std::flush;
95083 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
95084 0 : std::cout << " not valid " << std::endl;
95085 : }
95086 : }
95087 :
95088 0 : if ( p_parent != NULL )
95089 : {
95090 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95091 : {
95092 0 : if ( p_parent->isInMemoryPool() == false )
95093 : {
95094 0 : std::cout << "SgAndOp :: ";
95095 0 : std::cout << " p_parent is not in memory pool of ";
95096 0 : std::cout << p_parent->class_name() << std::endl;
95097 : }
95098 : }
95099 : else
95100 : {
95101 0 : std::cout << "SgAndOp :: " << std::flush;
95102 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
95103 0 : std::cout << " not valid " << std::endl;
95104 : }
95105 : }
95106 :
95107 :
95108 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
95109 :
95110 0 : }
95111 :
95112 :
95113 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
95114 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
95115 : bool
95116 0 : SgAndOp::isInMemoryPool ()
95117 : {
95118 0 : typedef unsigned char* TestType;
95119 :
95120 0 : bool found = false;
95121 :
95122 0 : ROSE_ASSERT(this != NULL);
95123 :
95124 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
95125 :
95126 0 : TestType tested = (TestType) ( this ) ;
95127 :
95128 0 : std::vector < unsigned char* > :: const_iterator block = SgAndOp::pools.begin();
95129 :
95130 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
95131 : // while (found == false && block < Memory_Block_List.end())
95132 0 : while ( (found == false) && (block != SgAndOp::pools.end()) )
95133 : {
95134 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAndOp::pool_size * sizeof(SgAndOp) ) ) ;
95135 0 : ++block;
95136 : }
95137 :
95138 : // Special handling for static data
95139 :
95140 :
95141 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
95142 0 : ROSE_ASSERT(found == true);
95143 :
95144 0 : return found;
95145 : }
95146 : /* #line 95147 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
95147 :
95148 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
95149 :
95150 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
95151 :
95152 : /* #line 95153 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
95153 :
95154 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
95155 :
95156 : void
95157 0 : SgOrOp::checkDataMemberPointersIfInMemoryPool()
95158 : {
95159 : // ------------ checking pointers of SgOrOp -------------------
95160 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
95161 :
95162 0 : if ( p_lhs_operand_i != NULL )
95163 : {
95164 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95165 : {
95166 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
95167 : {
95168 0 : std::cout << "SgOrOp :: ";
95169 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
95170 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
95171 : }
95172 : }
95173 : else
95174 : {
95175 0 : std::cout << "SgOrOp :: " << std::flush;
95176 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
95177 0 : std::cout << " not valid " << std::endl;
95178 : }
95179 : }
95180 :
95181 0 : if ( p_rhs_operand_i != NULL )
95182 : {
95183 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95184 : {
95185 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
95186 : {
95187 0 : std::cout << "SgOrOp :: ";
95188 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
95189 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
95190 : }
95191 : }
95192 : else
95193 : {
95194 0 : std::cout << "SgOrOp :: " << std::flush;
95195 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
95196 0 : std::cout << " not valid " << std::endl;
95197 : }
95198 : }
95199 :
95200 0 : if ( p_expression_type != NULL )
95201 : {
95202 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95203 : {
95204 0 : if ( p_expression_type->isInMemoryPool() == false )
95205 : {
95206 0 : std::cout << "SgOrOp :: ";
95207 0 : std::cout << " p_expression_type is not in memory pool of ";
95208 0 : std::cout << p_expression_type->class_name() << std::endl;
95209 : }
95210 : }
95211 : else
95212 : {
95213 0 : std::cout << "SgOrOp :: " << std::flush;
95214 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
95215 0 : std::cout << " not valid " << std::endl;
95216 : }
95217 : }
95218 :
95219 0 : if ( p_originalExpressionTree != NULL )
95220 : {
95221 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95222 : {
95223 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
95224 : {
95225 0 : std::cout << "SgOrOp :: ";
95226 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
95227 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
95228 : }
95229 : }
95230 : else
95231 : {
95232 0 : std::cout << "SgOrOp :: " << std::flush;
95233 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
95234 0 : std::cout << " not valid " << std::endl;
95235 : }
95236 : }
95237 :
95238 0 : if ( p_operatorPosition != NULL )
95239 : {
95240 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95241 : {
95242 0 : if ( p_operatorPosition->isInMemoryPool() == false )
95243 : {
95244 0 : std::cout << "SgOrOp :: ";
95245 0 : std::cout << " p_operatorPosition is not in memory pool of ";
95246 0 : std::cout << p_operatorPosition->class_name() << std::endl;
95247 : }
95248 : }
95249 : else
95250 : {
95251 0 : std::cout << "SgOrOp :: " << std::flush;
95252 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
95253 0 : std::cout << " not valid " << std::endl;
95254 : }
95255 : }
95256 :
95257 0 : if ( p_startOfConstruct != NULL )
95258 : {
95259 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95260 : {
95261 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
95262 : {
95263 0 : std::cout << "SgOrOp :: ";
95264 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
95265 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
95266 : }
95267 : }
95268 : else
95269 : {
95270 0 : std::cout << "SgOrOp :: " << std::flush;
95271 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
95272 0 : std::cout << " not valid " << std::endl;
95273 : }
95274 : }
95275 :
95276 0 : if ( p_endOfConstruct != NULL )
95277 : {
95278 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95279 : {
95280 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
95281 : {
95282 0 : std::cout << "SgOrOp :: ";
95283 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
95284 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
95285 : }
95286 : }
95287 : else
95288 : {
95289 0 : std::cout << "SgOrOp :: " << std::flush;
95290 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
95291 0 : std::cout << " not valid " << std::endl;
95292 : }
95293 : }
95294 :
95295 0 : if ( p_parent != NULL )
95296 : {
95297 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95298 : {
95299 0 : if ( p_parent->isInMemoryPool() == false )
95300 : {
95301 0 : std::cout << "SgOrOp :: ";
95302 0 : std::cout << " p_parent is not in memory pool of ";
95303 0 : std::cout << p_parent->class_name() << std::endl;
95304 : }
95305 : }
95306 : else
95307 : {
95308 0 : std::cout << "SgOrOp :: " << std::flush;
95309 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
95310 0 : std::cout << " not valid " << std::endl;
95311 : }
95312 : }
95313 :
95314 :
95315 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
95316 :
95317 0 : }
95318 :
95319 :
95320 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
95321 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
95322 : bool
95323 0 : SgOrOp::isInMemoryPool ()
95324 : {
95325 0 : typedef unsigned char* TestType;
95326 :
95327 0 : bool found = false;
95328 :
95329 0 : ROSE_ASSERT(this != NULL);
95330 :
95331 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
95332 :
95333 0 : TestType tested = (TestType) ( this ) ;
95334 :
95335 0 : std::vector < unsigned char* > :: const_iterator block = SgOrOp::pools.begin();
95336 :
95337 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
95338 : // while (found == false && block < Memory_Block_List.end())
95339 0 : while ( (found == false) && (block != SgOrOp::pools.end()) )
95340 : {
95341 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgOrOp::pool_size * sizeof(SgOrOp) ) ) ;
95342 0 : ++block;
95343 : }
95344 :
95345 : // Special handling for static data
95346 :
95347 :
95348 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
95349 0 : ROSE_ASSERT(found == true);
95350 :
95351 0 : return found;
95352 : }
95353 : /* #line 95354 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
95354 :
95355 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
95356 :
95357 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
95358 :
95359 : /* #line 95360 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
95360 :
95361 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
95362 :
95363 : void
95364 0 : SgBitXorOp::checkDataMemberPointersIfInMemoryPool()
95365 : {
95366 : // ------------ checking pointers of SgBitXorOp -------------------
95367 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
95368 :
95369 0 : if ( p_lhs_operand_i != NULL )
95370 : {
95371 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95372 : {
95373 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
95374 : {
95375 0 : std::cout << "SgBitXorOp :: ";
95376 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
95377 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
95378 : }
95379 : }
95380 : else
95381 : {
95382 0 : std::cout << "SgBitXorOp :: " << std::flush;
95383 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
95384 0 : std::cout << " not valid " << std::endl;
95385 : }
95386 : }
95387 :
95388 0 : if ( p_rhs_operand_i != NULL )
95389 : {
95390 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95391 : {
95392 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
95393 : {
95394 0 : std::cout << "SgBitXorOp :: ";
95395 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
95396 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
95397 : }
95398 : }
95399 : else
95400 : {
95401 0 : std::cout << "SgBitXorOp :: " << std::flush;
95402 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
95403 0 : std::cout << " not valid " << std::endl;
95404 : }
95405 : }
95406 :
95407 0 : if ( p_expression_type != NULL )
95408 : {
95409 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95410 : {
95411 0 : if ( p_expression_type->isInMemoryPool() == false )
95412 : {
95413 0 : std::cout << "SgBitXorOp :: ";
95414 0 : std::cout << " p_expression_type is not in memory pool of ";
95415 0 : std::cout << p_expression_type->class_name() << std::endl;
95416 : }
95417 : }
95418 : else
95419 : {
95420 0 : std::cout << "SgBitXorOp :: " << std::flush;
95421 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
95422 0 : std::cout << " not valid " << std::endl;
95423 : }
95424 : }
95425 :
95426 0 : if ( p_originalExpressionTree != NULL )
95427 : {
95428 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95429 : {
95430 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
95431 : {
95432 0 : std::cout << "SgBitXorOp :: ";
95433 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
95434 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
95435 : }
95436 : }
95437 : else
95438 : {
95439 0 : std::cout << "SgBitXorOp :: " << std::flush;
95440 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
95441 0 : std::cout << " not valid " << std::endl;
95442 : }
95443 : }
95444 :
95445 0 : if ( p_operatorPosition != NULL )
95446 : {
95447 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95448 : {
95449 0 : if ( p_operatorPosition->isInMemoryPool() == false )
95450 : {
95451 0 : std::cout << "SgBitXorOp :: ";
95452 0 : std::cout << " p_operatorPosition is not in memory pool of ";
95453 0 : std::cout << p_operatorPosition->class_name() << std::endl;
95454 : }
95455 : }
95456 : else
95457 : {
95458 0 : std::cout << "SgBitXorOp :: " << std::flush;
95459 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
95460 0 : std::cout << " not valid " << std::endl;
95461 : }
95462 : }
95463 :
95464 0 : if ( p_startOfConstruct != NULL )
95465 : {
95466 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95467 : {
95468 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
95469 : {
95470 0 : std::cout << "SgBitXorOp :: ";
95471 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
95472 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
95473 : }
95474 : }
95475 : else
95476 : {
95477 0 : std::cout << "SgBitXorOp :: " << std::flush;
95478 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
95479 0 : std::cout << " not valid " << std::endl;
95480 : }
95481 : }
95482 :
95483 0 : if ( p_endOfConstruct != NULL )
95484 : {
95485 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95486 : {
95487 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
95488 : {
95489 0 : std::cout << "SgBitXorOp :: ";
95490 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
95491 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
95492 : }
95493 : }
95494 : else
95495 : {
95496 0 : std::cout << "SgBitXorOp :: " << std::flush;
95497 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
95498 0 : std::cout << " not valid " << std::endl;
95499 : }
95500 : }
95501 :
95502 0 : if ( p_parent != NULL )
95503 : {
95504 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95505 : {
95506 0 : if ( p_parent->isInMemoryPool() == false )
95507 : {
95508 0 : std::cout << "SgBitXorOp :: ";
95509 0 : std::cout << " p_parent is not in memory pool of ";
95510 0 : std::cout << p_parent->class_name() << std::endl;
95511 : }
95512 : }
95513 : else
95514 : {
95515 0 : std::cout << "SgBitXorOp :: " << std::flush;
95516 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
95517 0 : std::cout << " not valid " << std::endl;
95518 : }
95519 : }
95520 :
95521 :
95522 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
95523 :
95524 0 : }
95525 :
95526 :
95527 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
95528 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
95529 : bool
95530 0 : SgBitXorOp::isInMemoryPool ()
95531 : {
95532 0 : typedef unsigned char* TestType;
95533 :
95534 0 : bool found = false;
95535 :
95536 0 : ROSE_ASSERT(this != NULL);
95537 :
95538 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
95539 :
95540 0 : TestType tested = (TestType) ( this ) ;
95541 :
95542 0 : std::vector < unsigned char* > :: const_iterator block = SgBitXorOp::pools.begin();
95543 :
95544 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
95545 : // while (found == false && block < Memory_Block_List.end())
95546 0 : while ( (found == false) && (block != SgBitXorOp::pools.end()) )
95547 : {
95548 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgBitXorOp::pool_size * sizeof(SgBitXorOp) ) ) ;
95549 0 : ++block;
95550 : }
95551 :
95552 : // Special handling for static data
95553 :
95554 :
95555 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
95556 0 : ROSE_ASSERT(found == true);
95557 :
95558 0 : return found;
95559 : }
95560 : /* #line 95561 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
95561 :
95562 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
95563 :
95564 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
95565 :
95566 : /* #line 95567 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
95567 :
95568 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
95569 :
95570 : void
95571 0 : SgBitAndOp::checkDataMemberPointersIfInMemoryPool()
95572 : {
95573 : // ------------ checking pointers of SgBitAndOp -------------------
95574 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
95575 :
95576 0 : if ( p_lhs_operand_i != NULL )
95577 : {
95578 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95579 : {
95580 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
95581 : {
95582 0 : std::cout << "SgBitAndOp :: ";
95583 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
95584 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
95585 : }
95586 : }
95587 : else
95588 : {
95589 0 : std::cout << "SgBitAndOp :: " << std::flush;
95590 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
95591 0 : std::cout << " not valid " << std::endl;
95592 : }
95593 : }
95594 :
95595 0 : if ( p_rhs_operand_i != NULL )
95596 : {
95597 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95598 : {
95599 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
95600 : {
95601 0 : std::cout << "SgBitAndOp :: ";
95602 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
95603 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
95604 : }
95605 : }
95606 : else
95607 : {
95608 0 : std::cout << "SgBitAndOp :: " << std::flush;
95609 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
95610 0 : std::cout << " not valid " << std::endl;
95611 : }
95612 : }
95613 :
95614 0 : if ( p_expression_type != NULL )
95615 : {
95616 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95617 : {
95618 0 : if ( p_expression_type->isInMemoryPool() == false )
95619 : {
95620 0 : std::cout << "SgBitAndOp :: ";
95621 0 : std::cout << " p_expression_type is not in memory pool of ";
95622 0 : std::cout << p_expression_type->class_name() << std::endl;
95623 : }
95624 : }
95625 : else
95626 : {
95627 0 : std::cout << "SgBitAndOp :: " << std::flush;
95628 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
95629 0 : std::cout << " not valid " << std::endl;
95630 : }
95631 : }
95632 :
95633 0 : if ( p_originalExpressionTree != NULL )
95634 : {
95635 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95636 : {
95637 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
95638 : {
95639 0 : std::cout << "SgBitAndOp :: ";
95640 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
95641 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
95642 : }
95643 : }
95644 : else
95645 : {
95646 0 : std::cout << "SgBitAndOp :: " << std::flush;
95647 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
95648 0 : std::cout << " not valid " << std::endl;
95649 : }
95650 : }
95651 :
95652 0 : if ( p_operatorPosition != NULL )
95653 : {
95654 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95655 : {
95656 0 : if ( p_operatorPosition->isInMemoryPool() == false )
95657 : {
95658 0 : std::cout << "SgBitAndOp :: ";
95659 0 : std::cout << " p_operatorPosition is not in memory pool of ";
95660 0 : std::cout << p_operatorPosition->class_name() << std::endl;
95661 : }
95662 : }
95663 : else
95664 : {
95665 0 : std::cout << "SgBitAndOp :: " << std::flush;
95666 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
95667 0 : std::cout << " not valid " << std::endl;
95668 : }
95669 : }
95670 :
95671 0 : if ( p_startOfConstruct != NULL )
95672 : {
95673 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95674 : {
95675 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
95676 : {
95677 0 : std::cout << "SgBitAndOp :: ";
95678 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
95679 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
95680 : }
95681 : }
95682 : else
95683 : {
95684 0 : std::cout << "SgBitAndOp :: " << std::flush;
95685 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
95686 0 : std::cout << " not valid " << std::endl;
95687 : }
95688 : }
95689 :
95690 0 : if ( p_endOfConstruct != NULL )
95691 : {
95692 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95693 : {
95694 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
95695 : {
95696 0 : std::cout << "SgBitAndOp :: ";
95697 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
95698 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
95699 : }
95700 : }
95701 : else
95702 : {
95703 0 : std::cout << "SgBitAndOp :: " << std::flush;
95704 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
95705 0 : std::cout << " not valid " << std::endl;
95706 : }
95707 : }
95708 :
95709 0 : if ( p_parent != NULL )
95710 : {
95711 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95712 : {
95713 0 : if ( p_parent->isInMemoryPool() == false )
95714 : {
95715 0 : std::cout << "SgBitAndOp :: ";
95716 0 : std::cout << " p_parent is not in memory pool of ";
95717 0 : std::cout << p_parent->class_name() << std::endl;
95718 : }
95719 : }
95720 : else
95721 : {
95722 0 : std::cout << "SgBitAndOp :: " << std::flush;
95723 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
95724 0 : std::cout << " not valid " << std::endl;
95725 : }
95726 : }
95727 :
95728 :
95729 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
95730 :
95731 0 : }
95732 :
95733 :
95734 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
95735 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
95736 : bool
95737 0 : SgBitAndOp::isInMemoryPool ()
95738 : {
95739 0 : typedef unsigned char* TestType;
95740 :
95741 0 : bool found = false;
95742 :
95743 0 : ROSE_ASSERT(this != NULL);
95744 :
95745 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
95746 :
95747 0 : TestType tested = (TestType) ( this ) ;
95748 :
95749 0 : std::vector < unsigned char* > :: const_iterator block = SgBitAndOp::pools.begin();
95750 :
95751 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
95752 : // while (found == false && block < Memory_Block_List.end())
95753 0 : while ( (found == false) && (block != SgBitAndOp::pools.end()) )
95754 : {
95755 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgBitAndOp::pool_size * sizeof(SgBitAndOp) ) ) ;
95756 0 : ++block;
95757 : }
95758 :
95759 : // Special handling for static data
95760 :
95761 :
95762 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
95763 0 : ROSE_ASSERT(found == true);
95764 :
95765 0 : return found;
95766 : }
95767 : /* #line 95768 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
95768 :
95769 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
95770 :
95771 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
95772 :
95773 : /* #line 95774 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
95774 :
95775 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
95776 :
95777 : void
95778 0 : SgBitOrOp::checkDataMemberPointersIfInMemoryPool()
95779 : {
95780 : // ------------ checking pointers of SgBitOrOp -------------------
95781 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
95782 :
95783 0 : if ( p_lhs_operand_i != NULL )
95784 : {
95785 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95786 : {
95787 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
95788 : {
95789 0 : std::cout << "SgBitOrOp :: ";
95790 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
95791 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
95792 : }
95793 : }
95794 : else
95795 : {
95796 0 : std::cout << "SgBitOrOp :: " << std::flush;
95797 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
95798 0 : std::cout << " not valid " << std::endl;
95799 : }
95800 : }
95801 :
95802 0 : if ( p_rhs_operand_i != NULL )
95803 : {
95804 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95805 : {
95806 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
95807 : {
95808 0 : std::cout << "SgBitOrOp :: ";
95809 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
95810 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
95811 : }
95812 : }
95813 : else
95814 : {
95815 0 : std::cout << "SgBitOrOp :: " << std::flush;
95816 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
95817 0 : std::cout << " not valid " << std::endl;
95818 : }
95819 : }
95820 :
95821 0 : if ( p_expression_type != NULL )
95822 : {
95823 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95824 : {
95825 0 : if ( p_expression_type->isInMemoryPool() == false )
95826 : {
95827 0 : std::cout << "SgBitOrOp :: ";
95828 0 : std::cout << " p_expression_type is not in memory pool of ";
95829 0 : std::cout << p_expression_type->class_name() << std::endl;
95830 : }
95831 : }
95832 : else
95833 : {
95834 0 : std::cout << "SgBitOrOp :: " << std::flush;
95835 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
95836 0 : std::cout << " not valid " << std::endl;
95837 : }
95838 : }
95839 :
95840 0 : if ( p_originalExpressionTree != NULL )
95841 : {
95842 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95843 : {
95844 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
95845 : {
95846 0 : std::cout << "SgBitOrOp :: ";
95847 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
95848 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
95849 : }
95850 : }
95851 : else
95852 : {
95853 0 : std::cout << "SgBitOrOp :: " << std::flush;
95854 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
95855 0 : std::cout << " not valid " << std::endl;
95856 : }
95857 : }
95858 :
95859 0 : if ( p_operatorPosition != NULL )
95860 : {
95861 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95862 : {
95863 0 : if ( p_operatorPosition->isInMemoryPool() == false )
95864 : {
95865 0 : std::cout << "SgBitOrOp :: ";
95866 0 : std::cout << " p_operatorPosition is not in memory pool of ";
95867 0 : std::cout << p_operatorPosition->class_name() << std::endl;
95868 : }
95869 : }
95870 : else
95871 : {
95872 0 : std::cout << "SgBitOrOp :: " << std::flush;
95873 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
95874 0 : std::cout << " not valid " << std::endl;
95875 : }
95876 : }
95877 :
95878 0 : if ( p_startOfConstruct != NULL )
95879 : {
95880 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95881 : {
95882 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
95883 : {
95884 0 : std::cout << "SgBitOrOp :: ";
95885 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
95886 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
95887 : }
95888 : }
95889 : else
95890 : {
95891 0 : std::cout << "SgBitOrOp :: " << std::flush;
95892 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
95893 0 : std::cout << " not valid " << std::endl;
95894 : }
95895 : }
95896 :
95897 0 : if ( p_endOfConstruct != NULL )
95898 : {
95899 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95900 : {
95901 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
95902 : {
95903 0 : std::cout << "SgBitOrOp :: ";
95904 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
95905 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
95906 : }
95907 : }
95908 : else
95909 : {
95910 0 : std::cout << "SgBitOrOp :: " << std::flush;
95911 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
95912 0 : std::cout << " not valid " << std::endl;
95913 : }
95914 : }
95915 :
95916 0 : if ( p_parent != NULL )
95917 : {
95918 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95919 : {
95920 0 : if ( p_parent->isInMemoryPool() == false )
95921 : {
95922 0 : std::cout << "SgBitOrOp :: ";
95923 0 : std::cout << " p_parent is not in memory pool of ";
95924 0 : std::cout << p_parent->class_name() << std::endl;
95925 : }
95926 : }
95927 : else
95928 : {
95929 0 : std::cout << "SgBitOrOp :: " << std::flush;
95930 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
95931 0 : std::cout << " not valid " << std::endl;
95932 : }
95933 : }
95934 :
95935 :
95936 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
95937 :
95938 0 : }
95939 :
95940 :
95941 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
95942 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
95943 : bool
95944 0 : SgBitOrOp::isInMemoryPool ()
95945 : {
95946 0 : typedef unsigned char* TestType;
95947 :
95948 0 : bool found = false;
95949 :
95950 0 : ROSE_ASSERT(this != NULL);
95951 :
95952 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
95953 :
95954 0 : TestType tested = (TestType) ( this ) ;
95955 :
95956 0 : std::vector < unsigned char* > :: const_iterator block = SgBitOrOp::pools.begin();
95957 :
95958 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
95959 : // while (found == false && block < Memory_Block_List.end())
95960 0 : while ( (found == false) && (block != SgBitOrOp::pools.end()) )
95961 : {
95962 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgBitOrOp::pool_size * sizeof(SgBitOrOp) ) ) ;
95963 0 : ++block;
95964 : }
95965 :
95966 : // Special handling for static data
95967 :
95968 :
95969 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
95970 0 : ROSE_ASSERT(found == true);
95971 :
95972 0 : return found;
95973 : }
95974 : /* #line 95975 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
95975 :
95976 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
95977 :
95978 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
95979 :
95980 : /* #line 95981 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
95981 :
95982 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
95983 :
95984 : void
95985 0 : SgBitEqvOp::checkDataMemberPointersIfInMemoryPool()
95986 : {
95987 : // ------------ checking pointers of SgBitEqvOp -------------------
95988 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
95989 :
95990 0 : if ( p_lhs_operand_i != NULL )
95991 : {
95992 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
95993 : {
95994 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
95995 : {
95996 0 : std::cout << "SgBitEqvOp :: ";
95997 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
95998 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
95999 : }
96000 : }
96001 : else
96002 : {
96003 0 : std::cout << "SgBitEqvOp :: " << std::flush;
96004 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
96005 0 : std::cout << " not valid " << std::endl;
96006 : }
96007 : }
96008 :
96009 0 : if ( p_rhs_operand_i != NULL )
96010 : {
96011 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96012 : {
96013 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
96014 : {
96015 0 : std::cout << "SgBitEqvOp :: ";
96016 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
96017 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
96018 : }
96019 : }
96020 : else
96021 : {
96022 0 : std::cout << "SgBitEqvOp :: " << std::flush;
96023 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
96024 0 : std::cout << " not valid " << std::endl;
96025 : }
96026 : }
96027 :
96028 0 : if ( p_expression_type != NULL )
96029 : {
96030 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96031 : {
96032 0 : if ( p_expression_type->isInMemoryPool() == false )
96033 : {
96034 0 : std::cout << "SgBitEqvOp :: ";
96035 0 : std::cout << " p_expression_type is not in memory pool of ";
96036 0 : std::cout << p_expression_type->class_name() << std::endl;
96037 : }
96038 : }
96039 : else
96040 : {
96041 0 : std::cout << "SgBitEqvOp :: " << std::flush;
96042 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
96043 0 : std::cout << " not valid " << std::endl;
96044 : }
96045 : }
96046 :
96047 0 : if ( p_originalExpressionTree != NULL )
96048 : {
96049 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96050 : {
96051 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
96052 : {
96053 0 : std::cout << "SgBitEqvOp :: ";
96054 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
96055 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
96056 : }
96057 : }
96058 : else
96059 : {
96060 0 : std::cout << "SgBitEqvOp :: " << std::flush;
96061 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
96062 0 : std::cout << " not valid " << std::endl;
96063 : }
96064 : }
96065 :
96066 0 : if ( p_operatorPosition != NULL )
96067 : {
96068 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96069 : {
96070 0 : if ( p_operatorPosition->isInMemoryPool() == false )
96071 : {
96072 0 : std::cout << "SgBitEqvOp :: ";
96073 0 : std::cout << " p_operatorPosition is not in memory pool of ";
96074 0 : std::cout << p_operatorPosition->class_name() << std::endl;
96075 : }
96076 : }
96077 : else
96078 : {
96079 0 : std::cout << "SgBitEqvOp :: " << std::flush;
96080 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
96081 0 : std::cout << " not valid " << std::endl;
96082 : }
96083 : }
96084 :
96085 0 : if ( p_startOfConstruct != NULL )
96086 : {
96087 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96088 : {
96089 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
96090 : {
96091 0 : std::cout << "SgBitEqvOp :: ";
96092 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
96093 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
96094 : }
96095 : }
96096 : else
96097 : {
96098 0 : std::cout << "SgBitEqvOp :: " << std::flush;
96099 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
96100 0 : std::cout << " not valid " << std::endl;
96101 : }
96102 : }
96103 :
96104 0 : if ( p_endOfConstruct != NULL )
96105 : {
96106 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96107 : {
96108 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
96109 : {
96110 0 : std::cout << "SgBitEqvOp :: ";
96111 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
96112 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
96113 : }
96114 : }
96115 : else
96116 : {
96117 0 : std::cout << "SgBitEqvOp :: " << std::flush;
96118 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
96119 0 : std::cout << " not valid " << std::endl;
96120 : }
96121 : }
96122 :
96123 0 : if ( p_parent != NULL )
96124 : {
96125 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96126 : {
96127 0 : if ( p_parent->isInMemoryPool() == false )
96128 : {
96129 0 : std::cout << "SgBitEqvOp :: ";
96130 0 : std::cout << " p_parent is not in memory pool of ";
96131 0 : std::cout << p_parent->class_name() << std::endl;
96132 : }
96133 : }
96134 : else
96135 : {
96136 0 : std::cout << "SgBitEqvOp :: " << std::flush;
96137 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
96138 0 : std::cout << " not valid " << std::endl;
96139 : }
96140 : }
96141 :
96142 :
96143 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
96144 :
96145 0 : }
96146 :
96147 :
96148 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
96149 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
96150 : bool
96151 0 : SgBitEqvOp::isInMemoryPool ()
96152 : {
96153 0 : typedef unsigned char* TestType;
96154 :
96155 0 : bool found = false;
96156 :
96157 0 : ROSE_ASSERT(this != NULL);
96158 :
96159 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
96160 :
96161 0 : TestType tested = (TestType) ( this ) ;
96162 :
96163 0 : std::vector < unsigned char* > :: const_iterator block = SgBitEqvOp::pools.begin();
96164 :
96165 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
96166 : // while (found == false && block < Memory_Block_List.end())
96167 0 : while ( (found == false) && (block != SgBitEqvOp::pools.end()) )
96168 : {
96169 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgBitEqvOp::pool_size * sizeof(SgBitEqvOp) ) ) ;
96170 0 : ++block;
96171 : }
96172 :
96173 : // Special handling for static data
96174 :
96175 :
96176 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
96177 0 : ROSE_ASSERT(found == true);
96178 :
96179 0 : return found;
96180 : }
96181 : /* #line 96182 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
96182 :
96183 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
96184 :
96185 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
96186 :
96187 : /* #line 96188 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
96188 :
96189 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
96190 :
96191 : void
96192 0 : SgCommaOpExp::checkDataMemberPointersIfInMemoryPool()
96193 : {
96194 : // ------------ checking pointers of SgCommaOpExp -------------------
96195 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
96196 :
96197 0 : if ( p_lhs_operand_i != NULL )
96198 : {
96199 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96200 : {
96201 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
96202 : {
96203 0 : std::cout << "SgCommaOpExp :: ";
96204 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
96205 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
96206 : }
96207 : }
96208 : else
96209 : {
96210 0 : std::cout << "SgCommaOpExp :: " << std::flush;
96211 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
96212 0 : std::cout << " not valid " << std::endl;
96213 : }
96214 : }
96215 :
96216 0 : if ( p_rhs_operand_i != NULL )
96217 : {
96218 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96219 : {
96220 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
96221 : {
96222 0 : std::cout << "SgCommaOpExp :: ";
96223 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
96224 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
96225 : }
96226 : }
96227 : else
96228 : {
96229 0 : std::cout << "SgCommaOpExp :: " << std::flush;
96230 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
96231 0 : std::cout << " not valid " << std::endl;
96232 : }
96233 : }
96234 :
96235 0 : if ( p_expression_type != NULL )
96236 : {
96237 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96238 : {
96239 0 : if ( p_expression_type->isInMemoryPool() == false )
96240 : {
96241 0 : std::cout << "SgCommaOpExp :: ";
96242 0 : std::cout << " p_expression_type is not in memory pool of ";
96243 0 : std::cout << p_expression_type->class_name() << std::endl;
96244 : }
96245 : }
96246 : else
96247 : {
96248 0 : std::cout << "SgCommaOpExp :: " << std::flush;
96249 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
96250 0 : std::cout << " not valid " << std::endl;
96251 : }
96252 : }
96253 :
96254 0 : if ( p_originalExpressionTree != NULL )
96255 : {
96256 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96257 : {
96258 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
96259 : {
96260 0 : std::cout << "SgCommaOpExp :: ";
96261 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
96262 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
96263 : }
96264 : }
96265 : else
96266 : {
96267 0 : std::cout << "SgCommaOpExp :: " << std::flush;
96268 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
96269 0 : std::cout << " not valid " << std::endl;
96270 : }
96271 : }
96272 :
96273 0 : if ( p_operatorPosition != NULL )
96274 : {
96275 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96276 : {
96277 0 : if ( p_operatorPosition->isInMemoryPool() == false )
96278 : {
96279 0 : std::cout << "SgCommaOpExp :: ";
96280 0 : std::cout << " p_operatorPosition is not in memory pool of ";
96281 0 : std::cout << p_operatorPosition->class_name() << std::endl;
96282 : }
96283 : }
96284 : else
96285 : {
96286 0 : std::cout << "SgCommaOpExp :: " << std::flush;
96287 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
96288 0 : std::cout << " not valid " << std::endl;
96289 : }
96290 : }
96291 :
96292 0 : if ( p_startOfConstruct != NULL )
96293 : {
96294 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96295 : {
96296 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
96297 : {
96298 0 : std::cout << "SgCommaOpExp :: ";
96299 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
96300 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
96301 : }
96302 : }
96303 : else
96304 : {
96305 0 : std::cout << "SgCommaOpExp :: " << std::flush;
96306 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
96307 0 : std::cout << " not valid " << std::endl;
96308 : }
96309 : }
96310 :
96311 0 : if ( p_endOfConstruct != NULL )
96312 : {
96313 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96314 : {
96315 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
96316 : {
96317 0 : std::cout << "SgCommaOpExp :: ";
96318 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
96319 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
96320 : }
96321 : }
96322 : else
96323 : {
96324 0 : std::cout << "SgCommaOpExp :: " << std::flush;
96325 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
96326 0 : std::cout << " not valid " << std::endl;
96327 : }
96328 : }
96329 :
96330 0 : if ( p_parent != NULL )
96331 : {
96332 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96333 : {
96334 0 : if ( p_parent->isInMemoryPool() == false )
96335 : {
96336 0 : std::cout << "SgCommaOpExp :: ";
96337 0 : std::cout << " p_parent is not in memory pool of ";
96338 0 : std::cout << p_parent->class_name() << std::endl;
96339 : }
96340 : }
96341 : else
96342 : {
96343 0 : std::cout << "SgCommaOpExp :: " << std::flush;
96344 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
96345 0 : std::cout << " not valid " << std::endl;
96346 : }
96347 : }
96348 :
96349 :
96350 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
96351 :
96352 0 : }
96353 :
96354 :
96355 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
96356 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
96357 : bool
96358 0 : SgCommaOpExp::isInMemoryPool ()
96359 : {
96360 0 : typedef unsigned char* TestType;
96361 :
96362 0 : bool found = false;
96363 :
96364 0 : ROSE_ASSERT(this != NULL);
96365 :
96366 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
96367 :
96368 0 : TestType tested = (TestType) ( this ) ;
96369 :
96370 0 : std::vector < unsigned char* > :: const_iterator block = SgCommaOpExp::pools.begin();
96371 :
96372 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
96373 : // while (found == false && block < Memory_Block_List.end())
96374 0 : while ( (found == false) && (block != SgCommaOpExp::pools.end()) )
96375 : {
96376 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCommaOpExp::pool_size * sizeof(SgCommaOpExp) ) ) ;
96377 0 : ++block;
96378 : }
96379 :
96380 : // Special handling for static data
96381 :
96382 :
96383 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
96384 0 : ROSE_ASSERT(found == true);
96385 :
96386 0 : return found;
96387 : }
96388 : /* #line 96389 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
96389 :
96390 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
96391 :
96392 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
96393 :
96394 : /* #line 96395 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
96395 :
96396 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
96397 :
96398 : void
96399 0 : SgLshiftOp::checkDataMemberPointersIfInMemoryPool()
96400 : {
96401 : // ------------ checking pointers of SgLshiftOp -------------------
96402 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
96403 :
96404 0 : if ( p_lhs_operand_i != NULL )
96405 : {
96406 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96407 : {
96408 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
96409 : {
96410 0 : std::cout << "SgLshiftOp :: ";
96411 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
96412 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
96413 : }
96414 : }
96415 : else
96416 : {
96417 0 : std::cout << "SgLshiftOp :: " << std::flush;
96418 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
96419 0 : std::cout << " not valid " << std::endl;
96420 : }
96421 : }
96422 :
96423 0 : if ( p_rhs_operand_i != NULL )
96424 : {
96425 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96426 : {
96427 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
96428 : {
96429 0 : std::cout << "SgLshiftOp :: ";
96430 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
96431 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
96432 : }
96433 : }
96434 : else
96435 : {
96436 0 : std::cout << "SgLshiftOp :: " << std::flush;
96437 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
96438 0 : std::cout << " not valid " << std::endl;
96439 : }
96440 : }
96441 :
96442 0 : if ( p_expression_type != NULL )
96443 : {
96444 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96445 : {
96446 0 : if ( p_expression_type->isInMemoryPool() == false )
96447 : {
96448 0 : std::cout << "SgLshiftOp :: ";
96449 0 : std::cout << " p_expression_type is not in memory pool of ";
96450 0 : std::cout << p_expression_type->class_name() << std::endl;
96451 : }
96452 : }
96453 : else
96454 : {
96455 0 : std::cout << "SgLshiftOp :: " << std::flush;
96456 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
96457 0 : std::cout << " not valid " << std::endl;
96458 : }
96459 : }
96460 :
96461 0 : if ( p_originalExpressionTree != NULL )
96462 : {
96463 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96464 : {
96465 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
96466 : {
96467 0 : std::cout << "SgLshiftOp :: ";
96468 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
96469 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
96470 : }
96471 : }
96472 : else
96473 : {
96474 0 : std::cout << "SgLshiftOp :: " << std::flush;
96475 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
96476 0 : std::cout << " not valid " << std::endl;
96477 : }
96478 : }
96479 :
96480 0 : if ( p_operatorPosition != NULL )
96481 : {
96482 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96483 : {
96484 0 : if ( p_operatorPosition->isInMemoryPool() == false )
96485 : {
96486 0 : std::cout << "SgLshiftOp :: ";
96487 0 : std::cout << " p_operatorPosition is not in memory pool of ";
96488 0 : std::cout << p_operatorPosition->class_name() << std::endl;
96489 : }
96490 : }
96491 : else
96492 : {
96493 0 : std::cout << "SgLshiftOp :: " << std::flush;
96494 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
96495 0 : std::cout << " not valid " << std::endl;
96496 : }
96497 : }
96498 :
96499 0 : if ( p_startOfConstruct != NULL )
96500 : {
96501 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96502 : {
96503 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
96504 : {
96505 0 : std::cout << "SgLshiftOp :: ";
96506 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
96507 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
96508 : }
96509 : }
96510 : else
96511 : {
96512 0 : std::cout << "SgLshiftOp :: " << std::flush;
96513 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
96514 0 : std::cout << " not valid " << std::endl;
96515 : }
96516 : }
96517 :
96518 0 : if ( p_endOfConstruct != NULL )
96519 : {
96520 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96521 : {
96522 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
96523 : {
96524 0 : std::cout << "SgLshiftOp :: ";
96525 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
96526 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
96527 : }
96528 : }
96529 : else
96530 : {
96531 0 : std::cout << "SgLshiftOp :: " << std::flush;
96532 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
96533 0 : std::cout << " not valid " << std::endl;
96534 : }
96535 : }
96536 :
96537 0 : if ( p_parent != NULL )
96538 : {
96539 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96540 : {
96541 0 : if ( p_parent->isInMemoryPool() == false )
96542 : {
96543 0 : std::cout << "SgLshiftOp :: ";
96544 0 : std::cout << " p_parent is not in memory pool of ";
96545 0 : std::cout << p_parent->class_name() << std::endl;
96546 : }
96547 : }
96548 : else
96549 : {
96550 0 : std::cout << "SgLshiftOp :: " << std::flush;
96551 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
96552 0 : std::cout << " not valid " << std::endl;
96553 : }
96554 : }
96555 :
96556 :
96557 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
96558 :
96559 0 : }
96560 :
96561 :
96562 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
96563 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
96564 : bool
96565 0 : SgLshiftOp::isInMemoryPool ()
96566 : {
96567 0 : typedef unsigned char* TestType;
96568 :
96569 0 : bool found = false;
96570 :
96571 0 : ROSE_ASSERT(this != NULL);
96572 :
96573 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
96574 :
96575 0 : TestType tested = (TestType) ( this ) ;
96576 :
96577 0 : std::vector < unsigned char* > :: const_iterator block = SgLshiftOp::pools.begin();
96578 :
96579 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
96580 : // while (found == false && block < Memory_Block_List.end())
96581 0 : while ( (found == false) && (block != SgLshiftOp::pools.end()) )
96582 : {
96583 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLshiftOp::pool_size * sizeof(SgLshiftOp) ) ) ;
96584 0 : ++block;
96585 : }
96586 :
96587 : // Special handling for static data
96588 :
96589 :
96590 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
96591 0 : ROSE_ASSERT(found == true);
96592 :
96593 0 : return found;
96594 : }
96595 : /* #line 96596 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
96596 :
96597 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
96598 :
96599 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
96600 :
96601 : /* #line 96602 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
96602 :
96603 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
96604 :
96605 : void
96606 0 : SgRshiftOp::checkDataMemberPointersIfInMemoryPool()
96607 : {
96608 : // ------------ checking pointers of SgRshiftOp -------------------
96609 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
96610 :
96611 0 : if ( p_lhs_operand_i != NULL )
96612 : {
96613 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96614 : {
96615 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
96616 : {
96617 0 : std::cout << "SgRshiftOp :: ";
96618 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
96619 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
96620 : }
96621 : }
96622 : else
96623 : {
96624 0 : std::cout << "SgRshiftOp :: " << std::flush;
96625 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
96626 0 : std::cout << " not valid " << std::endl;
96627 : }
96628 : }
96629 :
96630 0 : if ( p_rhs_operand_i != NULL )
96631 : {
96632 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96633 : {
96634 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
96635 : {
96636 0 : std::cout << "SgRshiftOp :: ";
96637 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
96638 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
96639 : }
96640 : }
96641 : else
96642 : {
96643 0 : std::cout << "SgRshiftOp :: " << std::flush;
96644 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
96645 0 : std::cout << " not valid " << std::endl;
96646 : }
96647 : }
96648 :
96649 0 : if ( p_expression_type != NULL )
96650 : {
96651 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96652 : {
96653 0 : if ( p_expression_type->isInMemoryPool() == false )
96654 : {
96655 0 : std::cout << "SgRshiftOp :: ";
96656 0 : std::cout << " p_expression_type is not in memory pool of ";
96657 0 : std::cout << p_expression_type->class_name() << std::endl;
96658 : }
96659 : }
96660 : else
96661 : {
96662 0 : std::cout << "SgRshiftOp :: " << std::flush;
96663 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
96664 0 : std::cout << " not valid " << std::endl;
96665 : }
96666 : }
96667 :
96668 0 : if ( p_originalExpressionTree != NULL )
96669 : {
96670 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96671 : {
96672 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
96673 : {
96674 0 : std::cout << "SgRshiftOp :: ";
96675 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
96676 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
96677 : }
96678 : }
96679 : else
96680 : {
96681 0 : std::cout << "SgRshiftOp :: " << std::flush;
96682 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
96683 0 : std::cout << " not valid " << std::endl;
96684 : }
96685 : }
96686 :
96687 0 : if ( p_operatorPosition != NULL )
96688 : {
96689 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96690 : {
96691 0 : if ( p_operatorPosition->isInMemoryPool() == false )
96692 : {
96693 0 : std::cout << "SgRshiftOp :: ";
96694 0 : std::cout << " p_operatorPosition is not in memory pool of ";
96695 0 : std::cout << p_operatorPosition->class_name() << std::endl;
96696 : }
96697 : }
96698 : else
96699 : {
96700 0 : std::cout << "SgRshiftOp :: " << std::flush;
96701 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
96702 0 : std::cout << " not valid " << std::endl;
96703 : }
96704 : }
96705 :
96706 0 : if ( p_startOfConstruct != NULL )
96707 : {
96708 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96709 : {
96710 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
96711 : {
96712 0 : std::cout << "SgRshiftOp :: ";
96713 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
96714 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
96715 : }
96716 : }
96717 : else
96718 : {
96719 0 : std::cout << "SgRshiftOp :: " << std::flush;
96720 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
96721 0 : std::cout << " not valid " << std::endl;
96722 : }
96723 : }
96724 :
96725 0 : if ( p_endOfConstruct != NULL )
96726 : {
96727 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96728 : {
96729 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
96730 : {
96731 0 : std::cout << "SgRshiftOp :: ";
96732 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
96733 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
96734 : }
96735 : }
96736 : else
96737 : {
96738 0 : std::cout << "SgRshiftOp :: " << std::flush;
96739 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
96740 0 : std::cout << " not valid " << std::endl;
96741 : }
96742 : }
96743 :
96744 0 : if ( p_parent != NULL )
96745 : {
96746 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96747 : {
96748 0 : if ( p_parent->isInMemoryPool() == false )
96749 : {
96750 0 : std::cout << "SgRshiftOp :: ";
96751 0 : std::cout << " p_parent is not in memory pool of ";
96752 0 : std::cout << p_parent->class_name() << std::endl;
96753 : }
96754 : }
96755 : else
96756 : {
96757 0 : std::cout << "SgRshiftOp :: " << std::flush;
96758 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
96759 0 : std::cout << " not valid " << std::endl;
96760 : }
96761 : }
96762 :
96763 :
96764 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
96765 :
96766 0 : }
96767 :
96768 :
96769 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
96770 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
96771 : bool
96772 0 : SgRshiftOp::isInMemoryPool ()
96773 : {
96774 0 : typedef unsigned char* TestType;
96775 :
96776 0 : bool found = false;
96777 :
96778 0 : ROSE_ASSERT(this != NULL);
96779 :
96780 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
96781 :
96782 0 : TestType tested = (TestType) ( this ) ;
96783 :
96784 0 : std::vector < unsigned char* > :: const_iterator block = SgRshiftOp::pools.begin();
96785 :
96786 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
96787 : // while (found == false && block < Memory_Block_List.end())
96788 0 : while ( (found == false) && (block != SgRshiftOp::pools.end()) )
96789 : {
96790 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgRshiftOp::pool_size * sizeof(SgRshiftOp) ) ) ;
96791 0 : ++block;
96792 : }
96793 :
96794 : // Special handling for static data
96795 :
96796 :
96797 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
96798 0 : ROSE_ASSERT(found == true);
96799 :
96800 0 : return found;
96801 : }
96802 : /* #line 96803 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
96803 :
96804 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
96805 :
96806 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
96807 :
96808 : /* #line 96809 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
96809 :
96810 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
96811 :
96812 : void
96813 0 : SgPntrArrRefExp::checkDataMemberPointersIfInMemoryPool()
96814 : {
96815 : // ------------ checking pointers of SgPntrArrRefExp -------------------
96816 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
96817 :
96818 0 : if ( p_lhs_operand_i != NULL )
96819 : {
96820 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96821 : {
96822 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
96823 : {
96824 0 : std::cout << "SgPntrArrRefExp :: ";
96825 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
96826 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
96827 : }
96828 : }
96829 : else
96830 : {
96831 0 : std::cout << "SgPntrArrRefExp :: " << std::flush;
96832 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
96833 0 : std::cout << " not valid " << std::endl;
96834 : }
96835 : }
96836 :
96837 0 : if ( p_rhs_operand_i != NULL )
96838 : {
96839 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96840 : {
96841 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
96842 : {
96843 0 : std::cout << "SgPntrArrRefExp :: ";
96844 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
96845 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
96846 : }
96847 : }
96848 : else
96849 : {
96850 0 : std::cout << "SgPntrArrRefExp :: " << std::flush;
96851 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
96852 0 : std::cout << " not valid " << std::endl;
96853 : }
96854 : }
96855 :
96856 0 : if ( p_expression_type != NULL )
96857 : {
96858 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96859 : {
96860 0 : if ( p_expression_type->isInMemoryPool() == false )
96861 : {
96862 0 : std::cout << "SgPntrArrRefExp :: ";
96863 0 : std::cout << " p_expression_type is not in memory pool of ";
96864 0 : std::cout << p_expression_type->class_name() << std::endl;
96865 : }
96866 : }
96867 : else
96868 : {
96869 0 : std::cout << "SgPntrArrRefExp :: " << std::flush;
96870 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
96871 0 : std::cout << " not valid " << std::endl;
96872 : }
96873 : }
96874 :
96875 0 : if ( p_originalExpressionTree != NULL )
96876 : {
96877 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96878 : {
96879 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
96880 : {
96881 0 : std::cout << "SgPntrArrRefExp :: ";
96882 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
96883 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
96884 : }
96885 : }
96886 : else
96887 : {
96888 0 : std::cout << "SgPntrArrRefExp :: " << std::flush;
96889 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
96890 0 : std::cout << " not valid " << std::endl;
96891 : }
96892 : }
96893 :
96894 0 : if ( p_operatorPosition != NULL )
96895 : {
96896 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96897 : {
96898 0 : if ( p_operatorPosition->isInMemoryPool() == false )
96899 : {
96900 0 : std::cout << "SgPntrArrRefExp :: ";
96901 0 : std::cout << " p_operatorPosition is not in memory pool of ";
96902 0 : std::cout << p_operatorPosition->class_name() << std::endl;
96903 : }
96904 : }
96905 : else
96906 : {
96907 0 : std::cout << "SgPntrArrRefExp :: " << std::flush;
96908 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
96909 0 : std::cout << " not valid " << std::endl;
96910 : }
96911 : }
96912 :
96913 0 : if ( p_startOfConstruct != NULL )
96914 : {
96915 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96916 : {
96917 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
96918 : {
96919 0 : std::cout << "SgPntrArrRefExp :: ";
96920 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
96921 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
96922 : }
96923 : }
96924 : else
96925 : {
96926 0 : std::cout << "SgPntrArrRefExp :: " << std::flush;
96927 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
96928 0 : std::cout << " not valid " << std::endl;
96929 : }
96930 : }
96931 :
96932 0 : if ( p_endOfConstruct != NULL )
96933 : {
96934 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96935 : {
96936 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
96937 : {
96938 0 : std::cout << "SgPntrArrRefExp :: ";
96939 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
96940 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
96941 : }
96942 : }
96943 : else
96944 : {
96945 0 : std::cout << "SgPntrArrRefExp :: " << std::flush;
96946 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
96947 0 : std::cout << " not valid " << std::endl;
96948 : }
96949 : }
96950 :
96951 0 : if ( p_parent != NULL )
96952 : {
96953 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
96954 : {
96955 0 : if ( p_parent->isInMemoryPool() == false )
96956 : {
96957 0 : std::cout << "SgPntrArrRefExp :: ";
96958 0 : std::cout << " p_parent is not in memory pool of ";
96959 0 : std::cout << p_parent->class_name() << std::endl;
96960 : }
96961 : }
96962 : else
96963 : {
96964 0 : std::cout << "SgPntrArrRefExp :: " << std::flush;
96965 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
96966 0 : std::cout << " not valid " << std::endl;
96967 : }
96968 : }
96969 :
96970 :
96971 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
96972 :
96973 0 : }
96974 :
96975 :
96976 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
96977 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
96978 : bool
96979 0 : SgPntrArrRefExp::isInMemoryPool ()
96980 : {
96981 0 : typedef unsigned char* TestType;
96982 :
96983 0 : bool found = false;
96984 :
96985 0 : ROSE_ASSERT(this != NULL);
96986 :
96987 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
96988 :
96989 0 : TestType tested = (TestType) ( this ) ;
96990 :
96991 0 : std::vector < unsigned char* > :: const_iterator block = SgPntrArrRefExp::pools.begin();
96992 :
96993 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
96994 : // while (found == false && block < Memory_Block_List.end())
96995 0 : while ( (found == false) && (block != SgPntrArrRefExp::pools.end()) )
96996 : {
96997 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgPntrArrRefExp::pool_size * sizeof(SgPntrArrRefExp) ) ) ;
96998 0 : ++block;
96999 : }
97000 :
97001 : // Special handling for static data
97002 :
97003 :
97004 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
97005 0 : ROSE_ASSERT(found == true);
97006 :
97007 0 : return found;
97008 : }
97009 : /* #line 97010 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
97010 :
97011 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
97012 :
97013 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
97014 :
97015 : /* #line 97016 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
97016 :
97017 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
97018 :
97019 : void
97020 0 : SgScopeOp::checkDataMemberPointersIfInMemoryPool()
97021 : {
97022 : // ------------ checking pointers of SgScopeOp -------------------
97023 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
97024 :
97025 0 : if ( p_lhs_operand_i != NULL )
97026 : {
97027 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97028 : {
97029 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
97030 : {
97031 0 : std::cout << "SgScopeOp :: ";
97032 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
97033 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
97034 : }
97035 : }
97036 : else
97037 : {
97038 0 : std::cout << "SgScopeOp :: " << std::flush;
97039 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
97040 0 : std::cout << " not valid " << std::endl;
97041 : }
97042 : }
97043 :
97044 0 : if ( p_rhs_operand_i != NULL )
97045 : {
97046 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97047 : {
97048 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
97049 : {
97050 0 : std::cout << "SgScopeOp :: ";
97051 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
97052 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
97053 : }
97054 : }
97055 : else
97056 : {
97057 0 : std::cout << "SgScopeOp :: " << std::flush;
97058 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
97059 0 : std::cout << " not valid " << std::endl;
97060 : }
97061 : }
97062 :
97063 0 : if ( p_expression_type != NULL )
97064 : {
97065 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97066 : {
97067 0 : if ( p_expression_type->isInMemoryPool() == false )
97068 : {
97069 0 : std::cout << "SgScopeOp :: ";
97070 0 : std::cout << " p_expression_type is not in memory pool of ";
97071 0 : std::cout << p_expression_type->class_name() << std::endl;
97072 : }
97073 : }
97074 : else
97075 : {
97076 0 : std::cout << "SgScopeOp :: " << std::flush;
97077 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
97078 0 : std::cout << " not valid " << std::endl;
97079 : }
97080 : }
97081 :
97082 0 : if ( p_originalExpressionTree != NULL )
97083 : {
97084 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97085 : {
97086 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
97087 : {
97088 0 : std::cout << "SgScopeOp :: ";
97089 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
97090 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
97091 : }
97092 : }
97093 : else
97094 : {
97095 0 : std::cout << "SgScopeOp :: " << std::flush;
97096 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
97097 0 : std::cout << " not valid " << std::endl;
97098 : }
97099 : }
97100 :
97101 0 : if ( p_operatorPosition != NULL )
97102 : {
97103 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97104 : {
97105 0 : if ( p_operatorPosition->isInMemoryPool() == false )
97106 : {
97107 0 : std::cout << "SgScopeOp :: ";
97108 0 : std::cout << " p_operatorPosition is not in memory pool of ";
97109 0 : std::cout << p_operatorPosition->class_name() << std::endl;
97110 : }
97111 : }
97112 : else
97113 : {
97114 0 : std::cout << "SgScopeOp :: " << std::flush;
97115 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
97116 0 : std::cout << " not valid " << std::endl;
97117 : }
97118 : }
97119 :
97120 0 : if ( p_startOfConstruct != NULL )
97121 : {
97122 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97123 : {
97124 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
97125 : {
97126 0 : std::cout << "SgScopeOp :: ";
97127 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
97128 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
97129 : }
97130 : }
97131 : else
97132 : {
97133 0 : std::cout << "SgScopeOp :: " << std::flush;
97134 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
97135 0 : std::cout << " not valid " << std::endl;
97136 : }
97137 : }
97138 :
97139 0 : if ( p_endOfConstruct != NULL )
97140 : {
97141 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97142 : {
97143 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
97144 : {
97145 0 : std::cout << "SgScopeOp :: ";
97146 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
97147 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
97148 : }
97149 : }
97150 : else
97151 : {
97152 0 : std::cout << "SgScopeOp :: " << std::flush;
97153 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
97154 0 : std::cout << " not valid " << std::endl;
97155 : }
97156 : }
97157 :
97158 0 : if ( p_parent != NULL )
97159 : {
97160 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97161 : {
97162 0 : if ( p_parent->isInMemoryPool() == false )
97163 : {
97164 0 : std::cout << "SgScopeOp :: ";
97165 0 : std::cout << " p_parent is not in memory pool of ";
97166 0 : std::cout << p_parent->class_name() << std::endl;
97167 : }
97168 : }
97169 : else
97170 : {
97171 0 : std::cout << "SgScopeOp :: " << std::flush;
97172 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
97173 0 : std::cout << " not valid " << std::endl;
97174 : }
97175 : }
97176 :
97177 :
97178 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
97179 :
97180 0 : }
97181 :
97182 :
97183 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
97184 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
97185 : bool
97186 0 : SgScopeOp::isInMemoryPool ()
97187 : {
97188 0 : typedef unsigned char* TestType;
97189 :
97190 0 : bool found = false;
97191 :
97192 0 : ROSE_ASSERT(this != NULL);
97193 :
97194 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
97195 :
97196 0 : TestType tested = (TestType) ( this ) ;
97197 :
97198 0 : std::vector < unsigned char* > :: const_iterator block = SgScopeOp::pools.begin();
97199 :
97200 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
97201 : // while (found == false && block < Memory_Block_List.end())
97202 0 : while ( (found == false) && (block != SgScopeOp::pools.end()) )
97203 : {
97204 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgScopeOp::pool_size * sizeof(SgScopeOp) ) ) ;
97205 0 : ++block;
97206 : }
97207 :
97208 : // Special handling for static data
97209 :
97210 :
97211 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
97212 0 : ROSE_ASSERT(found == true);
97213 :
97214 0 : return found;
97215 : }
97216 : /* #line 97217 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
97217 :
97218 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
97219 :
97220 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
97221 :
97222 : /* #line 97223 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
97223 :
97224 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
97225 :
97226 : void
97227 0 : SgAssignOp::checkDataMemberPointersIfInMemoryPool()
97228 : {
97229 : // ------------ checking pointers of SgAssignOp -------------------
97230 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
97231 :
97232 0 : if ( p_lhs_operand_i != NULL )
97233 : {
97234 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97235 : {
97236 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
97237 : {
97238 0 : std::cout << "SgAssignOp :: ";
97239 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
97240 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
97241 : }
97242 : }
97243 : else
97244 : {
97245 0 : std::cout << "SgAssignOp :: " << std::flush;
97246 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
97247 0 : std::cout << " not valid " << std::endl;
97248 : }
97249 : }
97250 :
97251 0 : if ( p_rhs_operand_i != NULL )
97252 : {
97253 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97254 : {
97255 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
97256 : {
97257 0 : std::cout << "SgAssignOp :: ";
97258 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
97259 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
97260 : }
97261 : }
97262 : else
97263 : {
97264 0 : std::cout << "SgAssignOp :: " << std::flush;
97265 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
97266 0 : std::cout << " not valid " << std::endl;
97267 : }
97268 : }
97269 :
97270 0 : if ( p_expression_type != NULL )
97271 : {
97272 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97273 : {
97274 0 : if ( p_expression_type->isInMemoryPool() == false )
97275 : {
97276 0 : std::cout << "SgAssignOp :: ";
97277 0 : std::cout << " p_expression_type is not in memory pool of ";
97278 0 : std::cout << p_expression_type->class_name() << std::endl;
97279 : }
97280 : }
97281 : else
97282 : {
97283 0 : std::cout << "SgAssignOp :: " << std::flush;
97284 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
97285 0 : std::cout << " not valid " << std::endl;
97286 : }
97287 : }
97288 :
97289 0 : if ( p_originalExpressionTree != NULL )
97290 : {
97291 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97292 : {
97293 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
97294 : {
97295 0 : std::cout << "SgAssignOp :: ";
97296 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
97297 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
97298 : }
97299 : }
97300 : else
97301 : {
97302 0 : std::cout << "SgAssignOp :: " << std::flush;
97303 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
97304 0 : std::cout << " not valid " << std::endl;
97305 : }
97306 : }
97307 :
97308 0 : if ( p_operatorPosition != NULL )
97309 : {
97310 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97311 : {
97312 0 : if ( p_operatorPosition->isInMemoryPool() == false )
97313 : {
97314 0 : std::cout << "SgAssignOp :: ";
97315 0 : std::cout << " p_operatorPosition is not in memory pool of ";
97316 0 : std::cout << p_operatorPosition->class_name() << std::endl;
97317 : }
97318 : }
97319 : else
97320 : {
97321 0 : std::cout << "SgAssignOp :: " << std::flush;
97322 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
97323 0 : std::cout << " not valid " << std::endl;
97324 : }
97325 : }
97326 :
97327 0 : if ( p_startOfConstruct != NULL )
97328 : {
97329 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97330 : {
97331 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
97332 : {
97333 0 : std::cout << "SgAssignOp :: ";
97334 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
97335 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
97336 : }
97337 : }
97338 : else
97339 : {
97340 0 : std::cout << "SgAssignOp :: " << std::flush;
97341 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
97342 0 : std::cout << " not valid " << std::endl;
97343 : }
97344 : }
97345 :
97346 0 : if ( p_endOfConstruct != NULL )
97347 : {
97348 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97349 : {
97350 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
97351 : {
97352 0 : std::cout << "SgAssignOp :: ";
97353 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
97354 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
97355 : }
97356 : }
97357 : else
97358 : {
97359 0 : std::cout << "SgAssignOp :: " << std::flush;
97360 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
97361 0 : std::cout << " not valid " << std::endl;
97362 : }
97363 : }
97364 :
97365 0 : if ( p_parent != NULL )
97366 : {
97367 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97368 : {
97369 0 : if ( p_parent->isInMemoryPool() == false )
97370 : {
97371 0 : std::cout << "SgAssignOp :: ";
97372 0 : std::cout << " p_parent is not in memory pool of ";
97373 0 : std::cout << p_parent->class_name() << std::endl;
97374 : }
97375 : }
97376 : else
97377 : {
97378 0 : std::cout << "SgAssignOp :: " << std::flush;
97379 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
97380 0 : std::cout << " not valid " << std::endl;
97381 : }
97382 : }
97383 :
97384 :
97385 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
97386 :
97387 0 : }
97388 :
97389 :
97390 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
97391 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
97392 : bool
97393 0 : SgAssignOp::isInMemoryPool ()
97394 : {
97395 0 : typedef unsigned char* TestType;
97396 :
97397 0 : bool found = false;
97398 :
97399 0 : ROSE_ASSERT(this != NULL);
97400 :
97401 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
97402 :
97403 0 : TestType tested = (TestType) ( this ) ;
97404 :
97405 0 : std::vector < unsigned char* > :: const_iterator block = SgAssignOp::pools.begin();
97406 :
97407 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
97408 : // while (found == false && block < Memory_Block_List.end())
97409 0 : while ( (found == false) && (block != SgAssignOp::pools.end()) )
97410 : {
97411 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAssignOp::pool_size * sizeof(SgAssignOp) ) ) ;
97412 0 : ++block;
97413 : }
97414 :
97415 : // Special handling for static data
97416 :
97417 :
97418 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
97419 0 : ROSE_ASSERT(found == true);
97420 :
97421 0 : return found;
97422 : }
97423 : /* #line 97424 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
97424 :
97425 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
97426 :
97427 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
97428 :
97429 : /* #line 97430 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
97430 :
97431 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
97432 :
97433 : void
97434 0 : SgExponentiationOp::checkDataMemberPointersIfInMemoryPool()
97435 : {
97436 : // ------------ checking pointers of SgExponentiationOp -------------------
97437 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
97438 :
97439 0 : if ( p_lhs_operand_i != NULL )
97440 : {
97441 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97442 : {
97443 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
97444 : {
97445 0 : std::cout << "SgExponentiationOp :: ";
97446 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
97447 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
97448 : }
97449 : }
97450 : else
97451 : {
97452 0 : std::cout << "SgExponentiationOp :: " << std::flush;
97453 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
97454 0 : std::cout << " not valid " << std::endl;
97455 : }
97456 : }
97457 :
97458 0 : if ( p_rhs_operand_i != NULL )
97459 : {
97460 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97461 : {
97462 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
97463 : {
97464 0 : std::cout << "SgExponentiationOp :: ";
97465 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
97466 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
97467 : }
97468 : }
97469 : else
97470 : {
97471 0 : std::cout << "SgExponentiationOp :: " << std::flush;
97472 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
97473 0 : std::cout << " not valid " << std::endl;
97474 : }
97475 : }
97476 :
97477 0 : if ( p_expression_type != NULL )
97478 : {
97479 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97480 : {
97481 0 : if ( p_expression_type->isInMemoryPool() == false )
97482 : {
97483 0 : std::cout << "SgExponentiationOp :: ";
97484 0 : std::cout << " p_expression_type is not in memory pool of ";
97485 0 : std::cout << p_expression_type->class_name() << std::endl;
97486 : }
97487 : }
97488 : else
97489 : {
97490 0 : std::cout << "SgExponentiationOp :: " << std::flush;
97491 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
97492 0 : std::cout << " not valid " << std::endl;
97493 : }
97494 : }
97495 :
97496 0 : if ( p_originalExpressionTree != NULL )
97497 : {
97498 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97499 : {
97500 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
97501 : {
97502 0 : std::cout << "SgExponentiationOp :: ";
97503 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
97504 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
97505 : }
97506 : }
97507 : else
97508 : {
97509 0 : std::cout << "SgExponentiationOp :: " << std::flush;
97510 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
97511 0 : std::cout << " not valid " << std::endl;
97512 : }
97513 : }
97514 :
97515 0 : if ( p_operatorPosition != NULL )
97516 : {
97517 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97518 : {
97519 0 : if ( p_operatorPosition->isInMemoryPool() == false )
97520 : {
97521 0 : std::cout << "SgExponentiationOp :: ";
97522 0 : std::cout << " p_operatorPosition is not in memory pool of ";
97523 0 : std::cout << p_operatorPosition->class_name() << std::endl;
97524 : }
97525 : }
97526 : else
97527 : {
97528 0 : std::cout << "SgExponentiationOp :: " << std::flush;
97529 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
97530 0 : std::cout << " not valid " << std::endl;
97531 : }
97532 : }
97533 :
97534 0 : if ( p_startOfConstruct != NULL )
97535 : {
97536 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97537 : {
97538 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
97539 : {
97540 0 : std::cout << "SgExponentiationOp :: ";
97541 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
97542 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
97543 : }
97544 : }
97545 : else
97546 : {
97547 0 : std::cout << "SgExponentiationOp :: " << std::flush;
97548 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
97549 0 : std::cout << " not valid " << std::endl;
97550 : }
97551 : }
97552 :
97553 0 : if ( p_endOfConstruct != NULL )
97554 : {
97555 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97556 : {
97557 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
97558 : {
97559 0 : std::cout << "SgExponentiationOp :: ";
97560 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
97561 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
97562 : }
97563 : }
97564 : else
97565 : {
97566 0 : std::cout << "SgExponentiationOp :: " << std::flush;
97567 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
97568 0 : std::cout << " not valid " << std::endl;
97569 : }
97570 : }
97571 :
97572 0 : if ( p_parent != NULL )
97573 : {
97574 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97575 : {
97576 0 : if ( p_parent->isInMemoryPool() == false )
97577 : {
97578 0 : std::cout << "SgExponentiationOp :: ";
97579 0 : std::cout << " p_parent is not in memory pool of ";
97580 0 : std::cout << p_parent->class_name() << std::endl;
97581 : }
97582 : }
97583 : else
97584 : {
97585 0 : std::cout << "SgExponentiationOp :: " << std::flush;
97586 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
97587 0 : std::cout << " not valid " << std::endl;
97588 : }
97589 : }
97590 :
97591 :
97592 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
97593 :
97594 0 : }
97595 :
97596 :
97597 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
97598 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
97599 : bool
97600 0 : SgExponentiationOp::isInMemoryPool ()
97601 : {
97602 0 : typedef unsigned char* TestType;
97603 :
97604 0 : bool found = false;
97605 :
97606 0 : ROSE_ASSERT(this != NULL);
97607 :
97608 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
97609 :
97610 0 : TestType tested = (TestType) ( this ) ;
97611 :
97612 0 : std::vector < unsigned char* > :: const_iterator block = SgExponentiationOp::pools.begin();
97613 :
97614 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
97615 : // while (found == false && block < Memory_Block_List.end())
97616 0 : while ( (found == false) && (block != SgExponentiationOp::pools.end()) )
97617 : {
97618 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgExponentiationOp::pool_size * sizeof(SgExponentiationOp) ) ) ;
97619 0 : ++block;
97620 : }
97621 :
97622 : // Special handling for static data
97623 :
97624 :
97625 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
97626 0 : ROSE_ASSERT(found == true);
97627 :
97628 0 : return found;
97629 : }
97630 : /* #line 97631 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
97631 :
97632 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
97633 :
97634 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
97635 :
97636 : /* #line 97637 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
97637 :
97638 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
97639 :
97640 : void
97641 0 : SgConcatenationOp::checkDataMemberPointersIfInMemoryPool()
97642 : {
97643 : // ------------ checking pointers of SgConcatenationOp -------------------
97644 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
97645 :
97646 0 : if ( p_lhs_operand_i != NULL )
97647 : {
97648 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97649 : {
97650 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
97651 : {
97652 0 : std::cout << "SgConcatenationOp :: ";
97653 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
97654 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
97655 : }
97656 : }
97657 : else
97658 : {
97659 0 : std::cout << "SgConcatenationOp :: " << std::flush;
97660 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
97661 0 : std::cout << " not valid " << std::endl;
97662 : }
97663 : }
97664 :
97665 0 : if ( p_rhs_operand_i != NULL )
97666 : {
97667 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97668 : {
97669 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
97670 : {
97671 0 : std::cout << "SgConcatenationOp :: ";
97672 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
97673 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
97674 : }
97675 : }
97676 : else
97677 : {
97678 0 : std::cout << "SgConcatenationOp :: " << std::flush;
97679 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
97680 0 : std::cout << " not valid " << std::endl;
97681 : }
97682 : }
97683 :
97684 0 : if ( p_expression_type != NULL )
97685 : {
97686 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97687 : {
97688 0 : if ( p_expression_type->isInMemoryPool() == false )
97689 : {
97690 0 : std::cout << "SgConcatenationOp :: ";
97691 0 : std::cout << " p_expression_type is not in memory pool of ";
97692 0 : std::cout << p_expression_type->class_name() << std::endl;
97693 : }
97694 : }
97695 : else
97696 : {
97697 0 : std::cout << "SgConcatenationOp :: " << std::flush;
97698 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
97699 0 : std::cout << " not valid " << std::endl;
97700 : }
97701 : }
97702 :
97703 0 : if ( p_originalExpressionTree != NULL )
97704 : {
97705 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97706 : {
97707 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
97708 : {
97709 0 : std::cout << "SgConcatenationOp :: ";
97710 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
97711 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
97712 : }
97713 : }
97714 : else
97715 : {
97716 0 : std::cout << "SgConcatenationOp :: " << std::flush;
97717 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
97718 0 : std::cout << " not valid " << std::endl;
97719 : }
97720 : }
97721 :
97722 0 : if ( p_operatorPosition != NULL )
97723 : {
97724 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97725 : {
97726 0 : if ( p_operatorPosition->isInMemoryPool() == false )
97727 : {
97728 0 : std::cout << "SgConcatenationOp :: ";
97729 0 : std::cout << " p_operatorPosition is not in memory pool of ";
97730 0 : std::cout << p_operatorPosition->class_name() << std::endl;
97731 : }
97732 : }
97733 : else
97734 : {
97735 0 : std::cout << "SgConcatenationOp :: " << std::flush;
97736 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
97737 0 : std::cout << " not valid " << std::endl;
97738 : }
97739 : }
97740 :
97741 0 : if ( p_startOfConstruct != NULL )
97742 : {
97743 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97744 : {
97745 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
97746 : {
97747 0 : std::cout << "SgConcatenationOp :: ";
97748 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
97749 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
97750 : }
97751 : }
97752 : else
97753 : {
97754 0 : std::cout << "SgConcatenationOp :: " << std::flush;
97755 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
97756 0 : std::cout << " not valid " << std::endl;
97757 : }
97758 : }
97759 :
97760 0 : if ( p_endOfConstruct != NULL )
97761 : {
97762 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97763 : {
97764 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
97765 : {
97766 0 : std::cout << "SgConcatenationOp :: ";
97767 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
97768 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
97769 : }
97770 : }
97771 : else
97772 : {
97773 0 : std::cout << "SgConcatenationOp :: " << std::flush;
97774 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
97775 0 : std::cout << " not valid " << std::endl;
97776 : }
97777 : }
97778 :
97779 0 : if ( p_parent != NULL )
97780 : {
97781 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97782 : {
97783 0 : if ( p_parent->isInMemoryPool() == false )
97784 : {
97785 0 : std::cout << "SgConcatenationOp :: ";
97786 0 : std::cout << " p_parent is not in memory pool of ";
97787 0 : std::cout << p_parent->class_name() << std::endl;
97788 : }
97789 : }
97790 : else
97791 : {
97792 0 : std::cout << "SgConcatenationOp :: " << std::flush;
97793 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
97794 0 : std::cout << " not valid " << std::endl;
97795 : }
97796 : }
97797 :
97798 :
97799 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
97800 :
97801 0 : }
97802 :
97803 :
97804 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
97805 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
97806 : bool
97807 0 : SgConcatenationOp::isInMemoryPool ()
97808 : {
97809 0 : typedef unsigned char* TestType;
97810 :
97811 0 : bool found = false;
97812 :
97813 0 : ROSE_ASSERT(this != NULL);
97814 :
97815 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
97816 :
97817 0 : TestType tested = (TestType) ( this ) ;
97818 :
97819 0 : std::vector < unsigned char* > :: const_iterator block = SgConcatenationOp::pools.begin();
97820 :
97821 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
97822 : // while (found == false && block < Memory_Block_List.end())
97823 0 : while ( (found == false) && (block != SgConcatenationOp::pools.end()) )
97824 : {
97825 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgConcatenationOp::pool_size * sizeof(SgConcatenationOp) ) ) ;
97826 0 : ++block;
97827 : }
97828 :
97829 : // Special handling for static data
97830 :
97831 :
97832 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
97833 0 : ROSE_ASSERT(found == true);
97834 :
97835 0 : return found;
97836 : }
97837 : /* #line 97838 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
97838 :
97839 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
97840 :
97841 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
97842 :
97843 : /* #line 97844 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
97844 :
97845 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
97846 :
97847 : void
97848 0 : SgPointerAssignOp::checkDataMemberPointersIfInMemoryPool()
97849 : {
97850 : // ------------ checking pointers of SgPointerAssignOp -------------------
97851 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
97852 :
97853 0 : if ( p_lhs_operand_i != NULL )
97854 : {
97855 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97856 : {
97857 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
97858 : {
97859 0 : std::cout << "SgPointerAssignOp :: ";
97860 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
97861 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
97862 : }
97863 : }
97864 : else
97865 : {
97866 0 : std::cout << "SgPointerAssignOp :: " << std::flush;
97867 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
97868 0 : std::cout << " not valid " << std::endl;
97869 : }
97870 : }
97871 :
97872 0 : if ( p_rhs_operand_i != NULL )
97873 : {
97874 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97875 : {
97876 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
97877 : {
97878 0 : std::cout << "SgPointerAssignOp :: ";
97879 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
97880 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
97881 : }
97882 : }
97883 : else
97884 : {
97885 0 : std::cout << "SgPointerAssignOp :: " << std::flush;
97886 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
97887 0 : std::cout << " not valid " << std::endl;
97888 : }
97889 : }
97890 :
97891 0 : if ( p_expression_type != NULL )
97892 : {
97893 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97894 : {
97895 0 : if ( p_expression_type->isInMemoryPool() == false )
97896 : {
97897 0 : std::cout << "SgPointerAssignOp :: ";
97898 0 : std::cout << " p_expression_type is not in memory pool of ";
97899 0 : std::cout << p_expression_type->class_name() << std::endl;
97900 : }
97901 : }
97902 : else
97903 : {
97904 0 : std::cout << "SgPointerAssignOp :: " << std::flush;
97905 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
97906 0 : std::cout << " not valid " << std::endl;
97907 : }
97908 : }
97909 :
97910 0 : if ( p_originalExpressionTree != NULL )
97911 : {
97912 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97913 : {
97914 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
97915 : {
97916 0 : std::cout << "SgPointerAssignOp :: ";
97917 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
97918 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
97919 : }
97920 : }
97921 : else
97922 : {
97923 0 : std::cout << "SgPointerAssignOp :: " << std::flush;
97924 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
97925 0 : std::cout << " not valid " << std::endl;
97926 : }
97927 : }
97928 :
97929 0 : if ( p_operatorPosition != NULL )
97930 : {
97931 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97932 : {
97933 0 : if ( p_operatorPosition->isInMemoryPool() == false )
97934 : {
97935 0 : std::cout << "SgPointerAssignOp :: ";
97936 0 : std::cout << " p_operatorPosition is not in memory pool of ";
97937 0 : std::cout << p_operatorPosition->class_name() << std::endl;
97938 : }
97939 : }
97940 : else
97941 : {
97942 0 : std::cout << "SgPointerAssignOp :: " << std::flush;
97943 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
97944 0 : std::cout << " not valid " << std::endl;
97945 : }
97946 : }
97947 :
97948 0 : if ( p_startOfConstruct != NULL )
97949 : {
97950 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97951 : {
97952 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
97953 : {
97954 0 : std::cout << "SgPointerAssignOp :: ";
97955 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
97956 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
97957 : }
97958 : }
97959 : else
97960 : {
97961 0 : std::cout << "SgPointerAssignOp :: " << std::flush;
97962 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
97963 0 : std::cout << " not valid " << std::endl;
97964 : }
97965 : }
97966 :
97967 0 : if ( p_endOfConstruct != NULL )
97968 : {
97969 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97970 : {
97971 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
97972 : {
97973 0 : std::cout << "SgPointerAssignOp :: ";
97974 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
97975 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
97976 : }
97977 : }
97978 : else
97979 : {
97980 0 : std::cout << "SgPointerAssignOp :: " << std::flush;
97981 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
97982 0 : std::cout << " not valid " << std::endl;
97983 : }
97984 : }
97985 :
97986 0 : if ( p_parent != NULL )
97987 : {
97988 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
97989 : {
97990 0 : if ( p_parent->isInMemoryPool() == false )
97991 : {
97992 0 : std::cout << "SgPointerAssignOp :: ";
97993 0 : std::cout << " p_parent is not in memory pool of ";
97994 0 : std::cout << p_parent->class_name() << std::endl;
97995 : }
97996 : }
97997 : else
97998 : {
97999 0 : std::cout << "SgPointerAssignOp :: " << std::flush;
98000 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
98001 0 : std::cout << " not valid " << std::endl;
98002 : }
98003 : }
98004 :
98005 :
98006 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
98007 :
98008 0 : }
98009 :
98010 :
98011 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
98012 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
98013 : bool
98014 0 : SgPointerAssignOp::isInMemoryPool ()
98015 : {
98016 0 : typedef unsigned char* TestType;
98017 :
98018 0 : bool found = false;
98019 :
98020 0 : ROSE_ASSERT(this != NULL);
98021 :
98022 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
98023 :
98024 0 : TestType tested = (TestType) ( this ) ;
98025 :
98026 0 : std::vector < unsigned char* > :: const_iterator block = SgPointerAssignOp::pools.begin();
98027 :
98028 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
98029 : // while (found == false && block < Memory_Block_List.end())
98030 0 : while ( (found == false) && (block != SgPointerAssignOp::pools.end()) )
98031 : {
98032 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgPointerAssignOp::pool_size * sizeof(SgPointerAssignOp) ) ) ;
98033 0 : ++block;
98034 : }
98035 :
98036 : // Special handling for static data
98037 :
98038 :
98039 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
98040 0 : ROSE_ASSERT(found == true);
98041 :
98042 0 : return found;
98043 : }
98044 : /* #line 98045 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
98045 :
98046 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
98047 :
98048 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
98049 :
98050 : /* #line 98051 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
98051 :
98052 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
98053 :
98054 : void
98055 0 : SgUserDefinedBinaryOp::checkDataMemberPointersIfInMemoryPool()
98056 : {
98057 : // ------------ checking pointers of SgUserDefinedBinaryOp -------------------
98058 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
98059 :
98060 0 : if ( p_symbol != NULL )
98061 : {
98062 0 : if ( p_symbol->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98063 : {
98064 0 : if ( p_symbol->isInMemoryPool() == false )
98065 : {
98066 0 : std::cout << "SgUserDefinedBinaryOp :: ";
98067 0 : std::cout << " p_symbol is not in memory pool of ";
98068 0 : std::cout << p_symbol->class_name() << std::endl;
98069 : }
98070 : }
98071 : else
98072 : {
98073 0 : std::cout << "SgUserDefinedBinaryOp :: " << std::flush;
98074 0 : std::cout << "SgFunctionSymbol* p_symbol = " << p_symbol << " --> " << std::flush;
98075 0 : std::cout << " not valid " << std::endl;
98076 : }
98077 : }
98078 :
98079 0 : if ( p_lhs_operand_i != NULL )
98080 : {
98081 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98082 : {
98083 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
98084 : {
98085 0 : std::cout << "SgUserDefinedBinaryOp :: ";
98086 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
98087 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
98088 : }
98089 : }
98090 : else
98091 : {
98092 0 : std::cout << "SgUserDefinedBinaryOp :: " << std::flush;
98093 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
98094 0 : std::cout << " not valid " << std::endl;
98095 : }
98096 : }
98097 :
98098 0 : if ( p_rhs_operand_i != NULL )
98099 : {
98100 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98101 : {
98102 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
98103 : {
98104 0 : std::cout << "SgUserDefinedBinaryOp :: ";
98105 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
98106 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
98107 : }
98108 : }
98109 : else
98110 : {
98111 0 : std::cout << "SgUserDefinedBinaryOp :: " << std::flush;
98112 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
98113 0 : std::cout << " not valid " << std::endl;
98114 : }
98115 : }
98116 :
98117 0 : if ( p_expression_type != NULL )
98118 : {
98119 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98120 : {
98121 0 : if ( p_expression_type->isInMemoryPool() == false )
98122 : {
98123 0 : std::cout << "SgUserDefinedBinaryOp :: ";
98124 0 : std::cout << " p_expression_type is not in memory pool of ";
98125 0 : std::cout << p_expression_type->class_name() << std::endl;
98126 : }
98127 : }
98128 : else
98129 : {
98130 0 : std::cout << "SgUserDefinedBinaryOp :: " << std::flush;
98131 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
98132 0 : std::cout << " not valid " << std::endl;
98133 : }
98134 : }
98135 :
98136 0 : if ( p_originalExpressionTree != NULL )
98137 : {
98138 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98139 : {
98140 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
98141 : {
98142 0 : std::cout << "SgUserDefinedBinaryOp :: ";
98143 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
98144 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
98145 : }
98146 : }
98147 : else
98148 : {
98149 0 : std::cout << "SgUserDefinedBinaryOp :: " << std::flush;
98150 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
98151 0 : std::cout << " not valid " << std::endl;
98152 : }
98153 : }
98154 :
98155 0 : if ( p_operatorPosition != NULL )
98156 : {
98157 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98158 : {
98159 0 : if ( p_operatorPosition->isInMemoryPool() == false )
98160 : {
98161 0 : std::cout << "SgUserDefinedBinaryOp :: ";
98162 0 : std::cout << " p_operatorPosition is not in memory pool of ";
98163 0 : std::cout << p_operatorPosition->class_name() << std::endl;
98164 : }
98165 : }
98166 : else
98167 : {
98168 0 : std::cout << "SgUserDefinedBinaryOp :: " << std::flush;
98169 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
98170 0 : std::cout << " not valid " << std::endl;
98171 : }
98172 : }
98173 :
98174 0 : if ( p_startOfConstruct != NULL )
98175 : {
98176 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98177 : {
98178 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
98179 : {
98180 0 : std::cout << "SgUserDefinedBinaryOp :: ";
98181 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
98182 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
98183 : }
98184 : }
98185 : else
98186 : {
98187 0 : std::cout << "SgUserDefinedBinaryOp :: " << std::flush;
98188 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
98189 0 : std::cout << " not valid " << std::endl;
98190 : }
98191 : }
98192 :
98193 0 : if ( p_endOfConstruct != NULL )
98194 : {
98195 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98196 : {
98197 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
98198 : {
98199 0 : std::cout << "SgUserDefinedBinaryOp :: ";
98200 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
98201 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
98202 : }
98203 : }
98204 : else
98205 : {
98206 0 : std::cout << "SgUserDefinedBinaryOp :: " << std::flush;
98207 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
98208 0 : std::cout << " not valid " << std::endl;
98209 : }
98210 : }
98211 :
98212 0 : if ( p_parent != NULL )
98213 : {
98214 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98215 : {
98216 0 : if ( p_parent->isInMemoryPool() == false )
98217 : {
98218 0 : std::cout << "SgUserDefinedBinaryOp :: ";
98219 0 : std::cout << " p_parent is not in memory pool of ";
98220 0 : std::cout << p_parent->class_name() << std::endl;
98221 : }
98222 : }
98223 : else
98224 : {
98225 0 : std::cout << "SgUserDefinedBinaryOp :: " << std::flush;
98226 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
98227 0 : std::cout << " not valid " << std::endl;
98228 : }
98229 : }
98230 :
98231 :
98232 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
98233 :
98234 0 : }
98235 :
98236 :
98237 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
98238 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
98239 : bool
98240 0 : SgUserDefinedBinaryOp::isInMemoryPool ()
98241 : {
98242 0 : typedef unsigned char* TestType;
98243 :
98244 0 : bool found = false;
98245 :
98246 0 : ROSE_ASSERT(this != NULL);
98247 :
98248 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
98249 :
98250 0 : TestType tested = (TestType) ( this ) ;
98251 :
98252 0 : std::vector < unsigned char* > :: const_iterator block = SgUserDefinedBinaryOp::pools.begin();
98253 :
98254 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
98255 : // while (found == false && block < Memory_Block_List.end())
98256 0 : while ( (found == false) && (block != SgUserDefinedBinaryOp::pools.end()) )
98257 : {
98258 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUserDefinedBinaryOp::pool_size * sizeof(SgUserDefinedBinaryOp) ) ) ;
98259 0 : ++block;
98260 : }
98261 :
98262 : // Special handling for static data
98263 :
98264 :
98265 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
98266 0 : ROSE_ASSERT(found == true);
98267 :
98268 0 : return found;
98269 : }
98270 : /* #line 98271 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
98271 :
98272 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
98273 :
98274 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
98275 :
98276 : /* #line 98277 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
98277 :
98278 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
98279 :
98280 : void
98281 0 : SgCompoundAssignOp::checkDataMemberPointersIfInMemoryPool()
98282 : {
98283 : // ------------ checking pointers of SgCompoundAssignOp -------------------
98284 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
98285 :
98286 0 : if ( p_lhs_operand_i != NULL )
98287 : {
98288 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98289 : {
98290 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
98291 : {
98292 0 : std::cout << "SgCompoundAssignOp :: ";
98293 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
98294 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
98295 : }
98296 : }
98297 : else
98298 : {
98299 0 : std::cout << "SgCompoundAssignOp :: " << std::flush;
98300 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
98301 0 : std::cout << " not valid " << std::endl;
98302 : }
98303 : }
98304 :
98305 0 : if ( p_rhs_operand_i != NULL )
98306 : {
98307 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98308 : {
98309 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
98310 : {
98311 0 : std::cout << "SgCompoundAssignOp :: ";
98312 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
98313 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
98314 : }
98315 : }
98316 : else
98317 : {
98318 0 : std::cout << "SgCompoundAssignOp :: " << std::flush;
98319 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
98320 0 : std::cout << " not valid " << std::endl;
98321 : }
98322 : }
98323 :
98324 0 : if ( p_expression_type != NULL )
98325 : {
98326 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98327 : {
98328 0 : if ( p_expression_type->isInMemoryPool() == false )
98329 : {
98330 0 : std::cout << "SgCompoundAssignOp :: ";
98331 0 : std::cout << " p_expression_type is not in memory pool of ";
98332 0 : std::cout << p_expression_type->class_name() << std::endl;
98333 : }
98334 : }
98335 : else
98336 : {
98337 0 : std::cout << "SgCompoundAssignOp :: " << std::flush;
98338 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
98339 0 : std::cout << " not valid " << std::endl;
98340 : }
98341 : }
98342 :
98343 0 : if ( p_originalExpressionTree != NULL )
98344 : {
98345 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98346 : {
98347 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
98348 : {
98349 0 : std::cout << "SgCompoundAssignOp :: ";
98350 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
98351 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
98352 : }
98353 : }
98354 : else
98355 : {
98356 0 : std::cout << "SgCompoundAssignOp :: " << std::flush;
98357 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
98358 0 : std::cout << " not valid " << std::endl;
98359 : }
98360 : }
98361 :
98362 0 : if ( p_operatorPosition != NULL )
98363 : {
98364 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98365 : {
98366 0 : if ( p_operatorPosition->isInMemoryPool() == false )
98367 : {
98368 0 : std::cout << "SgCompoundAssignOp :: ";
98369 0 : std::cout << " p_operatorPosition is not in memory pool of ";
98370 0 : std::cout << p_operatorPosition->class_name() << std::endl;
98371 : }
98372 : }
98373 : else
98374 : {
98375 0 : std::cout << "SgCompoundAssignOp :: " << std::flush;
98376 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
98377 0 : std::cout << " not valid " << std::endl;
98378 : }
98379 : }
98380 :
98381 0 : if ( p_startOfConstruct != NULL )
98382 : {
98383 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98384 : {
98385 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
98386 : {
98387 0 : std::cout << "SgCompoundAssignOp :: ";
98388 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
98389 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
98390 : }
98391 : }
98392 : else
98393 : {
98394 0 : std::cout << "SgCompoundAssignOp :: " << std::flush;
98395 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
98396 0 : std::cout << " not valid " << std::endl;
98397 : }
98398 : }
98399 :
98400 0 : if ( p_endOfConstruct != NULL )
98401 : {
98402 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98403 : {
98404 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
98405 : {
98406 0 : std::cout << "SgCompoundAssignOp :: ";
98407 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
98408 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
98409 : }
98410 : }
98411 : else
98412 : {
98413 0 : std::cout << "SgCompoundAssignOp :: " << std::flush;
98414 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
98415 0 : std::cout << " not valid " << std::endl;
98416 : }
98417 : }
98418 :
98419 0 : if ( p_parent != NULL )
98420 : {
98421 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98422 : {
98423 0 : if ( p_parent->isInMemoryPool() == false )
98424 : {
98425 0 : std::cout << "SgCompoundAssignOp :: ";
98426 0 : std::cout << " p_parent is not in memory pool of ";
98427 0 : std::cout << p_parent->class_name() << std::endl;
98428 : }
98429 : }
98430 : else
98431 : {
98432 0 : std::cout << "SgCompoundAssignOp :: " << std::flush;
98433 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
98434 0 : std::cout << " not valid " << std::endl;
98435 : }
98436 : }
98437 :
98438 :
98439 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
98440 :
98441 0 : }
98442 :
98443 :
98444 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
98445 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
98446 : bool
98447 0 : SgCompoundAssignOp::isInMemoryPool ()
98448 : {
98449 0 : typedef unsigned char* TestType;
98450 :
98451 0 : bool found = false;
98452 :
98453 0 : ROSE_ASSERT(this != NULL);
98454 :
98455 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
98456 :
98457 0 : TestType tested = (TestType) ( this ) ;
98458 :
98459 0 : std::vector < unsigned char* > :: const_iterator block = SgCompoundAssignOp::pools.begin();
98460 :
98461 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
98462 : // while (found == false && block < Memory_Block_List.end())
98463 0 : while ( (found == false) && (block != SgCompoundAssignOp::pools.end()) )
98464 : {
98465 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCompoundAssignOp::pool_size * sizeof(SgCompoundAssignOp) ) ) ;
98466 0 : ++block;
98467 : }
98468 :
98469 : // Special handling for static data
98470 :
98471 :
98472 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
98473 0 : ROSE_ASSERT(found == true);
98474 :
98475 0 : return found;
98476 : }
98477 : /* #line 98478 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
98478 :
98479 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
98480 :
98481 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
98482 :
98483 : /* #line 98484 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
98484 :
98485 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
98486 :
98487 : void
98488 0 : SgPlusAssignOp::checkDataMemberPointersIfInMemoryPool()
98489 : {
98490 : // ------------ checking pointers of SgPlusAssignOp -------------------
98491 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
98492 :
98493 0 : if ( p_lhs_operand_i != NULL )
98494 : {
98495 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98496 : {
98497 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
98498 : {
98499 0 : std::cout << "SgPlusAssignOp :: ";
98500 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
98501 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
98502 : }
98503 : }
98504 : else
98505 : {
98506 0 : std::cout << "SgPlusAssignOp :: " << std::flush;
98507 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
98508 0 : std::cout << " not valid " << std::endl;
98509 : }
98510 : }
98511 :
98512 0 : if ( p_rhs_operand_i != NULL )
98513 : {
98514 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98515 : {
98516 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
98517 : {
98518 0 : std::cout << "SgPlusAssignOp :: ";
98519 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
98520 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
98521 : }
98522 : }
98523 : else
98524 : {
98525 0 : std::cout << "SgPlusAssignOp :: " << std::flush;
98526 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
98527 0 : std::cout << " not valid " << std::endl;
98528 : }
98529 : }
98530 :
98531 0 : if ( p_expression_type != NULL )
98532 : {
98533 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98534 : {
98535 0 : if ( p_expression_type->isInMemoryPool() == false )
98536 : {
98537 0 : std::cout << "SgPlusAssignOp :: ";
98538 0 : std::cout << " p_expression_type is not in memory pool of ";
98539 0 : std::cout << p_expression_type->class_name() << std::endl;
98540 : }
98541 : }
98542 : else
98543 : {
98544 0 : std::cout << "SgPlusAssignOp :: " << std::flush;
98545 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
98546 0 : std::cout << " not valid " << std::endl;
98547 : }
98548 : }
98549 :
98550 0 : if ( p_originalExpressionTree != NULL )
98551 : {
98552 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98553 : {
98554 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
98555 : {
98556 0 : std::cout << "SgPlusAssignOp :: ";
98557 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
98558 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
98559 : }
98560 : }
98561 : else
98562 : {
98563 0 : std::cout << "SgPlusAssignOp :: " << std::flush;
98564 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
98565 0 : std::cout << " not valid " << std::endl;
98566 : }
98567 : }
98568 :
98569 0 : if ( p_operatorPosition != NULL )
98570 : {
98571 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98572 : {
98573 0 : if ( p_operatorPosition->isInMemoryPool() == false )
98574 : {
98575 0 : std::cout << "SgPlusAssignOp :: ";
98576 0 : std::cout << " p_operatorPosition is not in memory pool of ";
98577 0 : std::cout << p_operatorPosition->class_name() << std::endl;
98578 : }
98579 : }
98580 : else
98581 : {
98582 0 : std::cout << "SgPlusAssignOp :: " << std::flush;
98583 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
98584 0 : std::cout << " not valid " << std::endl;
98585 : }
98586 : }
98587 :
98588 0 : if ( p_startOfConstruct != NULL )
98589 : {
98590 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98591 : {
98592 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
98593 : {
98594 0 : std::cout << "SgPlusAssignOp :: ";
98595 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
98596 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
98597 : }
98598 : }
98599 : else
98600 : {
98601 0 : std::cout << "SgPlusAssignOp :: " << std::flush;
98602 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
98603 0 : std::cout << " not valid " << std::endl;
98604 : }
98605 : }
98606 :
98607 0 : if ( p_endOfConstruct != NULL )
98608 : {
98609 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98610 : {
98611 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
98612 : {
98613 0 : std::cout << "SgPlusAssignOp :: ";
98614 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
98615 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
98616 : }
98617 : }
98618 : else
98619 : {
98620 0 : std::cout << "SgPlusAssignOp :: " << std::flush;
98621 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
98622 0 : std::cout << " not valid " << std::endl;
98623 : }
98624 : }
98625 :
98626 0 : if ( p_parent != NULL )
98627 : {
98628 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98629 : {
98630 0 : if ( p_parent->isInMemoryPool() == false )
98631 : {
98632 0 : std::cout << "SgPlusAssignOp :: ";
98633 0 : std::cout << " p_parent is not in memory pool of ";
98634 0 : std::cout << p_parent->class_name() << std::endl;
98635 : }
98636 : }
98637 : else
98638 : {
98639 0 : std::cout << "SgPlusAssignOp :: " << std::flush;
98640 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
98641 0 : std::cout << " not valid " << std::endl;
98642 : }
98643 : }
98644 :
98645 :
98646 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
98647 :
98648 0 : }
98649 :
98650 :
98651 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
98652 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
98653 : bool
98654 0 : SgPlusAssignOp::isInMemoryPool ()
98655 : {
98656 0 : typedef unsigned char* TestType;
98657 :
98658 0 : bool found = false;
98659 :
98660 0 : ROSE_ASSERT(this != NULL);
98661 :
98662 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
98663 :
98664 0 : TestType tested = (TestType) ( this ) ;
98665 :
98666 0 : std::vector < unsigned char* > :: const_iterator block = SgPlusAssignOp::pools.begin();
98667 :
98668 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
98669 : // while (found == false && block < Memory_Block_List.end())
98670 0 : while ( (found == false) && (block != SgPlusAssignOp::pools.end()) )
98671 : {
98672 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgPlusAssignOp::pool_size * sizeof(SgPlusAssignOp) ) ) ;
98673 0 : ++block;
98674 : }
98675 :
98676 : // Special handling for static data
98677 :
98678 :
98679 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
98680 0 : ROSE_ASSERT(found == true);
98681 :
98682 0 : return found;
98683 : }
98684 : /* #line 98685 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
98685 :
98686 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
98687 :
98688 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
98689 :
98690 : /* #line 98691 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
98691 :
98692 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
98693 :
98694 : void
98695 0 : SgMinusAssignOp::checkDataMemberPointersIfInMemoryPool()
98696 : {
98697 : // ------------ checking pointers of SgMinusAssignOp -------------------
98698 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
98699 :
98700 0 : if ( p_lhs_operand_i != NULL )
98701 : {
98702 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98703 : {
98704 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
98705 : {
98706 0 : std::cout << "SgMinusAssignOp :: ";
98707 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
98708 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
98709 : }
98710 : }
98711 : else
98712 : {
98713 0 : std::cout << "SgMinusAssignOp :: " << std::flush;
98714 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
98715 0 : std::cout << " not valid " << std::endl;
98716 : }
98717 : }
98718 :
98719 0 : if ( p_rhs_operand_i != NULL )
98720 : {
98721 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98722 : {
98723 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
98724 : {
98725 0 : std::cout << "SgMinusAssignOp :: ";
98726 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
98727 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
98728 : }
98729 : }
98730 : else
98731 : {
98732 0 : std::cout << "SgMinusAssignOp :: " << std::flush;
98733 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
98734 0 : std::cout << " not valid " << std::endl;
98735 : }
98736 : }
98737 :
98738 0 : if ( p_expression_type != NULL )
98739 : {
98740 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98741 : {
98742 0 : if ( p_expression_type->isInMemoryPool() == false )
98743 : {
98744 0 : std::cout << "SgMinusAssignOp :: ";
98745 0 : std::cout << " p_expression_type is not in memory pool of ";
98746 0 : std::cout << p_expression_type->class_name() << std::endl;
98747 : }
98748 : }
98749 : else
98750 : {
98751 0 : std::cout << "SgMinusAssignOp :: " << std::flush;
98752 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
98753 0 : std::cout << " not valid " << std::endl;
98754 : }
98755 : }
98756 :
98757 0 : if ( p_originalExpressionTree != NULL )
98758 : {
98759 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98760 : {
98761 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
98762 : {
98763 0 : std::cout << "SgMinusAssignOp :: ";
98764 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
98765 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
98766 : }
98767 : }
98768 : else
98769 : {
98770 0 : std::cout << "SgMinusAssignOp :: " << std::flush;
98771 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
98772 0 : std::cout << " not valid " << std::endl;
98773 : }
98774 : }
98775 :
98776 0 : if ( p_operatorPosition != NULL )
98777 : {
98778 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98779 : {
98780 0 : if ( p_operatorPosition->isInMemoryPool() == false )
98781 : {
98782 0 : std::cout << "SgMinusAssignOp :: ";
98783 0 : std::cout << " p_operatorPosition is not in memory pool of ";
98784 0 : std::cout << p_operatorPosition->class_name() << std::endl;
98785 : }
98786 : }
98787 : else
98788 : {
98789 0 : std::cout << "SgMinusAssignOp :: " << std::flush;
98790 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
98791 0 : std::cout << " not valid " << std::endl;
98792 : }
98793 : }
98794 :
98795 0 : if ( p_startOfConstruct != NULL )
98796 : {
98797 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98798 : {
98799 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
98800 : {
98801 0 : std::cout << "SgMinusAssignOp :: ";
98802 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
98803 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
98804 : }
98805 : }
98806 : else
98807 : {
98808 0 : std::cout << "SgMinusAssignOp :: " << std::flush;
98809 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
98810 0 : std::cout << " not valid " << std::endl;
98811 : }
98812 : }
98813 :
98814 0 : if ( p_endOfConstruct != NULL )
98815 : {
98816 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98817 : {
98818 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
98819 : {
98820 0 : std::cout << "SgMinusAssignOp :: ";
98821 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
98822 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
98823 : }
98824 : }
98825 : else
98826 : {
98827 0 : std::cout << "SgMinusAssignOp :: " << std::flush;
98828 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
98829 0 : std::cout << " not valid " << std::endl;
98830 : }
98831 : }
98832 :
98833 0 : if ( p_parent != NULL )
98834 : {
98835 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98836 : {
98837 0 : if ( p_parent->isInMemoryPool() == false )
98838 : {
98839 0 : std::cout << "SgMinusAssignOp :: ";
98840 0 : std::cout << " p_parent is not in memory pool of ";
98841 0 : std::cout << p_parent->class_name() << std::endl;
98842 : }
98843 : }
98844 : else
98845 : {
98846 0 : std::cout << "SgMinusAssignOp :: " << std::flush;
98847 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
98848 0 : std::cout << " not valid " << std::endl;
98849 : }
98850 : }
98851 :
98852 :
98853 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
98854 :
98855 0 : }
98856 :
98857 :
98858 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
98859 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
98860 : bool
98861 0 : SgMinusAssignOp::isInMemoryPool ()
98862 : {
98863 0 : typedef unsigned char* TestType;
98864 :
98865 0 : bool found = false;
98866 :
98867 0 : ROSE_ASSERT(this != NULL);
98868 :
98869 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
98870 :
98871 0 : TestType tested = (TestType) ( this ) ;
98872 :
98873 0 : std::vector < unsigned char* > :: const_iterator block = SgMinusAssignOp::pools.begin();
98874 :
98875 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
98876 : // while (found == false && block < Memory_Block_List.end())
98877 0 : while ( (found == false) && (block != SgMinusAssignOp::pools.end()) )
98878 : {
98879 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgMinusAssignOp::pool_size * sizeof(SgMinusAssignOp) ) ) ;
98880 0 : ++block;
98881 : }
98882 :
98883 : // Special handling for static data
98884 :
98885 :
98886 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
98887 0 : ROSE_ASSERT(found == true);
98888 :
98889 0 : return found;
98890 : }
98891 : /* #line 98892 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
98892 :
98893 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
98894 :
98895 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
98896 :
98897 : /* #line 98898 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
98898 :
98899 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
98900 :
98901 : void
98902 0 : SgAndAssignOp::checkDataMemberPointersIfInMemoryPool()
98903 : {
98904 : // ------------ checking pointers of SgAndAssignOp -------------------
98905 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
98906 :
98907 0 : if ( p_lhs_operand_i != NULL )
98908 : {
98909 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98910 : {
98911 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
98912 : {
98913 0 : std::cout << "SgAndAssignOp :: ";
98914 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
98915 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
98916 : }
98917 : }
98918 : else
98919 : {
98920 0 : std::cout << "SgAndAssignOp :: " << std::flush;
98921 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
98922 0 : std::cout << " not valid " << std::endl;
98923 : }
98924 : }
98925 :
98926 0 : if ( p_rhs_operand_i != NULL )
98927 : {
98928 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98929 : {
98930 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
98931 : {
98932 0 : std::cout << "SgAndAssignOp :: ";
98933 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
98934 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
98935 : }
98936 : }
98937 : else
98938 : {
98939 0 : std::cout << "SgAndAssignOp :: " << std::flush;
98940 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
98941 0 : std::cout << " not valid " << std::endl;
98942 : }
98943 : }
98944 :
98945 0 : if ( p_expression_type != NULL )
98946 : {
98947 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98948 : {
98949 0 : if ( p_expression_type->isInMemoryPool() == false )
98950 : {
98951 0 : std::cout << "SgAndAssignOp :: ";
98952 0 : std::cout << " p_expression_type is not in memory pool of ";
98953 0 : std::cout << p_expression_type->class_name() << std::endl;
98954 : }
98955 : }
98956 : else
98957 : {
98958 0 : std::cout << "SgAndAssignOp :: " << std::flush;
98959 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
98960 0 : std::cout << " not valid " << std::endl;
98961 : }
98962 : }
98963 :
98964 0 : if ( p_originalExpressionTree != NULL )
98965 : {
98966 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98967 : {
98968 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
98969 : {
98970 0 : std::cout << "SgAndAssignOp :: ";
98971 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
98972 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
98973 : }
98974 : }
98975 : else
98976 : {
98977 0 : std::cout << "SgAndAssignOp :: " << std::flush;
98978 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
98979 0 : std::cout << " not valid " << std::endl;
98980 : }
98981 : }
98982 :
98983 0 : if ( p_operatorPosition != NULL )
98984 : {
98985 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
98986 : {
98987 0 : if ( p_operatorPosition->isInMemoryPool() == false )
98988 : {
98989 0 : std::cout << "SgAndAssignOp :: ";
98990 0 : std::cout << " p_operatorPosition is not in memory pool of ";
98991 0 : std::cout << p_operatorPosition->class_name() << std::endl;
98992 : }
98993 : }
98994 : else
98995 : {
98996 0 : std::cout << "SgAndAssignOp :: " << std::flush;
98997 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
98998 0 : std::cout << " not valid " << std::endl;
98999 : }
99000 : }
99001 :
99002 0 : if ( p_startOfConstruct != NULL )
99003 : {
99004 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99005 : {
99006 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
99007 : {
99008 0 : std::cout << "SgAndAssignOp :: ";
99009 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
99010 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
99011 : }
99012 : }
99013 : else
99014 : {
99015 0 : std::cout << "SgAndAssignOp :: " << std::flush;
99016 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
99017 0 : std::cout << " not valid " << std::endl;
99018 : }
99019 : }
99020 :
99021 0 : if ( p_endOfConstruct != NULL )
99022 : {
99023 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99024 : {
99025 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
99026 : {
99027 0 : std::cout << "SgAndAssignOp :: ";
99028 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
99029 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
99030 : }
99031 : }
99032 : else
99033 : {
99034 0 : std::cout << "SgAndAssignOp :: " << std::flush;
99035 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
99036 0 : std::cout << " not valid " << std::endl;
99037 : }
99038 : }
99039 :
99040 0 : if ( p_parent != NULL )
99041 : {
99042 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99043 : {
99044 0 : if ( p_parent->isInMemoryPool() == false )
99045 : {
99046 0 : std::cout << "SgAndAssignOp :: ";
99047 0 : std::cout << " p_parent is not in memory pool of ";
99048 0 : std::cout << p_parent->class_name() << std::endl;
99049 : }
99050 : }
99051 : else
99052 : {
99053 0 : std::cout << "SgAndAssignOp :: " << std::flush;
99054 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
99055 0 : std::cout << " not valid " << std::endl;
99056 : }
99057 : }
99058 :
99059 :
99060 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
99061 :
99062 0 : }
99063 :
99064 :
99065 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
99066 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
99067 : bool
99068 0 : SgAndAssignOp::isInMemoryPool ()
99069 : {
99070 0 : typedef unsigned char* TestType;
99071 :
99072 0 : bool found = false;
99073 :
99074 0 : ROSE_ASSERT(this != NULL);
99075 :
99076 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
99077 :
99078 0 : TestType tested = (TestType) ( this ) ;
99079 :
99080 0 : std::vector < unsigned char* > :: const_iterator block = SgAndAssignOp::pools.begin();
99081 :
99082 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
99083 : // while (found == false && block < Memory_Block_List.end())
99084 0 : while ( (found == false) && (block != SgAndAssignOp::pools.end()) )
99085 : {
99086 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAndAssignOp::pool_size * sizeof(SgAndAssignOp) ) ) ;
99087 0 : ++block;
99088 : }
99089 :
99090 : // Special handling for static data
99091 :
99092 :
99093 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
99094 0 : ROSE_ASSERT(found == true);
99095 :
99096 0 : return found;
99097 : }
99098 : /* #line 99099 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
99099 :
99100 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
99101 :
99102 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
99103 :
99104 : /* #line 99105 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
99105 :
99106 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
99107 :
99108 : void
99109 0 : SgIorAssignOp::checkDataMemberPointersIfInMemoryPool()
99110 : {
99111 : // ------------ checking pointers of SgIorAssignOp -------------------
99112 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
99113 :
99114 0 : if ( p_lhs_operand_i != NULL )
99115 : {
99116 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99117 : {
99118 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
99119 : {
99120 0 : std::cout << "SgIorAssignOp :: ";
99121 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
99122 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
99123 : }
99124 : }
99125 : else
99126 : {
99127 0 : std::cout << "SgIorAssignOp :: " << std::flush;
99128 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
99129 0 : std::cout << " not valid " << std::endl;
99130 : }
99131 : }
99132 :
99133 0 : if ( p_rhs_operand_i != NULL )
99134 : {
99135 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99136 : {
99137 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
99138 : {
99139 0 : std::cout << "SgIorAssignOp :: ";
99140 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
99141 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
99142 : }
99143 : }
99144 : else
99145 : {
99146 0 : std::cout << "SgIorAssignOp :: " << std::flush;
99147 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
99148 0 : std::cout << " not valid " << std::endl;
99149 : }
99150 : }
99151 :
99152 0 : if ( p_expression_type != NULL )
99153 : {
99154 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99155 : {
99156 0 : if ( p_expression_type->isInMemoryPool() == false )
99157 : {
99158 0 : std::cout << "SgIorAssignOp :: ";
99159 0 : std::cout << " p_expression_type is not in memory pool of ";
99160 0 : std::cout << p_expression_type->class_name() << std::endl;
99161 : }
99162 : }
99163 : else
99164 : {
99165 0 : std::cout << "SgIorAssignOp :: " << std::flush;
99166 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
99167 0 : std::cout << " not valid " << std::endl;
99168 : }
99169 : }
99170 :
99171 0 : if ( p_originalExpressionTree != NULL )
99172 : {
99173 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99174 : {
99175 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
99176 : {
99177 0 : std::cout << "SgIorAssignOp :: ";
99178 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
99179 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
99180 : }
99181 : }
99182 : else
99183 : {
99184 0 : std::cout << "SgIorAssignOp :: " << std::flush;
99185 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
99186 0 : std::cout << " not valid " << std::endl;
99187 : }
99188 : }
99189 :
99190 0 : if ( p_operatorPosition != NULL )
99191 : {
99192 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99193 : {
99194 0 : if ( p_operatorPosition->isInMemoryPool() == false )
99195 : {
99196 0 : std::cout << "SgIorAssignOp :: ";
99197 0 : std::cout << " p_operatorPosition is not in memory pool of ";
99198 0 : std::cout << p_operatorPosition->class_name() << std::endl;
99199 : }
99200 : }
99201 : else
99202 : {
99203 0 : std::cout << "SgIorAssignOp :: " << std::flush;
99204 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
99205 0 : std::cout << " not valid " << std::endl;
99206 : }
99207 : }
99208 :
99209 0 : if ( p_startOfConstruct != NULL )
99210 : {
99211 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99212 : {
99213 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
99214 : {
99215 0 : std::cout << "SgIorAssignOp :: ";
99216 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
99217 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
99218 : }
99219 : }
99220 : else
99221 : {
99222 0 : std::cout << "SgIorAssignOp :: " << std::flush;
99223 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
99224 0 : std::cout << " not valid " << std::endl;
99225 : }
99226 : }
99227 :
99228 0 : if ( p_endOfConstruct != NULL )
99229 : {
99230 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99231 : {
99232 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
99233 : {
99234 0 : std::cout << "SgIorAssignOp :: ";
99235 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
99236 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
99237 : }
99238 : }
99239 : else
99240 : {
99241 0 : std::cout << "SgIorAssignOp :: " << std::flush;
99242 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
99243 0 : std::cout << " not valid " << std::endl;
99244 : }
99245 : }
99246 :
99247 0 : if ( p_parent != NULL )
99248 : {
99249 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99250 : {
99251 0 : if ( p_parent->isInMemoryPool() == false )
99252 : {
99253 0 : std::cout << "SgIorAssignOp :: ";
99254 0 : std::cout << " p_parent is not in memory pool of ";
99255 0 : std::cout << p_parent->class_name() << std::endl;
99256 : }
99257 : }
99258 : else
99259 : {
99260 0 : std::cout << "SgIorAssignOp :: " << std::flush;
99261 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
99262 0 : std::cout << " not valid " << std::endl;
99263 : }
99264 : }
99265 :
99266 :
99267 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
99268 :
99269 0 : }
99270 :
99271 :
99272 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
99273 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
99274 : bool
99275 0 : SgIorAssignOp::isInMemoryPool ()
99276 : {
99277 0 : typedef unsigned char* TestType;
99278 :
99279 0 : bool found = false;
99280 :
99281 0 : ROSE_ASSERT(this != NULL);
99282 :
99283 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
99284 :
99285 0 : TestType tested = (TestType) ( this ) ;
99286 :
99287 0 : std::vector < unsigned char* > :: const_iterator block = SgIorAssignOp::pools.begin();
99288 :
99289 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
99290 : // while (found == false && block < Memory_Block_List.end())
99291 0 : while ( (found == false) && (block != SgIorAssignOp::pools.end()) )
99292 : {
99293 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIorAssignOp::pool_size * sizeof(SgIorAssignOp) ) ) ;
99294 0 : ++block;
99295 : }
99296 :
99297 : // Special handling for static data
99298 :
99299 :
99300 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
99301 0 : ROSE_ASSERT(found == true);
99302 :
99303 0 : return found;
99304 : }
99305 : /* #line 99306 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
99306 :
99307 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
99308 :
99309 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
99310 :
99311 : /* #line 99312 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
99312 :
99313 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
99314 :
99315 : void
99316 0 : SgMultAssignOp::checkDataMemberPointersIfInMemoryPool()
99317 : {
99318 : // ------------ checking pointers of SgMultAssignOp -------------------
99319 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
99320 :
99321 0 : if ( p_lhs_operand_i != NULL )
99322 : {
99323 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99324 : {
99325 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
99326 : {
99327 0 : std::cout << "SgMultAssignOp :: ";
99328 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
99329 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
99330 : }
99331 : }
99332 : else
99333 : {
99334 0 : std::cout << "SgMultAssignOp :: " << std::flush;
99335 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
99336 0 : std::cout << " not valid " << std::endl;
99337 : }
99338 : }
99339 :
99340 0 : if ( p_rhs_operand_i != NULL )
99341 : {
99342 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99343 : {
99344 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
99345 : {
99346 0 : std::cout << "SgMultAssignOp :: ";
99347 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
99348 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
99349 : }
99350 : }
99351 : else
99352 : {
99353 0 : std::cout << "SgMultAssignOp :: " << std::flush;
99354 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
99355 0 : std::cout << " not valid " << std::endl;
99356 : }
99357 : }
99358 :
99359 0 : if ( p_expression_type != NULL )
99360 : {
99361 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99362 : {
99363 0 : if ( p_expression_type->isInMemoryPool() == false )
99364 : {
99365 0 : std::cout << "SgMultAssignOp :: ";
99366 0 : std::cout << " p_expression_type is not in memory pool of ";
99367 0 : std::cout << p_expression_type->class_name() << std::endl;
99368 : }
99369 : }
99370 : else
99371 : {
99372 0 : std::cout << "SgMultAssignOp :: " << std::flush;
99373 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
99374 0 : std::cout << " not valid " << std::endl;
99375 : }
99376 : }
99377 :
99378 0 : if ( p_originalExpressionTree != NULL )
99379 : {
99380 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99381 : {
99382 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
99383 : {
99384 0 : std::cout << "SgMultAssignOp :: ";
99385 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
99386 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
99387 : }
99388 : }
99389 : else
99390 : {
99391 0 : std::cout << "SgMultAssignOp :: " << std::flush;
99392 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
99393 0 : std::cout << " not valid " << std::endl;
99394 : }
99395 : }
99396 :
99397 0 : if ( p_operatorPosition != NULL )
99398 : {
99399 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99400 : {
99401 0 : if ( p_operatorPosition->isInMemoryPool() == false )
99402 : {
99403 0 : std::cout << "SgMultAssignOp :: ";
99404 0 : std::cout << " p_operatorPosition is not in memory pool of ";
99405 0 : std::cout << p_operatorPosition->class_name() << std::endl;
99406 : }
99407 : }
99408 : else
99409 : {
99410 0 : std::cout << "SgMultAssignOp :: " << std::flush;
99411 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
99412 0 : std::cout << " not valid " << std::endl;
99413 : }
99414 : }
99415 :
99416 0 : if ( p_startOfConstruct != NULL )
99417 : {
99418 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99419 : {
99420 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
99421 : {
99422 0 : std::cout << "SgMultAssignOp :: ";
99423 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
99424 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
99425 : }
99426 : }
99427 : else
99428 : {
99429 0 : std::cout << "SgMultAssignOp :: " << std::flush;
99430 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
99431 0 : std::cout << " not valid " << std::endl;
99432 : }
99433 : }
99434 :
99435 0 : if ( p_endOfConstruct != NULL )
99436 : {
99437 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99438 : {
99439 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
99440 : {
99441 0 : std::cout << "SgMultAssignOp :: ";
99442 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
99443 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
99444 : }
99445 : }
99446 : else
99447 : {
99448 0 : std::cout << "SgMultAssignOp :: " << std::flush;
99449 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
99450 0 : std::cout << " not valid " << std::endl;
99451 : }
99452 : }
99453 :
99454 0 : if ( p_parent != NULL )
99455 : {
99456 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99457 : {
99458 0 : if ( p_parent->isInMemoryPool() == false )
99459 : {
99460 0 : std::cout << "SgMultAssignOp :: ";
99461 0 : std::cout << " p_parent is not in memory pool of ";
99462 0 : std::cout << p_parent->class_name() << std::endl;
99463 : }
99464 : }
99465 : else
99466 : {
99467 0 : std::cout << "SgMultAssignOp :: " << std::flush;
99468 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
99469 0 : std::cout << " not valid " << std::endl;
99470 : }
99471 : }
99472 :
99473 :
99474 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
99475 :
99476 0 : }
99477 :
99478 :
99479 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
99480 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
99481 : bool
99482 0 : SgMultAssignOp::isInMemoryPool ()
99483 : {
99484 0 : typedef unsigned char* TestType;
99485 :
99486 0 : bool found = false;
99487 :
99488 0 : ROSE_ASSERT(this != NULL);
99489 :
99490 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
99491 :
99492 0 : TestType tested = (TestType) ( this ) ;
99493 :
99494 0 : std::vector < unsigned char* > :: const_iterator block = SgMultAssignOp::pools.begin();
99495 :
99496 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
99497 : // while (found == false && block < Memory_Block_List.end())
99498 0 : while ( (found == false) && (block != SgMultAssignOp::pools.end()) )
99499 : {
99500 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgMultAssignOp::pool_size * sizeof(SgMultAssignOp) ) ) ;
99501 0 : ++block;
99502 : }
99503 :
99504 : // Special handling for static data
99505 :
99506 :
99507 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
99508 0 : ROSE_ASSERT(found == true);
99509 :
99510 0 : return found;
99511 : }
99512 : /* #line 99513 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
99513 :
99514 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
99515 :
99516 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
99517 :
99518 : /* #line 99519 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
99519 :
99520 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
99521 :
99522 : void
99523 0 : SgDivAssignOp::checkDataMemberPointersIfInMemoryPool()
99524 : {
99525 : // ------------ checking pointers of SgDivAssignOp -------------------
99526 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
99527 :
99528 0 : if ( p_lhs_operand_i != NULL )
99529 : {
99530 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99531 : {
99532 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
99533 : {
99534 0 : std::cout << "SgDivAssignOp :: ";
99535 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
99536 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
99537 : }
99538 : }
99539 : else
99540 : {
99541 0 : std::cout << "SgDivAssignOp :: " << std::flush;
99542 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
99543 0 : std::cout << " not valid " << std::endl;
99544 : }
99545 : }
99546 :
99547 0 : if ( p_rhs_operand_i != NULL )
99548 : {
99549 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99550 : {
99551 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
99552 : {
99553 0 : std::cout << "SgDivAssignOp :: ";
99554 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
99555 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
99556 : }
99557 : }
99558 : else
99559 : {
99560 0 : std::cout << "SgDivAssignOp :: " << std::flush;
99561 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
99562 0 : std::cout << " not valid " << std::endl;
99563 : }
99564 : }
99565 :
99566 0 : if ( p_expression_type != NULL )
99567 : {
99568 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99569 : {
99570 0 : if ( p_expression_type->isInMemoryPool() == false )
99571 : {
99572 0 : std::cout << "SgDivAssignOp :: ";
99573 0 : std::cout << " p_expression_type is not in memory pool of ";
99574 0 : std::cout << p_expression_type->class_name() << std::endl;
99575 : }
99576 : }
99577 : else
99578 : {
99579 0 : std::cout << "SgDivAssignOp :: " << std::flush;
99580 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
99581 0 : std::cout << " not valid " << std::endl;
99582 : }
99583 : }
99584 :
99585 0 : if ( p_originalExpressionTree != NULL )
99586 : {
99587 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99588 : {
99589 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
99590 : {
99591 0 : std::cout << "SgDivAssignOp :: ";
99592 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
99593 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
99594 : }
99595 : }
99596 : else
99597 : {
99598 0 : std::cout << "SgDivAssignOp :: " << std::flush;
99599 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
99600 0 : std::cout << " not valid " << std::endl;
99601 : }
99602 : }
99603 :
99604 0 : if ( p_operatorPosition != NULL )
99605 : {
99606 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99607 : {
99608 0 : if ( p_operatorPosition->isInMemoryPool() == false )
99609 : {
99610 0 : std::cout << "SgDivAssignOp :: ";
99611 0 : std::cout << " p_operatorPosition is not in memory pool of ";
99612 0 : std::cout << p_operatorPosition->class_name() << std::endl;
99613 : }
99614 : }
99615 : else
99616 : {
99617 0 : std::cout << "SgDivAssignOp :: " << std::flush;
99618 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
99619 0 : std::cout << " not valid " << std::endl;
99620 : }
99621 : }
99622 :
99623 0 : if ( p_startOfConstruct != NULL )
99624 : {
99625 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99626 : {
99627 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
99628 : {
99629 0 : std::cout << "SgDivAssignOp :: ";
99630 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
99631 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
99632 : }
99633 : }
99634 : else
99635 : {
99636 0 : std::cout << "SgDivAssignOp :: " << std::flush;
99637 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
99638 0 : std::cout << " not valid " << std::endl;
99639 : }
99640 : }
99641 :
99642 0 : if ( p_endOfConstruct != NULL )
99643 : {
99644 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99645 : {
99646 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
99647 : {
99648 0 : std::cout << "SgDivAssignOp :: ";
99649 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
99650 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
99651 : }
99652 : }
99653 : else
99654 : {
99655 0 : std::cout << "SgDivAssignOp :: " << std::flush;
99656 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
99657 0 : std::cout << " not valid " << std::endl;
99658 : }
99659 : }
99660 :
99661 0 : if ( p_parent != NULL )
99662 : {
99663 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99664 : {
99665 0 : if ( p_parent->isInMemoryPool() == false )
99666 : {
99667 0 : std::cout << "SgDivAssignOp :: ";
99668 0 : std::cout << " p_parent is not in memory pool of ";
99669 0 : std::cout << p_parent->class_name() << std::endl;
99670 : }
99671 : }
99672 : else
99673 : {
99674 0 : std::cout << "SgDivAssignOp :: " << std::flush;
99675 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
99676 0 : std::cout << " not valid " << std::endl;
99677 : }
99678 : }
99679 :
99680 :
99681 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
99682 :
99683 0 : }
99684 :
99685 :
99686 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
99687 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
99688 : bool
99689 0 : SgDivAssignOp::isInMemoryPool ()
99690 : {
99691 0 : typedef unsigned char* TestType;
99692 :
99693 0 : bool found = false;
99694 :
99695 0 : ROSE_ASSERT(this != NULL);
99696 :
99697 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
99698 :
99699 0 : TestType tested = (TestType) ( this ) ;
99700 :
99701 0 : std::vector < unsigned char* > :: const_iterator block = SgDivAssignOp::pools.begin();
99702 :
99703 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
99704 : // while (found == false && block < Memory_Block_List.end())
99705 0 : while ( (found == false) && (block != SgDivAssignOp::pools.end()) )
99706 : {
99707 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDivAssignOp::pool_size * sizeof(SgDivAssignOp) ) ) ;
99708 0 : ++block;
99709 : }
99710 :
99711 : // Special handling for static data
99712 :
99713 :
99714 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
99715 0 : ROSE_ASSERT(found == true);
99716 :
99717 0 : return found;
99718 : }
99719 : /* #line 99720 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
99720 :
99721 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
99722 :
99723 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
99724 :
99725 : /* #line 99726 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
99726 :
99727 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
99728 :
99729 : void
99730 0 : SgModAssignOp::checkDataMemberPointersIfInMemoryPool()
99731 : {
99732 : // ------------ checking pointers of SgModAssignOp -------------------
99733 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
99734 :
99735 0 : if ( p_lhs_operand_i != NULL )
99736 : {
99737 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99738 : {
99739 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
99740 : {
99741 0 : std::cout << "SgModAssignOp :: ";
99742 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
99743 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
99744 : }
99745 : }
99746 : else
99747 : {
99748 0 : std::cout << "SgModAssignOp :: " << std::flush;
99749 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
99750 0 : std::cout << " not valid " << std::endl;
99751 : }
99752 : }
99753 :
99754 0 : if ( p_rhs_operand_i != NULL )
99755 : {
99756 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99757 : {
99758 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
99759 : {
99760 0 : std::cout << "SgModAssignOp :: ";
99761 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
99762 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
99763 : }
99764 : }
99765 : else
99766 : {
99767 0 : std::cout << "SgModAssignOp :: " << std::flush;
99768 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
99769 0 : std::cout << " not valid " << std::endl;
99770 : }
99771 : }
99772 :
99773 0 : if ( p_expression_type != NULL )
99774 : {
99775 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99776 : {
99777 0 : if ( p_expression_type->isInMemoryPool() == false )
99778 : {
99779 0 : std::cout << "SgModAssignOp :: ";
99780 0 : std::cout << " p_expression_type is not in memory pool of ";
99781 0 : std::cout << p_expression_type->class_name() << std::endl;
99782 : }
99783 : }
99784 : else
99785 : {
99786 0 : std::cout << "SgModAssignOp :: " << std::flush;
99787 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
99788 0 : std::cout << " not valid " << std::endl;
99789 : }
99790 : }
99791 :
99792 0 : if ( p_originalExpressionTree != NULL )
99793 : {
99794 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99795 : {
99796 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
99797 : {
99798 0 : std::cout << "SgModAssignOp :: ";
99799 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
99800 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
99801 : }
99802 : }
99803 : else
99804 : {
99805 0 : std::cout << "SgModAssignOp :: " << std::flush;
99806 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
99807 0 : std::cout << " not valid " << std::endl;
99808 : }
99809 : }
99810 :
99811 0 : if ( p_operatorPosition != NULL )
99812 : {
99813 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99814 : {
99815 0 : if ( p_operatorPosition->isInMemoryPool() == false )
99816 : {
99817 0 : std::cout << "SgModAssignOp :: ";
99818 0 : std::cout << " p_operatorPosition is not in memory pool of ";
99819 0 : std::cout << p_operatorPosition->class_name() << std::endl;
99820 : }
99821 : }
99822 : else
99823 : {
99824 0 : std::cout << "SgModAssignOp :: " << std::flush;
99825 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
99826 0 : std::cout << " not valid " << std::endl;
99827 : }
99828 : }
99829 :
99830 0 : if ( p_startOfConstruct != NULL )
99831 : {
99832 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99833 : {
99834 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
99835 : {
99836 0 : std::cout << "SgModAssignOp :: ";
99837 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
99838 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
99839 : }
99840 : }
99841 : else
99842 : {
99843 0 : std::cout << "SgModAssignOp :: " << std::flush;
99844 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
99845 0 : std::cout << " not valid " << std::endl;
99846 : }
99847 : }
99848 :
99849 0 : if ( p_endOfConstruct != NULL )
99850 : {
99851 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99852 : {
99853 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
99854 : {
99855 0 : std::cout << "SgModAssignOp :: ";
99856 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
99857 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
99858 : }
99859 : }
99860 : else
99861 : {
99862 0 : std::cout << "SgModAssignOp :: " << std::flush;
99863 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
99864 0 : std::cout << " not valid " << std::endl;
99865 : }
99866 : }
99867 :
99868 0 : if ( p_parent != NULL )
99869 : {
99870 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99871 : {
99872 0 : if ( p_parent->isInMemoryPool() == false )
99873 : {
99874 0 : std::cout << "SgModAssignOp :: ";
99875 0 : std::cout << " p_parent is not in memory pool of ";
99876 0 : std::cout << p_parent->class_name() << std::endl;
99877 : }
99878 : }
99879 : else
99880 : {
99881 0 : std::cout << "SgModAssignOp :: " << std::flush;
99882 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
99883 0 : std::cout << " not valid " << std::endl;
99884 : }
99885 : }
99886 :
99887 :
99888 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
99889 :
99890 0 : }
99891 :
99892 :
99893 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
99894 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
99895 : bool
99896 0 : SgModAssignOp::isInMemoryPool ()
99897 : {
99898 0 : typedef unsigned char* TestType;
99899 :
99900 0 : bool found = false;
99901 :
99902 0 : ROSE_ASSERT(this != NULL);
99903 :
99904 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
99905 :
99906 0 : TestType tested = (TestType) ( this ) ;
99907 :
99908 0 : std::vector < unsigned char* > :: const_iterator block = SgModAssignOp::pools.begin();
99909 :
99910 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
99911 : // while (found == false && block < Memory_Block_List.end())
99912 0 : while ( (found == false) && (block != SgModAssignOp::pools.end()) )
99913 : {
99914 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgModAssignOp::pool_size * sizeof(SgModAssignOp) ) ) ;
99915 0 : ++block;
99916 : }
99917 :
99918 : // Special handling for static data
99919 :
99920 :
99921 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
99922 0 : ROSE_ASSERT(found == true);
99923 :
99924 0 : return found;
99925 : }
99926 : /* #line 99927 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
99927 :
99928 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
99929 :
99930 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
99931 :
99932 : /* #line 99933 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
99933 :
99934 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
99935 :
99936 : void
99937 0 : SgXorAssignOp::checkDataMemberPointersIfInMemoryPool()
99938 : {
99939 : // ------------ checking pointers of SgXorAssignOp -------------------
99940 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
99941 :
99942 0 : if ( p_lhs_operand_i != NULL )
99943 : {
99944 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99945 : {
99946 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
99947 : {
99948 0 : std::cout << "SgXorAssignOp :: ";
99949 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
99950 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
99951 : }
99952 : }
99953 : else
99954 : {
99955 0 : std::cout << "SgXorAssignOp :: " << std::flush;
99956 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
99957 0 : std::cout << " not valid " << std::endl;
99958 : }
99959 : }
99960 :
99961 0 : if ( p_rhs_operand_i != NULL )
99962 : {
99963 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99964 : {
99965 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
99966 : {
99967 0 : std::cout << "SgXorAssignOp :: ";
99968 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
99969 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
99970 : }
99971 : }
99972 : else
99973 : {
99974 0 : std::cout << "SgXorAssignOp :: " << std::flush;
99975 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
99976 0 : std::cout << " not valid " << std::endl;
99977 : }
99978 : }
99979 :
99980 0 : if ( p_expression_type != NULL )
99981 : {
99982 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
99983 : {
99984 0 : if ( p_expression_type->isInMemoryPool() == false )
99985 : {
99986 0 : std::cout << "SgXorAssignOp :: ";
99987 0 : std::cout << " p_expression_type is not in memory pool of ";
99988 0 : std::cout << p_expression_type->class_name() << std::endl;
99989 : }
99990 : }
99991 : else
99992 : {
99993 0 : std::cout << "SgXorAssignOp :: " << std::flush;
99994 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
99995 0 : std::cout << " not valid " << std::endl;
99996 : }
99997 : }
99998 :
99999 0 : if ( p_originalExpressionTree != NULL )
100000 : {
100001 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100002 : {
100003 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
100004 : {
100005 0 : std::cout << "SgXorAssignOp :: ";
100006 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
100007 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
100008 : }
100009 : }
100010 : else
100011 : {
100012 0 : std::cout << "SgXorAssignOp :: " << std::flush;
100013 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
100014 0 : std::cout << " not valid " << std::endl;
100015 : }
100016 : }
100017 :
100018 0 : if ( p_operatorPosition != NULL )
100019 : {
100020 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100021 : {
100022 0 : if ( p_operatorPosition->isInMemoryPool() == false )
100023 : {
100024 0 : std::cout << "SgXorAssignOp :: ";
100025 0 : std::cout << " p_operatorPosition is not in memory pool of ";
100026 0 : std::cout << p_operatorPosition->class_name() << std::endl;
100027 : }
100028 : }
100029 : else
100030 : {
100031 0 : std::cout << "SgXorAssignOp :: " << std::flush;
100032 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
100033 0 : std::cout << " not valid " << std::endl;
100034 : }
100035 : }
100036 :
100037 0 : if ( p_startOfConstruct != NULL )
100038 : {
100039 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100040 : {
100041 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
100042 : {
100043 0 : std::cout << "SgXorAssignOp :: ";
100044 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
100045 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
100046 : }
100047 : }
100048 : else
100049 : {
100050 0 : std::cout << "SgXorAssignOp :: " << std::flush;
100051 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
100052 0 : std::cout << " not valid " << std::endl;
100053 : }
100054 : }
100055 :
100056 0 : if ( p_endOfConstruct != NULL )
100057 : {
100058 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100059 : {
100060 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
100061 : {
100062 0 : std::cout << "SgXorAssignOp :: ";
100063 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
100064 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
100065 : }
100066 : }
100067 : else
100068 : {
100069 0 : std::cout << "SgXorAssignOp :: " << std::flush;
100070 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
100071 0 : std::cout << " not valid " << std::endl;
100072 : }
100073 : }
100074 :
100075 0 : if ( p_parent != NULL )
100076 : {
100077 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100078 : {
100079 0 : if ( p_parent->isInMemoryPool() == false )
100080 : {
100081 0 : std::cout << "SgXorAssignOp :: ";
100082 0 : std::cout << " p_parent is not in memory pool of ";
100083 0 : std::cout << p_parent->class_name() << std::endl;
100084 : }
100085 : }
100086 : else
100087 : {
100088 0 : std::cout << "SgXorAssignOp :: " << std::flush;
100089 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
100090 0 : std::cout << " not valid " << std::endl;
100091 : }
100092 : }
100093 :
100094 :
100095 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
100096 :
100097 0 : }
100098 :
100099 :
100100 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
100101 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
100102 : bool
100103 0 : SgXorAssignOp::isInMemoryPool ()
100104 : {
100105 0 : typedef unsigned char* TestType;
100106 :
100107 0 : bool found = false;
100108 :
100109 0 : ROSE_ASSERT(this != NULL);
100110 :
100111 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
100112 :
100113 0 : TestType tested = (TestType) ( this ) ;
100114 :
100115 0 : std::vector < unsigned char* > :: const_iterator block = SgXorAssignOp::pools.begin();
100116 :
100117 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
100118 : // while (found == false && block < Memory_Block_List.end())
100119 0 : while ( (found == false) && (block != SgXorAssignOp::pools.end()) )
100120 : {
100121 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgXorAssignOp::pool_size * sizeof(SgXorAssignOp) ) ) ;
100122 0 : ++block;
100123 : }
100124 :
100125 : // Special handling for static data
100126 :
100127 :
100128 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
100129 0 : ROSE_ASSERT(found == true);
100130 :
100131 0 : return found;
100132 : }
100133 : /* #line 100134 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
100134 :
100135 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
100136 :
100137 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
100138 :
100139 : /* #line 100140 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
100140 :
100141 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
100142 :
100143 : void
100144 0 : SgLshiftAssignOp::checkDataMemberPointersIfInMemoryPool()
100145 : {
100146 : // ------------ checking pointers of SgLshiftAssignOp -------------------
100147 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
100148 :
100149 0 : if ( p_lhs_operand_i != NULL )
100150 : {
100151 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100152 : {
100153 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
100154 : {
100155 0 : std::cout << "SgLshiftAssignOp :: ";
100156 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
100157 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
100158 : }
100159 : }
100160 : else
100161 : {
100162 0 : std::cout << "SgLshiftAssignOp :: " << std::flush;
100163 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
100164 0 : std::cout << " not valid " << std::endl;
100165 : }
100166 : }
100167 :
100168 0 : if ( p_rhs_operand_i != NULL )
100169 : {
100170 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100171 : {
100172 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
100173 : {
100174 0 : std::cout << "SgLshiftAssignOp :: ";
100175 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
100176 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
100177 : }
100178 : }
100179 : else
100180 : {
100181 0 : std::cout << "SgLshiftAssignOp :: " << std::flush;
100182 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
100183 0 : std::cout << " not valid " << std::endl;
100184 : }
100185 : }
100186 :
100187 0 : if ( p_expression_type != NULL )
100188 : {
100189 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100190 : {
100191 0 : if ( p_expression_type->isInMemoryPool() == false )
100192 : {
100193 0 : std::cout << "SgLshiftAssignOp :: ";
100194 0 : std::cout << " p_expression_type is not in memory pool of ";
100195 0 : std::cout << p_expression_type->class_name() << std::endl;
100196 : }
100197 : }
100198 : else
100199 : {
100200 0 : std::cout << "SgLshiftAssignOp :: " << std::flush;
100201 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
100202 0 : std::cout << " not valid " << std::endl;
100203 : }
100204 : }
100205 :
100206 0 : if ( p_originalExpressionTree != NULL )
100207 : {
100208 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100209 : {
100210 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
100211 : {
100212 0 : std::cout << "SgLshiftAssignOp :: ";
100213 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
100214 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
100215 : }
100216 : }
100217 : else
100218 : {
100219 0 : std::cout << "SgLshiftAssignOp :: " << std::flush;
100220 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
100221 0 : std::cout << " not valid " << std::endl;
100222 : }
100223 : }
100224 :
100225 0 : if ( p_operatorPosition != NULL )
100226 : {
100227 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100228 : {
100229 0 : if ( p_operatorPosition->isInMemoryPool() == false )
100230 : {
100231 0 : std::cout << "SgLshiftAssignOp :: ";
100232 0 : std::cout << " p_operatorPosition is not in memory pool of ";
100233 0 : std::cout << p_operatorPosition->class_name() << std::endl;
100234 : }
100235 : }
100236 : else
100237 : {
100238 0 : std::cout << "SgLshiftAssignOp :: " << std::flush;
100239 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
100240 0 : std::cout << " not valid " << std::endl;
100241 : }
100242 : }
100243 :
100244 0 : if ( p_startOfConstruct != NULL )
100245 : {
100246 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100247 : {
100248 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
100249 : {
100250 0 : std::cout << "SgLshiftAssignOp :: ";
100251 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
100252 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
100253 : }
100254 : }
100255 : else
100256 : {
100257 0 : std::cout << "SgLshiftAssignOp :: " << std::flush;
100258 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
100259 0 : std::cout << " not valid " << std::endl;
100260 : }
100261 : }
100262 :
100263 0 : if ( p_endOfConstruct != NULL )
100264 : {
100265 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100266 : {
100267 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
100268 : {
100269 0 : std::cout << "SgLshiftAssignOp :: ";
100270 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
100271 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
100272 : }
100273 : }
100274 : else
100275 : {
100276 0 : std::cout << "SgLshiftAssignOp :: " << std::flush;
100277 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
100278 0 : std::cout << " not valid " << std::endl;
100279 : }
100280 : }
100281 :
100282 0 : if ( p_parent != NULL )
100283 : {
100284 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100285 : {
100286 0 : if ( p_parent->isInMemoryPool() == false )
100287 : {
100288 0 : std::cout << "SgLshiftAssignOp :: ";
100289 0 : std::cout << " p_parent is not in memory pool of ";
100290 0 : std::cout << p_parent->class_name() << std::endl;
100291 : }
100292 : }
100293 : else
100294 : {
100295 0 : std::cout << "SgLshiftAssignOp :: " << std::flush;
100296 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
100297 0 : std::cout << " not valid " << std::endl;
100298 : }
100299 : }
100300 :
100301 :
100302 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
100303 :
100304 0 : }
100305 :
100306 :
100307 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
100308 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
100309 : bool
100310 0 : SgLshiftAssignOp::isInMemoryPool ()
100311 : {
100312 0 : typedef unsigned char* TestType;
100313 :
100314 0 : bool found = false;
100315 :
100316 0 : ROSE_ASSERT(this != NULL);
100317 :
100318 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
100319 :
100320 0 : TestType tested = (TestType) ( this ) ;
100321 :
100322 0 : std::vector < unsigned char* > :: const_iterator block = SgLshiftAssignOp::pools.begin();
100323 :
100324 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
100325 : // while (found == false && block < Memory_Block_List.end())
100326 0 : while ( (found == false) && (block != SgLshiftAssignOp::pools.end()) )
100327 : {
100328 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLshiftAssignOp::pool_size * sizeof(SgLshiftAssignOp) ) ) ;
100329 0 : ++block;
100330 : }
100331 :
100332 : // Special handling for static data
100333 :
100334 :
100335 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
100336 0 : ROSE_ASSERT(found == true);
100337 :
100338 0 : return found;
100339 : }
100340 : /* #line 100341 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
100341 :
100342 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
100343 :
100344 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
100345 :
100346 : /* #line 100347 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
100347 :
100348 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
100349 :
100350 : void
100351 0 : SgRshiftAssignOp::checkDataMemberPointersIfInMemoryPool()
100352 : {
100353 : // ------------ checking pointers of SgRshiftAssignOp -------------------
100354 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
100355 :
100356 0 : if ( p_lhs_operand_i != NULL )
100357 : {
100358 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100359 : {
100360 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
100361 : {
100362 0 : std::cout << "SgRshiftAssignOp :: ";
100363 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
100364 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
100365 : }
100366 : }
100367 : else
100368 : {
100369 0 : std::cout << "SgRshiftAssignOp :: " << std::flush;
100370 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
100371 0 : std::cout << " not valid " << std::endl;
100372 : }
100373 : }
100374 :
100375 0 : if ( p_rhs_operand_i != NULL )
100376 : {
100377 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100378 : {
100379 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
100380 : {
100381 0 : std::cout << "SgRshiftAssignOp :: ";
100382 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
100383 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
100384 : }
100385 : }
100386 : else
100387 : {
100388 0 : std::cout << "SgRshiftAssignOp :: " << std::flush;
100389 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
100390 0 : std::cout << " not valid " << std::endl;
100391 : }
100392 : }
100393 :
100394 0 : if ( p_expression_type != NULL )
100395 : {
100396 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100397 : {
100398 0 : if ( p_expression_type->isInMemoryPool() == false )
100399 : {
100400 0 : std::cout << "SgRshiftAssignOp :: ";
100401 0 : std::cout << " p_expression_type is not in memory pool of ";
100402 0 : std::cout << p_expression_type->class_name() << std::endl;
100403 : }
100404 : }
100405 : else
100406 : {
100407 0 : std::cout << "SgRshiftAssignOp :: " << std::flush;
100408 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
100409 0 : std::cout << " not valid " << std::endl;
100410 : }
100411 : }
100412 :
100413 0 : if ( p_originalExpressionTree != NULL )
100414 : {
100415 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100416 : {
100417 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
100418 : {
100419 0 : std::cout << "SgRshiftAssignOp :: ";
100420 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
100421 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
100422 : }
100423 : }
100424 : else
100425 : {
100426 0 : std::cout << "SgRshiftAssignOp :: " << std::flush;
100427 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
100428 0 : std::cout << " not valid " << std::endl;
100429 : }
100430 : }
100431 :
100432 0 : if ( p_operatorPosition != NULL )
100433 : {
100434 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100435 : {
100436 0 : if ( p_operatorPosition->isInMemoryPool() == false )
100437 : {
100438 0 : std::cout << "SgRshiftAssignOp :: ";
100439 0 : std::cout << " p_operatorPosition is not in memory pool of ";
100440 0 : std::cout << p_operatorPosition->class_name() << std::endl;
100441 : }
100442 : }
100443 : else
100444 : {
100445 0 : std::cout << "SgRshiftAssignOp :: " << std::flush;
100446 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
100447 0 : std::cout << " not valid " << std::endl;
100448 : }
100449 : }
100450 :
100451 0 : if ( p_startOfConstruct != NULL )
100452 : {
100453 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100454 : {
100455 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
100456 : {
100457 0 : std::cout << "SgRshiftAssignOp :: ";
100458 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
100459 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
100460 : }
100461 : }
100462 : else
100463 : {
100464 0 : std::cout << "SgRshiftAssignOp :: " << std::flush;
100465 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
100466 0 : std::cout << " not valid " << std::endl;
100467 : }
100468 : }
100469 :
100470 0 : if ( p_endOfConstruct != NULL )
100471 : {
100472 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100473 : {
100474 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
100475 : {
100476 0 : std::cout << "SgRshiftAssignOp :: ";
100477 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
100478 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
100479 : }
100480 : }
100481 : else
100482 : {
100483 0 : std::cout << "SgRshiftAssignOp :: " << std::flush;
100484 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
100485 0 : std::cout << " not valid " << std::endl;
100486 : }
100487 : }
100488 :
100489 0 : if ( p_parent != NULL )
100490 : {
100491 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100492 : {
100493 0 : if ( p_parent->isInMemoryPool() == false )
100494 : {
100495 0 : std::cout << "SgRshiftAssignOp :: ";
100496 0 : std::cout << " p_parent is not in memory pool of ";
100497 0 : std::cout << p_parent->class_name() << std::endl;
100498 : }
100499 : }
100500 : else
100501 : {
100502 0 : std::cout << "SgRshiftAssignOp :: " << std::flush;
100503 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
100504 0 : std::cout << " not valid " << std::endl;
100505 : }
100506 : }
100507 :
100508 :
100509 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
100510 :
100511 0 : }
100512 :
100513 :
100514 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
100515 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
100516 : bool
100517 0 : SgRshiftAssignOp::isInMemoryPool ()
100518 : {
100519 0 : typedef unsigned char* TestType;
100520 :
100521 0 : bool found = false;
100522 :
100523 0 : ROSE_ASSERT(this != NULL);
100524 :
100525 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
100526 :
100527 0 : TestType tested = (TestType) ( this ) ;
100528 :
100529 0 : std::vector < unsigned char* > :: const_iterator block = SgRshiftAssignOp::pools.begin();
100530 :
100531 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
100532 : // while (found == false && block < Memory_Block_List.end())
100533 0 : while ( (found == false) && (block != SgRshiftAssignOp::pools.end()) )
100534 : {
100535 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgRshiftAssignOp::pool_size * sizeof(SgRshiftAssignOp) ) ) ;
100536 0 : ++block;
100537 : }
100538 :
100539 : // Special handling for static data
100540 :
100541 :
100542 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
100543 0 : ROSE_ASSERT(found == true);
100544 :
100545 0 : return found;
100546 : }
100547 : /* #line 100548 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
100548 :
100549 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
100550 :
100551 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
100552 :
100553 : /* #line 100554 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
100554 :
100555 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
100556 :
100557 : void
100558 0 : SgIntegerDivideAssignOp::checkDataMemberPointersIfInMemoryPool()
100559 : {
100560 : // ------------ checking pointers of SgIntegerDivideAssignOp -------------------
100561 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
100562 :
100563 0 : if ( p_lhs_operand_i != NULL )
100564 : {
100565 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100566 : {
100567 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
100568 : {
100569 0 : std::cout << "SgIntegerDivideAssignOp :: ";
100570 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
100571 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
100572 : }
100573 : }
100574 : else
100575 : {
100576 0 : std::cout << "SgIntegerDivideAssignOp :: " << std::flush;
100577 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
100578 0 : std::cout << " not valid " << std::endl;
100579 : }
100580 : }
100581 :
100582 0 : if ( p_rhs_operand_i != NULL )
100583 : {
100584 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100585 : {
100586 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
100587 : {
100588 0 : std::cout << "SgIntegerDivideAssignOp :: ";
100589 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
100590 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
100591 : }
100592 : }
100593 : else
100594 : {
100595 0 : std::cout << "SgIntegerDivideAssignOp :: " << std::flush;
100596 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
100597 0 : std::cout << " not valid " << std::endl;
100598 : }
100599 : }
100600 :
100601 0 : if ( p_expression_type != NULL )
100602 : {
100603 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100604 : {
100605 0 : if ( p_expression_type->isInMemoryPool() == false )
100606 : {
100607 0 : std::cout << "SgIntegerDivideAssignOp :: ";
100608 0 : std::cout << " p_expression_type is not in memory pool of ";
100609 0 : std::cout << p_expression_type->class_name() << std::endl;
100610 : }
100611 : }
100612 : else
100613 : {
100614 0 : std::cout << "SgIntegerDivideAssignOp :: " << std::flush;
100615 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
100616 0 : std::cout << " not valid " << std::endl;
100617 : }
100618 : }
100619 :
100620 0 : if ( p_originalExpressionTree != NULL )
100621 : {
100622 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100623 : {
100624 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
100625 : {
100626 0 : std::cout << "SgIntegerDivideAssignOp :: ";
100627 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
100628 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
100629 : }
100630 : }
100631 : else
100632 : {
100633 0 : std::cout << "SgIntegerDivideAssignOp :: " << std::flush;
100634 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
100635 0 : std::cout << " not valid " << std::endl;
100636 : }
100637 : }
100638 :
100639 0 : if ( p_operatorPosition != NULL )
100640 : {
100641 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100642 : {
100643 0 : if ( p_operatorPosition->isInMemoryPool() == false )
100644 : {
100645 0 : std::cout << "SgIntegerDivideAssignOp :: ";
100646 0 : std::cout << " p_operatorPosition is not in memory pool of ";
100647 0 : std::cout << p_operatorPosition->class_name() << std::endl;
100648 : }
100649 : }
100650 : else
100651 : {
100652 0 : std::cout << "SgIntegerDivideAssignOp :: " << std::flush;
100653 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
100654 0 : std::cout << " not valid " << std::endl;
100655 : }
100656 : }
100657 :
100658 0 : if ( p_startOfConstruct != NULL )
100659 : {
100660 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100661 : {
100662 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
100663 : {
100664 0 : std::cout << "SgIntegerDivideAssignOp :: ";
100665 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
100666 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
100667 : }
100668 : }
100669 : else
100670 : {
100671 0 : std::cout << "SgIntegerDivideAssignOp :: " << std::flush;
100672 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
100673 0 : std::cout << " not valid " << std::endl;
100674 : }
100675 : }
100676 :
100677 0 : if ( p_endOfConstruct != NULL )
100678 : {
100679 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100680 : {
100681 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
100682 : {
100683 0 : std::cout << "SgIntegerDivideAssignOp :: ";
100684 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
100685 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
100686 : }
100687 : }
100688 : else
100689 : {
100690 0 : std::cout << "SgIntegerDivideAssignOp :: " << std::flush;
100691 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
100692 0 : std::cout << " not valid " << std::endl;
100693 : }
100694 : }
100695 :
100696 0 : if ( p_parent != NULL )
100697 : {
100698 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100699 : {
100700 0 : if ( p_parent->isInMemoryPool() == false )
100701 : {
100702 0 : std::cout << "SgIntegerDivideAssignOp :: ";
100703 0 : std::cout << " p_parent is not in memory pool of ";
100704 0 : std::cout << p_parent->class_name() << std::endl;
100705 : }
100706 : }
100707 : else
100708 : {
100709 0 : std::cout << "SgIntegerDivideAssignOp :: " << std::flush;
100710 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
100711 0 : std::cout << " not valid " << std::endl;
100712 : }
100713 : }
100714 :
100715 :
100716 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
100717 :
100718 0 : }
100719 :
100720 :
100721 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
100722 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
100723 : bool
100724 0 : SgIntegerDivideAssignOp::isInMemoryPool ()
100725 : {
100726 0 : typedef unsigned char* TestType;
100727 :
100728 0 : bool found = false;
100729 :
100730 0 : ROSE_ASSERT(this != NULL);
100731 :
100732 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
100733 :
100734 0 : TestType tested = (TestType) ( this ) ;
100735 :
100736 0 : std::vector < unsigned char* > :: const_iterator block = SgIntegerDivideAssignOp::pools.begin();
100737 :
100738 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
100739 : // while (found == false && block < Memory_Block_List.end())
100740 0 : while ( (found == false) && (block != SgIntegerDivideAssignOp::pools.end()) )
100741 : {
100742 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIntegerDivideAssignOp::pool_size * sizeof(SgIntegerDivideAssignOp) ) ) ;
100743 0 : ++block;
100744 : }
100745 :
100746 : // Special handling for static data
100747 :
100748 :
100749 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
100750 0 : ROSE_ASSERT(found == true);
100751 :
100752 0 : return found;
100753 : }
100754 : /* #line 100755 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
100755 :
100756 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
100757 :
100758 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
100759 :
100760 : /* #line 100761 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
100761 :
100762 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
100763 :
100764 : void
100765 0 : SgExponentiationAssignOp::checkDataMemberPointersIfInMemoryPool()
100766 : {
100767 : // ------------ checking pointers of SgExponentiationAssignOp -------------------
100768 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
100769 :
100770 0 : if ( p_lhs_operand_i != NULL )
100771 : {
100772 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100773 : {
100774 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
100775 : {
100776 0 : std::cout << "SgExponentiationAssignOp :: ";
100777 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
100778 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
100779 : }
100780 : }
100781 : else
100782 : {
100783 0 : std::cout << "SgExponentiationAssignOp :: " << std::flush;
100784 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
100785 0 : std::cout << " not valid " << std::endl;
100786 : }
100787 : }
100788 :
100789 0 : if ( p_rhs_operand_i != NULL )
100790 : {
100791 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100792 : {
100793 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
100794 : {
100795 0 : std::cout << "SgExponentiationAssignOp :: ";
100796 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
100797 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
100798 : }
100799 : }
100800 : else
100801 : {
100802 0 : std::cout << "SgExponentiationAssignOp :: " << std::flush;
100803 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
100804 0 : std::cout << " not valid " << std::endl;
100805 : }
100806 : }
100807 :
100808 0 : if ( p_expression_type != NULL )
100809 : {
100810 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100811 : {
100812 0 : if ( p_expression_type->isInMemoryPool() == false )
100813 : {
100814 0 : std::cout << "SgExponentiationAssignOp :: ";
100815 0 : std::cout << " p_expression_type is not in memory pool of ";
100816 0 : std::cout << p_expression_type->class_name() << std::endl;
100817 : }
100818 : }
100819 : else
100820 : {
100821 0 : std::cout << "SgExponentiationAssignOp :: " << std::flush;
100822 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
100823 0 : std::cout << " not valid " << std::endl;
100824 : }
100825 : }
100826 :
100827 0 : if ( p_originalExpressionTree != NULL )
100828 : {
100829 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100830 : {
100831 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
100832 : {
100833 0 : std::cout << "SgExponentiationAssignOp :: ";
100834 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
100835 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
100836 : }
100837 : }
100838 : else
100839 : {
100840 0 : std::cout << "SgExponentiationAssignOp :: " << std::flush;
100841 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
100842 0 : std::cout << " not valid " << std::endl;
100843 : }
100844 : }
100845 :
100846 0 : if ( p_operatorPosition != NULL )
100847 : {
100848 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100849 : {
100850 0 : if ( p_operatorPosition->isInMemoryPool() == false )
100851 : {
100852 0 : std::cout << "SgExponentiationAssignOp :: ";
100853 0 : std::cout << " p_operatorPosition is not in memory pool of ";
100854 0 : std::cout << p_operatorPosition->class_name() << std::endl;
100855 : }
100856 : }
100857 : else
100858 : {
100859 0 : std::cout << "SgExponentiationAssignOp :: " << std::flush;
100860 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
100861 0 : std::cout << " not valid " << std::endl;
100862 : }
100863 : }
100864 :
100865 0 : if ( p_startOfConstruct != NULL )
100866 : {
100867 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100868 : {
100869 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
100870 : {
100871 0 : std::cout << "SgExponentiationAssignOp :: ";
100872 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
100873 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
100874 : }
100875 : }
100876 : else
100877 : {
100878 0 : std::cout << "SgExponentiationAssignOp :: " << std::flush;
100879 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
100880 0 : std::cout << " not valid " << std::endl;
100881 : }
100882 : }
100883 :
100884 0 : if ( p_endOfConstruct != NULL )
100885 : {
100886 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100887 : {
100888 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
100889 : {
100890 0 : std::cout << "SgExponentiationAssignOp :: ";
100891 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
100892 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
100893 : }
100894 : }
100895 : else
100896 : {
100897 0 : std::cout << "SgExponentiationAssignOp :: " << std::flush;
100898 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
100899 0 : std::cout << " not valid " << std::endl;
100900 : }
100901 : }
100902 :
100903 0 : if ( p_parent != NULL )
100904 : {
100905 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100906 : {
100907 0 : if ( p_parent->isInMemoryPool() == false )
100908 : {
100909 0 : std::cout << "SgExponentiationAssignOp :: ";
100910 0 : std::cout << " p_parent is not in memory pool of ";
100911 0 : std::cout << p_parent->class_name() << std::endl;
100912 : }
100913 : }
100914 : else
100915 : {
100916 0 : std::cout << "SgExponentiationAssignOp :: " << std::flush;
100917 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
100918 0 : std::cout << " not valid " << std::endl;
100919 : }
100920 : }
100921 :
100922 :
100923 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
100924 :
100925 0 : }
100926 :
100927 :
100928 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
100929 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
100930 : bool
100931 0 : SgExponentiationAssignOp::isInMemoryPool ()
100932 : {
100933 0 : typedef unsigned char* TestType;
100934 :
100935 0 : bool found = false;
100936 :
100937 0 : ROSE_ASSERT(this != NULL);
100938 :
100939 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
100940 :
100941 0 : TestType tested = (TestType) ( this ) ;
100942 :
100943 0 : std::vector < unsigned char* > :: const_iterator block = SgExponentiationAssignOp::pools.begin();
100944 :
100945 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
100946 : // while (found == false && block < Memory_Block_List.end())
100947 0 : while ( (found == false) && (block != SgExponentiationAssignOp::pools.end()) )
100948 : {
100949 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgExponentiationAssignOp::pool_size * sizeof(SgExponentiationAssignOp) ) ) ;
100950 0 : ++block;
100951 : }
100952 :
100953 : // Special handling for static data
100954 :
100955 :
100956 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
100957 0 : ROSE_ASSERT(found == true);
100958 :
100959 0 : return found;
100960 : }
100961 : /* #line 100962 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
100962 :
100963 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
100964 :
100965 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
100966 :
100967 : /* #line 100968 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
100968 :
100969 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
100970 :
100971 : void
100972 0 : SgMembershipOp::checkDataMemberPointersIfInMemoryPool()
100973 : {
100974 : // ------------ checking pointers of SgMembershipOp -------------------
100975 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
100976 :
100977 0 : if ( p_lhs_operand_i != NULL )
100978 : {
100979 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100980 : {
100981 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
100982 : {
100983 0 : std::cout << "SgMembershipOp :: ";
100984 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
100985 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
100986 : }
100987 : }
100988 : else
100989 : {
100990 0 : std::cout << "SgMembershipOp :: " << std::flush;
100991 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
100992 0 : std::cout << " not valid " << std::endl;
100993 : }
100994 : }
100995 :
100996 0 : if ( p_rhs_operand_i != NULL )
100997 : {
100998 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
100999 : {
101000 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
101001 : {
101002 0 : std::cout << "SgMembershipOp :: ";
101003 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
101004 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
101005 : }
101006 : }
101007 : else
101008 : {
101009 0 : std::cout << "SgMembershipOp :: " << std::flush;
101010 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
101011 0 : std::cout << " not valid " << std::endl;
101012 : }
101013 : }
101014 :
101015 0 : if ( p_expression_type != NULL )
101016 : {
101017 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101018 : {
101019 0 : if ( p_expression_type->isInMemoryPool() == false )
101020 : {
101021 0 : std::cout << "SgMembershipOp :: ";
101022 0 : std::cout << " p_expression_type is not in memory pool of ";
101023 0 : std::cout << p_expression_type->class_name() << std::endl;
101024 : }
101025 : }
101026 : else
101027 : {
101028 0 : std::cout << "SgMembershipOp :: " << std::flush;
101029 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
101030 0 : std::cout << " not valid " << std::endl;
101031 : }
101032 : }
101033 :
101034 0 : if ( p_originalExpressionTree != NULL )
101035 : {
101036 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101037 : {
101038 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
101039 : {
101040 0 : std::cout << "SgMembershipOp :: ";
101041 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
101042 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
101043 : }
101044 : }
101045 : else
101046 : {
101047 0 : std::cout << "SgMembershipOp :: " << std::flush;
101048 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
101049 0 : std::cout << " not valid " << std::endl;
101050 : }
101051 : }
101052 :
101053 0 : if ( p_operatorPosition != NULL )
101054 : {
101055 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101056 : {
101057 0 : if ( p_operatorPosition->isInMemoryPool() == false )
101058 : {
101059 0 : std::cout << "SgMembershipOp :: ";
101060 0 : std::cout << " p_operatorPosition is not in memory pool of ";
101061 0 : std::cout << p_operatorPosition->class_name() << std::endl;
101062 : }
101063 : }
101064 : else
101065 : {
101066 0 : std::cout << "SgMembershipOp :: " << std::flush;
101067 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
101068 0 : std::cout << " not valid " << std::endl;
101069 : }
101070 : }
101071 :
101072 0 : if ( p_startOfConstruct != NULL )
101073 : {
101074 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101075 : {
101076 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
101077 : {
101078 0 : std::cout << "SgMembershipOp :: ";
101079 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
101080 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
101081 : }
101082 : }
101083 : else
101084 : {
101085 0 : std::cout << "SgMembershipOp :: " << std::flush;
101086 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
101087 0 : std::cout << " not valid " << std::endl;
101088 : }
101089 : }
101090 :
101091 0 : if ( p_endOfConstruct != NULL )
101092 : {
101093 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101094 : {
101095 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
101096 : {
101097 0 : std::cout << "SgMembershipOp :: ";
101098 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
101099 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
101100 : }
101101 : }
101102 : else
101103 : {
101104 0 : std::cout << "SgMembershipOp :: " << std::flush;
101105 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
101106 0 : std::cout << " not valid " << std::endl;
101107 : }
101108 : }
101109 :
101110 0 : if ( p_parent != NULL )
101111 : {
101112 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101113 : {
101114 0 : if ( p_parent->isInMemoryPool() == false )
101115 : {
101116 0 : std::cout << "SgMembershipOp :: ";
101117 0 : std::cout << " p_parent is not in memory pool of ";
101118 0 : std::cout << p_parent->class_name() << std::endl;
101119 : }
101120 : }
101121 : else
101122 : {
101123 0 : std::cout << "SgMembershipOp :: " << std::flush;
101124 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
101125 0 : std::cout << " not valid " << std::endl;
101126 : }
101127 : }
101128 :
101129 :
101130 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
101131 :
101132 0 : }
101133 :
101134 :
101135 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
101136 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
101137 : bool
101138 0 : SgMembershipOp::isInMemoryPool ()
101139 : {
101140 0 : typedef unsigned char* TestType;
101141 :
101142 0 : bool found = false;
101143 :
101144 0 : ROSE_ASSERT(this != NULL);
101145 :
101146 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
101147 :
101148 0 : TestType tested = (TestType) ( this ) ;
101149 :
101150 0 : std::vector < unsigned char* > :: const_iterator block = SgMembershipOp::pools.begin();
101151 :
101152 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
101153 : // while (found == false && block < Memory_Block_List.end())
101154 0 : while ( (found == false) && (block != SgMembershipOp::pools.end()) )
101155 : {
101156 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgMembershipOp::pool_size * sizeof(SgMembershipOp) ) ) ;
101157 0 : ++block;
101158 : }
101159 :
101160 : // Special handling for static data
101161 :
101162 :
101163 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
101164 0 : ROSE_ASSERT(found == true);
101165 :
101166 0 : return found;
101167 : }
101168 : /* #line 101169 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
101169 :
101170 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
101171 :
101172 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
101173 :
101174 : /* #line 101175 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
101175 :
101176 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
101177 :
101178 : void
101179 0 : SgSpaceshipOp::checkDataMemberPointersIfInMemoryPool()
101180 : {
101181 : // ------------ checking pointers of SgSpaceshipOp -------------------
101182 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
101183 :
101184 0 : if ( p_lhs_operand_i != NULL )
101185 : {
101186 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101187 : {
101188 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
101189 : {
101190 0 : std::cout << "SgSpaceshipOp :: ";
101191 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
101192 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
101193 : }
101194 : }
101195 : else
101196 : {
101197 0 : std::cout << "SgSpaceshipOp :: " << std::flush;
101198 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
101199 0 : std::cout << " not valid " << std::endl;
101200 : }
101201 : }
101202 :
101203 0 : if ( p_rhs_operand_i != NULL )
101204 : {
101205 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101206 : {
101207 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
101208 : {
101209 0 : std::cout << "SgSpaceshipOp :: ";
101210 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
101211 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
101212 : }
101213 : }
101214 : else
101215 : {
101216 0 : std::cout << "SgSpaceshipOp :: " << std::flush;
101217 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
101218 0 : std::cout << " not valid " << std::endl;
101219 : }
101220 : }
101221 :
101222 0 : if ( p_expression_type != NULL )
101223 : {
101224 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101225 : {
101226 0 : if ( p_expression_type->isInMemoryPool() == false )
101227 : {
101228 0 : std::cout << "SgSpaceshipOp :: ";
101229 0 : std::cout << " p_expression_type is not in memory pool of ";
101230 0 : std::cout << p_expression_type->class_name() << std::endl;
101231 : }
101232 : }
101233 : else
101234 : {
101235 0 : std::cout << "SgSpaceshipOp :: " << std::flush;
101236 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
101237 0 : std::cout << " not valid " << std::endl;
101238 : }
101239 : }
101240 :
101241 0 : if ( p_originalExpressionTree != NULL )
101242 : {
101243 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101244 : {
101245 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
101246 : {
101247 0 : std::cout << "SgSpaceshipOp :: ";
101248 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
101249 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
101250 : }
101251 : }
101252 : else
101253 : {
101254 0 : std::cout << "SgSpaceshipOp :: " << std::flush;
101255 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
101256 0 : std::cout << " not valid " << std::endl;
101257 : }
101258 : }
101259 :
101260 0 : if ( p_operatorPosition != NULL )
101261 : {
101262 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101263 : {
101264 0 : if ( p_operatorPosition->isInMemoryPool() == false )
101265 : {
101266 0 : std::cout << "SgSpaceshipOp :: ";
101267 0 : std::cout << " p_operatorPosition is not in memory pool of ";
101268 0 : std::cout << p_operatorPosition->class_name() << std::endl;
101269 : }
101270 : }
101271 : else
101272 : {
101273 0 : std::cout << "SgSpaceshipOp :: " << std::flush;
101274 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
101275 0 : std::cout << " not valid " << std::endl;
101276 : }
101277 : }
101278 :
101279 0 : if ( p_startOfConstruct != NULL )
101280 : {
101281 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101282 : {
101283 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
101284 : {
101285 0 : std::cout << "SgSpaceshipOp :: ";
101286 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
101287 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
101288 : }
101289 : }
101290 : else
101291 : {
101292 0 : std::cout << "SgSpaceshipOp :: " << std::flush;
101293 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
101294 0 : std::cout << " not valid " << std::endl;
101295 : }
101296 : }
101297 :
101298 0 : if ( p_endOfConstruct != NULL )
101299 : {
101300 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101301 : {
101302 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
101303 : {
101304 0 : std::cout << "SgSpaceshipOp :: ";
101305 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
101306 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
101307 : }
101308 : }
101309 : else
101310 : {
101311 0 : std::cout << "SgSpaceshipOp :: " << std::flush;
101312 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
101313 0 : std::cout << " not valid " << std::endl;
101314 : }
101315 : }
101316 :
101317 0 : if ( p_parent != NULL )
101318 : {
101319 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101320 : {
101321 0 : if ( p_parent->isInMemoryPool() == false )
101322 : {
101323 0 : std::cout << "SgSpaceshipOp :: ";
101324 0 : std::cout << " p_parent is not in memory pool of ";
101325 0 : std::cout << p_parent->class_name() << std::endl;
101326 : }
101327 : }
101328 : else
101329 : {
101330 0 : std::cout << "SgSpaceshipOp :: " << std::flush;
101331 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
101332 0 : std::cout << " not valid " << std::endl;
101333 : }
101334 : }
101335 :
101336 :
101337 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
101338 :
101339 0 : }
101340 :
101341 :
101342 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
101343 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
101344 : bool
101345 0 : SgSpaceshipOp::isInMemoryPool ()
101346 : {
101347 0 : typedef unsigned char* TestType;
101348 :
101349 0 : bool found = false;
101350 :
101351 0 : ROSE_ASSERT(this != NULL);
101352 :
101353 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
101354 :
101355 0 : TestType tested = (TestType) ( this ) ;
101356 :
101357 0 : std::vector < unsigned char* > :: const_iterator block = SgSpaceshipOp::pools.begin();
101358 :
101359 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
101360 : // while (found == false && block < Memory_Block_List.end())
101361 0 : while ( (found == false) && (block != SgSpaceshipOp::pools.end()) )
101362 : {
101363 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSpaceshipOp::pool_size * sizeof(SgSpaceshipOp) ) ) ;
101364 0 : ++block;
101365 : }
101366 :
101367 : // Special handling for static data
101368 :
101369 :
101370 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
101371 0 : ROSE_ASSERT(found == true);
101372 :
101373 0 : return found;
101374 : }
101375 : /* #line 101376 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
101376 :
101377 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
101378 :
101379 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
101380 :
101381 : /* #line 101382 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
101382 :
101383 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
101384 :
101385 : void
101386 0 : SgNonMembershipOp::checkDataMemberPointersIfInMemoryPool()
101387 : {
101388 : // ------------ checking pointers of SgNonMembershipOp -------------------
101389 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
101390 :
101391 0 : if ( p_lhs_operand_i != NULL )
101392 : {
101393 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101394 : {
101395 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
101396 : {
101397 0 : std::cout << "SgNonMembershipOp :: ";
101398 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
101399 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
101400 : }
101401 : }
101402 : else
101403 : {
101404 0 : std::cout << "SgNonMembershipOp :: " << std::flush;
101405 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
101406 0 : std::cout << " not valid " << std::endl;
101407 : }
101408 : }
101409 :
101410 0 : if ( p_rhs_operand_i != NULL )
101411 : {
101412 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101413 : {
101414 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
101415 : {
101416 0 : std::cout << "SgNonMembershipOp :: ";
101417 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
101418 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
101419 : }
101420 : }
101421 : else
101422 : {
101423 0 : std::cout << "SgNonMembershipOp :: " << std::flush;
101424 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
101425 0 : std::cout << " not valid " << std::endl;
101426 : }
101427 : }
101428 :
101429 0 : if ( p_expression_type != NULL )
101430 : {
101431 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101432 : {
101433 0 : if ( p_expression_type->isInMemoryPool() == false )
101434 : {
101435 0 : std::cout << "SgNonMembershipOp :: ";
101436 0 : std::cout << " p_expression_type is not in memory pool of ";
101437 0 : std::cout << p_expression_type->class_name() << std::endl;
101438 : }
101439 : }
101440 : else
101441 : {
101442 0 : std::cout << "SgNonMembershipOp :: " << std::flush;
101443 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
101444 0 : std::cout << " not valid " << std::endl;
101445 : }
101446 : }
101447 :
101448 0 : if ( p_originalExpressionTree != NULL )
101449 : {
101450 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101451 : {
101452 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
101453 : {
101454 0 : std::cout << "SgNonMembershipOp :: ";
101455 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
101456 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
101457 : }
101458 : }
101459 : else
101460 : {
101461 0 : std::cout << "SgNonMembershipOp :: " << std::flush;
101462 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
101463 0 : std::cout << " not valid " << std::endl;
101464 : }
101465 : }
101466 :
101467 0 : if ( p_operatorPosition != NULL )
101468 : {
101469 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101470 : {
101471 0 : if ( p_operatorPosition->isInMemoryPool() == false )
101472 : {
101473 0 : std::cout << "SgNonMembershipOp :: ";
101474 0 : std::cout << " p_operatorPosition is not in memory pool of ";
101475 0 : std::cout << p_operatorPosition->class_name() << std::endl;
101476 : }
101477 : }
101478 : else
101479 : {
101480 0 : std::cout << "SgNonMembershipOp :: " << std::flush;
101481 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
101482 0 : std::cout << " not valid " << std::endl;
101483 : }
101484 : }
101485 :
101486 0 : if ( p_startOfConstruct != NULL )
101487 : {
101488 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101489 : {
101490 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
101491 : {
101492 0 : std::cout << "SgNonMembershipOp :: ";
101493 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
101494 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
101495 : }
101496 : }
101497 : else
101498 : {
101499 0 : std::cout << "SgNonMembershipOp :: " << std::flush;
101500 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
101501 0 : std::cout << " not valid " << std::endl;
101502 : }
101503 : }
101504 :
101505 0 : if ( p_endOfConstruct != NULL )
101506 : {
101507 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101508 : {
101509 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
101510 : {
101511 0 : std::cout << "SgNonMembershipOp :: ";
101512 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
101513 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
101514 : }
101515 : }
101516 : else
101517 : {
101518 0 : std::cout << "SgNonMembershipOp :: " << std::flush;
101519 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
101520 0 : std::cout << " not valid " << std::endl;
101521 : }
101522 : }
101523 :
101524 0 : if ( p_parent != NULL )
101525 : {
101526 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101527 : {
101528 0 : if ( p_parent->isInMemoryPool() == false )
101529 : {
101530 0 : std::cout << "SgNonMembershipOp :: ";
101531 0 : std::cout << " p_parent is not in memory pool of ";
101532 0 : std::cout << p_parent->class_name() << std::endl;
101533 : }
101534 : }
101535 : else
101536 : {
101537 0 : std::cout << "SgNonMembershipOp :: " << std::flush;
101538 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
101539 0 : std::cout << " not valid " << std::endl;
101540 : }
101541 : }
101542 :
101543 :
101544 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
101545 :
101546 0 : }
101547 :
101548 :
101549 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
101550 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
101551 : bool
101552 0 : SgNonMembershipOp::isInMemoryPool ()
101553 : {
101554 0 : typedef unsigned char* TestType;
101555 :
101556 0 : bool found = false;
101557 :
101558 0 : ROSE_ASSERT(this != NULL);
101559 :
101560 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
101561 :
101562 0 : TestType tested = (TestType) ( this ) ;
101563 :
101564 0 : std::vector < unsigned char* > :: const_iterator block = SgNonMembershipOp::pools.begin();
101565 :
101566 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
101567 : // while (found == false && block < Memory_Block_List.end())
101568 0 : while ( (found == false) && (block != SgNonMembershipOp::pools.end()) )
101569 : {
101570 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNonMembershipOp::pool_size * sizeof(SgNonMembershipOp) ) ) ;
101571 0 : ++block;
101572 : }
101573 :
101574 : // Special handling for static data
101575 :
101576 :
101577 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
101578 0 : ROSE_ASSERT(found == true);
101579 :
101580 0 : return found;
101581 : }
101582 : /* #line 101583 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
101583 :
101584 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
101585 :
101586 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
101587 :
101588 : /* #line 101589 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
101589 :
101590 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
101591 :
101592 : void
101593 0 : SgIsOp::checkDataMemberPointersIfInMemoryPool()
101594 : {
101595 : // ------------ checking pointers of SgIsOp -------------------
101596 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
101597 :
101598 0 : if ( p_lhs_operand_i != NULL )
101599 : {
101600 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101601 : {
101602 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
101603 : {
101604 0 : std::cout << "SgIsOp :: ";
101605 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
101606 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
101607 : }
101608 : }
101609 : else
101610 : {
101611 0 : std::cout << "SgIsOp :: " << std::flush;
101612 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
101613 0 : std::cout << " not valid " << std::endl;
101614 : }
101615 : }
101616 :
101617 0 : if ( p_rhs_operand_i != NULL )
101618 : {
101619 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101620 : {
101621 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
101622 : {
101623 0 : std::cout << "SgIsOp :: ";
101624 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
101625 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
101626 : }
101627 : }
101628 : else
101629 : {
101630 0 : std::cout << "SgIsOp :: " << std::flush;
101631 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
101632 0 : std::cout << " not valid " << std::endl;
101633 : }
101634 : }
101635 :
101636 0 : if ( p_expression_type != NULL )
101637 : {
101638 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101639 : {
101640 0 : if ( p_expression_type->isInMemoryPool() == false )
101641 : {
101642 0 : std::cout << "SgIsOp :: ";
101643 0 : std::cout << " p_expression_type is not in memory pool of ";
101644 0 : std::cout << p_expression_type->class_name() << std::endl;
101645 : }
101646 : }
101647 : else
101648 : {
101649 0 : std::cout << "SgIsOp :: " << std::flush;
101650 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
101651 0 : std::cout << " not valid " << std::endl;
101652 : }
101653 : }
101654 :
101655 0 : if ( p_originalExpressionTree != NULL )
101656 : {
101657 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101658 : {
101659 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
101660 : {
101661 0 : std::cout << "SgIsOp :: ";
101662 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
101663 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
101664 : }
101665 : }
101666 : else
101667 : {
101668 0 : std::cout << "SgIsOp :: " << std::flush;
101669 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
101670 0 : std::cout << " not valid " << std::endl;
101671 : }
101672 : }
101673 :
101674 0 : if ( p_operatorPosition != NULL )
101675 : {
101676 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101677 : {
101678 0 : if ( p_operatorPosition->isInMemoryPool() == false )
101679 : {
101680 0 : std::cout << "SgIsOp :: ";
101681 0 : std::cout << " p_operatorPosition is not in memory pool of ";
101682 0 : std::cout << p_operatorPosition->class_name() << std::endl;
101683 : }
101684 : }
101685 : else
101686 : {
101687 0 : std::cout << "SgIsOp :: " << std::flush;
101688 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
101689 0 : std::cout << " not valid " << std::endl;
101690 : }
101691 : }
101692 :
101693 0 : if ( p_startOfConstruct != NULL )
101694 : {
101695 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101696 : {
101697 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
101698 : {
101699 0 : std::cout << "SgIsOp :: ";
101700 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
101701 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
101702 : }
101703 : }
101704 : else
101705 : {
101706 0 : std::cout << "SgIsOp :: " << std::flush;
101707 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
101708 0 : std::cout << " not valid " << std::endl;
101709 : }
101710 : }
101711 :
101712 0 : if ( p_endOfConstruct != NULL )
101713 : {
101714 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101715 : {
101716 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
101717 : {
101718 0 : std::cout << "SgIsOp :: ";
101719 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
101720 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
101721 : }
101722 : }
101723 : else
101724 : {
101725 0 : std::cout << "SgIsOp :: " << std::flush;
101726 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
101727 0 : std::cout << " not valid " << std::endl;
101728 : }
101729 : }
101730 :
101731 0 : if ( p_parent != NULL )
101732 : {
101733 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101734 : {
101735 0 : if ( p_parent->isInMemoryPool() == false )
101736 : {
101737 0 : std::cout << "SgIsOp :: ";
101738 0 : std::cout << " p_parent is not in memory pool of ";
101739 0 : std::cout << p_parent->class_name() << std::endl;
101740 : }
101741 : }
101742 : else
101743 : {
101744 0 : std::cout << "SgIsOp :: " << std::flush;
101745 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
101746 0 : std::cout << " not valid " << std::endl;
101747 : }
101748 : }
101749 :
101750 :
101751 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
101752 :
101753 0 : }
101754 :
101755 :
101756 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
101757 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
101758 : bool
101759 0 : SgIsOp::isInMemoryPool ()
101760 : {
101761 0 : typedef unsigned char* TestType;
101762 :
101763 0 : bool found = false;
101764 :
101765 0 : ROSE_ASSERT(this != NULL);
101766 :
101767 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
101768 :
101769 0 : TestType tested = (TestType) ( this ) ;
101770 :
101771 0 : std::vector < unsigned char* > :: const_iterator block = SgIsOp::pools.begin();
101772 :
101773 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
101774 : // while (found == false && block < Memory_Block_List.end())
101775 0 : while ( (found == false) && (block != SgIsOp::pools.end()) )
101776 : {
101777 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIsOp::pool_size * sizeof(SgIsOp) ) ) ;
101778 0 : ++block;
101779 : }
101780 :
101781 : // Special handling for static data
101782 :
101783 :
101784 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
101785 0 : ROSE_ASSERT(found == true);
101786 :
101787 0 : return found;
101788 : }
101789 : /* #line 101790 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
101790 :
101791 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
101792 :
101793 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
101794 :
101795 : /* #line 101796 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
101796 :
101797 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
101798 :
101799 : void
101800 0 : SgIsNotOp::checkDataMemberPointersIfInMemoryPool()
101801 : {
101802 : // ------------ checking pointers of SgIsNotOp -------------------
101803 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
101804 :
101805 0 : if ( p_lhs_operand_i != NULL )
101806 : {
101807 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101808 : {
101809 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
101810 : {
101811 0 : std::cout << "SgIsNotOp :: ";
101812 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
101813 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
101814 : }
101815 : }
101816 : else
101817 : {
101818 0 : std::cout << "SgIsNotOp :: " << std::flush;
101819 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
101820 0 : std::cout << " not valid " << std::endl;
101821 : }
101822 : }
101823 :
101824 0 : if ( p_rhs_operand_i != NULL )
101825 : {
101826 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101827 : {
101828 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
101829 : {
101830 0 : std::cout << "SgIsNotOp :: ";
101831 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
101832 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
101833 : }
101834 : }
101835 : else
101836 : {
101837 0 : std::cout << "SgIsNotOp :: " << std::flush;
101838 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
101839 0 : std::cout << " not valid " << std::endl;
101840 : }
101841 : }
101842 :
101843 0 : if ( p_expression_type != NULL )
101844 : {
101845 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101846 : {
101847 0 : if ( p_expression_type->isInMemoryPool() == false )
101848 : {
101849 0 : std::cout << "SgIsNotOp :: ";
101850 0 : std::cout << " p_expression_type is not in memory pool of ";
101851 0 : std::cout << p_expression_type->class_name() << std::endl;
101852 : }
101853 : }
101854 : else
101855 : {
101856 0 : std::cout << "SgIsNotOp :: " << std::flush;
101857 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
101858 0 : std::cout << " not valid " << std::endl;
101859 : }
101860 : }
101861 :
101862 0 : if ( p_originalExpressionTree != NULL )
101863 : {
101864 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101865 : {
101866 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
101867 : {
101868 0 : std::cout << "SgIsNotOp :: ";
101869 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
101870 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
101871 : }
101872 : }
101873 : else
101874 : {
101875 0 : std::cout << "SgIsNotOp :: " << std::flush;
101876 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
101877 0 : std::cout << " not valid " << std::endl;
101878 : }
101879 : }
101880 :
101881 0 : if ( p_operatorPosition != NULL )
101882 : {
101883 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101884 : {
101885 0 : if ( p_operatorPosition->isInMemoryPool() == false )
101886 : {
101887 0 : std::cout << "SgIsNotOp :: ";
101888 0 : std::cout << " p_operatorPosition is not in memory pool of ";
101889 0 : std::cout << p_operatorPosition->class_name() << std::endl;
101890 : }
101891 : }
101892 : else
101893 : {
101894 0 : std::cout << "SgIsNotOp :: " << std::flush;
101895 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
101896 0 : std::cout << " not valid " << std::endl;
101897 : }
101898 : }
101899 :
101900 0 : if ( p_startOfConstruct != NULL )
101901 : {
101902 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101903 : {
101904 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
101905 : {
101906 0 : std::cout << "SgIsNotOp :: ";
101907 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
101908 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
101909 : }
101910 : }
101911 : else
101912 : {
101913 0 : std::cout << "SgIsNotOp :: " << std::flush;
101914 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
101915 0 : std::cout << " not valid " << std::endl;
101916 : }
101917 : }
101918 :
101919 0 : if ( p_endOfConstruct != NULL )
101920 : {
101921 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101922 : {
101923 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
101924 : {
101925 0 : std::cout << "SgIsNotOp :: ";
101926 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
101927 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
101928 : }
101929 : }
101930 : else
101931 : {
101932 0 : std::cout << "SgIsNotOp :: " << std::flush;
101933 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
101934 0 : std::cout << " not valid " << std::endl;
101935 : }
101936 : }
101937 :
101938 0 : if ( p_parent != NULL )
101939 : {
101940 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
101941 : {
101942 0 : if ( p_parent->isInMemoryPool() == false )
101943 : {
101944 0 : std::cout << "SgIsNotOp :: ";
101945 0 : std::cout << " p_parent is not in memory pool of ";
101946 0 : std::cout << p_parent->class_name() << std::endl;
101947 : }
101948 : }
101949 : else
101950 : {
101951 0 : std::cout << "SgIsNotOp :: " << std::flush;
101952 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
101953 0 : std::cout << " not valid " << std::endl;
101954 : }
101955 : }
101956 :
101957 :
101958 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
101959 :
101960 0 : }
101961 :
101962 :
101963 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
101964 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
101965 : bool
101966 0 : SgIsNotOp::isInMemoryPool ()
101967 : {
101968 0 : typedef unsigned char* TestType;
101969 :
101970 0 : bool found = false;
101971 :
101972 0 : ROSE_ASSERT(this != NULL);
101973 :
101974 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
101975 :
101976 0 : TestType tested = (TestType) ( this ) ;
101977 :
101978 0 : std::vector < unsigned char* > :: const_iterator block = SgIsNotOp::pools.begin();
101979 :
101980 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
101981 : // while (found == false && block < Memory_Block_List.end())
101982 0 : while ( (found == false) && (block != SgIsNotOp::pools.end()) )
101983 : {
101984 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIsNotOp::pool_size * sizeof(SgIsNotOp) ) ) ;
101985 0 : ++block;
101986 : }
101987 :
101988 : // Special handling for static data
101989 :
101990 :
101991 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
101992 0 : ROSE_ASSERT(found == true);
101993 :
101994 0 : return found;
101995 : }
101996 : /* #line 101997 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
101997 :
101998 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
101999 :
102000 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
102001 :
102002 : /* #line 102003 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
102003 :
102004 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
102005 :
102006 : void
102007 0 : SgElementwiseOp::checkDataMemberPointersIfInMemoryPool()
102008 : {
102009 : // ------------ checking pointers of SgElementwiseOp -------------------
102010 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
102011 :
102012 0 : if ( p_lhs_operand_i != NULL )
102013 : {
102014 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102015 : {
102016 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
102017 : {
102018 0 : std::cout << "SgElementwiseOp :: ";
102019 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
102020 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
102021 : }
102022 : }
102023 : else
102024 : {
102025 0 : std::cout << "SgElementwiseOp :: " << std::flush;
102026 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
102027 0 : std::cout << " not valid " << std::endl;
102028 : }
102029 : }
102030 :
102031 0 : if ( p_rhs_operand_i != NULL )
102032 : {
102033 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102034 : {
102035 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
102036 : {
102037 0 : std::cout << "SgElementwiseOp :: ";
102038 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
102039 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
102040 : }
102041 : }
102042 : else
102043 : {
102044 0 : std::cout << "SgElementwiseOp :: " << std::flush;
102045 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
102046 0 : std::cout << " not valid " << std::endl;
102047 : }
102048 : }
102049 :
102050 0 : if ( p_expression_type != NULL )
102051 : {
102052 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102053 : {
102054 0 : if ( p_expression_type->isInMemoryPool() == false )
102055 : {
102056 0 : std::cout << "SgElementwiseOp :: ";
102057 0 : std::cout << " p_expression_type is not in memory pool of ";
102058 0 : std::cout << p_expression_type->class_name() << std::endl;
102059 : }
102060 : }
102061 : else
102062 : {
102063 0 : std::cout << "SgElementwiseOp :: " << std::flush;
102064 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
102065 0 : std::cout << " not valid " << std::endl;
102066 : }
102067 : }
102068 :
102069 0 : if ( p_originalExpressionTree != NULL )
102070 : {
102071 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102072 : {
102073 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
102074 : {
102075 0 : std::cout << "SgElementwiseOp :: ";
102076 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
102077 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
102078 : }
102079 : }
102080 : else
102081 : {
102082 0 : std::cout << "SgElementwiseOp :: " << std::flush;
102083 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
102084 0 : std::cout << " not valid " << std::endl;
102085 : }
102086 : }
102087 :
102088 0 : if ( p_operatorPosition != NULL )
102089 : {
102090 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102091 : {
102092 0 : if ( p_operatorPosition->isInMemoryPool() == false )
102093 : {
102094 0 : std::cout << "SgElementwiseOp :: ";
102095 0 : std::cout << " p_operatorPosition is not in memory pool of ";
102096 0 : std::cout << p_operatorPosition->class_name() << std::endl;
102097 : }
102098 : }
102099 : else
102100 : {
102101 0 : std::cout << "SgElementwiseOp :: " << std::flush;
102102 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
102103 0 : std::cout << " not valid " << std::endl;
102104 : }
102105 : }
102106 :
102107 0 : if ( p_startOfConstruct != NULL )
102108 : {
102109 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102110 : {
102111 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
102112 : {
102113 0 : std::cout << "SgElementwiseOp :: ";
102114 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
102115 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
102116 : }
102117 : }
102118 : else
102119 : {
102120 0 : std::cout << "SgElementwiseOp :: " << std::flush;
102121 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
102122 0 : std::cout << " not valid " << std::endl;
102123 : }
102124 : }
102125 :
102126 0 : if ( p_endOfConstruct != NULL )
102127 : {
102128 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102129 : {
102130 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
102131 : {
102132 0 : std::cout << "SgElementwiseOp :: ";
102133 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
102134 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
102135 : }
102136 : }
102137 : else
102138 : {
102139 0 : std::cout << "SgElementwiseOp :: " << std::flush;
102140 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
102141 0 : std::cout << " not valid " << std::endl;
102142 : }
102143 : }
102144 :
102145 0 : if ( p_parent != NULL )
102146 : {
102147 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102148 : {
102149 0 : if ( p_parent->isInMemoryPool() == false )
102150 : {
102151 0 : std::cout << "SgElementwiseOp :: ";
102152 0 : std::cout << " p_parent is not in memory pool of ";
102153 0 : std::cout << p_parent->class_name() << std::endl;
102154 : }
102155 : }
102156 : else
102157 : {
102158 0 : std::cout << "SgElementwiseOp :: " << std::flush;
102159 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
102160 0 : std::cout << " not valid " << std::endl;
102161 : }
102162 : }
102163 :
102164 :
102165 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
102166 :
102167 0 : }
102168 :
102169 :
102170 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
102171 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
102172 : bool
102173 0 : SgElementwiseOp::isInMemoryPool ()
102174 : {
102175 0 : typedef unsigned char* TestType;
102176 :
102177 0 : bool found = false;
102178 :
102179 0 : ROSE_ASSERT(this != NULL);
102180 :
102181 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
102182 :
102183 0 : TestType tested = (TestType) ( this ) ;
102184 :
102185 0 : std::vector < unsigned char* > :: const_iterator block = SgElementwiseOp::pools.begin();
102186 :
102187 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
102188 : // while (found == false && block < Memory_Block_List.end())
102189 0 : while ( (found == false) && (block != SgElementwiseOp::pools.end()) )
102190 : {
102191 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgElementwiseOp::pool_size * sizeof(SgElementwiseOp) ) ) ;
102192 0 : ++block;
102193 : }
102194 :
102195 : // Special handling for static data
102196 :
102197 :
102198 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
102199 0 : ROSE_ASSERT(found == true);
102200 :
102201 0 : return found;
102202 : }
102203 : /* #line 102204 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
102204 :
102205 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
102206 :
102207 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
102208 :
102209 : /* #line 102210 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
102210 :
102211 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
102212 :
102213 : void
102214 0 : SgElementwiseMultiplyOp::checkDataMemberPointersIfInMemoryPool()
102215 : {
102216 : // ------------ checking pointers of SgElementwiseMultiplyOp -------------------
102217 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
102218 :
102219 0 : if ( p_lhs_operand_i != NULL )
102220 : {
102221 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102222 : {
102223 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
102224 : {
102225 0 : std::cout << "SgElementwiseMultiplyOp :: ";
102226 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
102227 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
102228 : }
102229 : }
102230 : else
102231 : {
102232 0 : std::cout << "SgElementwiseMultiplyOp :: " << std::flush;
102233 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
102234 0 : std::cout << " not valid " << std::endl;
102235 : }
102236 : }
102237 :
102238 0 : if ( p_rhs_operand_i != NULL )
102239 : {
102240 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102241 : {
102242 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
102243 : {
102244 0 : std::cout << "SgElementwiseMultiplyOp :: ";
102245 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
102246 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
102247 : }
102248 : }
102249 : else
102250 : {
102251 0 : std::cout << "SgElementwiseMultiplyOp :: " << std::flush;
102252 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
102253 0 : std::cout << " not valid " << std::endl;
102254 : }
102255 : }
102256 :
102257 0 : if ( p_expression_type != NULL )
102258 : {
102259 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102260 : {
102261 0 : if ( p_expression_type->isInMemoryPool() == false )
102262 : {
102263 0 : std::cout << "SgElementwiseMultiplyOp :: ";
102264 0 : std::cout << " p_expression_type is not in memory pool of ";
102265 0 : std::cout << p_expression_type->class_name() << std::endl;
102266 : }
102267 : }
102268 : else
102269 : {
102270 0 : std::cout << "SgElementwiseMultiplyOp :: " << std::flush;
102271 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
102272 0 : std::cout << " not valid " << std::endl;
102273 : }
102274 : }
102275 :
102276 0 : if ( p_originalExpressionTree != NULL )
102277 : {
102278 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102279 : {
102280 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
102281 : {
102282 0 : std::cout << "SgElementwiseMultiplyOp :: ";
102283 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
102284 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
102285 : }
102286 : }
102287 : else
102288 : {
102289 0 : std::cout << "SgElementwiseMultiplyOp :: " << std::flush;
102290 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
102291 0 : std::cout << " not valid " << std::endl;
102292 : }
102293 : }
102294 :
102295 0 : if ( p_operatorPosition != NULL )
102296 : {
102297 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102298 : {
102299 0 : if ( p_operatorPosition->isInMemoryPool() == false )
102300 : {
102301 0 : std::cout << "SgElementwiseMultiplyOp :: ";
102302 0 : std::cout << " p_operatorPosition is not in memory pool of ";
102303 0 : std::cout << p_operatorPosition->class_name() << std::endl;
102304 : }
102305 : }
102306 : else
102307 : {
102308 0 : std::cout << "SgElementwiseMultiplyOp :: " << std::flush;
102309 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
102310 0 : std::cout << " not valid " << std::endl;
102311 : }
102312 : }
102313 :
102314 0 : if ( p_startOfConstruct != NULL )
102315 : {
102316 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102317 : {
102318 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
102319 : {
102320 0 : std::cout << "SgElementwiseMultiplyOp :: ";
102321 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
102322 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
102323 : }
102324 : }
102325 : else
102326 : {
102327 0 : std::cout << "SgElementwiseMultiplyOp :: " << std::flush;
102328 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
102329 0 : std::cout << " not valid " << std::endl;
102330 : }
102331 : }
102332 :
102333 0 : if ( p_endOfConstruct != NULL )
102334 : {
102335 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102336 : {
102337 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
102338 : {
102339 0 : std::cout << "SgElementwiseMultiplyOp :: ";
102340 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
102341 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
102342 : }
102343 : }
102344 : else
102345 : {
102346 0 : std::cout << "SgElementwiseMultiplyOp :: " << std::flush;
102347 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
102348 0 : std::cout << " not valid " << std::endl;
102349 : }
102350 : }
102351 :
102352 0 : if ( p_parent != NULL )
102353 : {
102354 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102355 : {
102356 0 : if ( p_parent->isInMemoryPool() == false )
102357 : {
102358 0 : std::cout << "SgElementwiseMultiplyOp :: ";
102359 0 : std::cout << " p_parent is not in memory pool of ";
102360 0 : std::cout << p_parent->class_name() << std::endl;
102361 : }
102362 : }
102363 : else
102364 : {
102365 0 : std::cout << "SgElementwiseMultiplyOp :: " << std::flush;
102366 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
102367 0 : std::cout << " not valid " << std::endl;
102368 : }
102369 : }
102370 :
102371 :
102372 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
102373 :
102374 0 : }
102375 :
102376 :
102377 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
102378 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
102379 : bool
102380 0 : SgElementwiseMultiplyOp::isInMemoryPool ()
102381 : {
102382 0 : typedef unsigned char* TestType;
102383 :
102384 0 : bool found = false;
102385 :
102386 0 : ROSE_ASSERT(this != NULL);
102387 :
102388 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
102389 :
102390 0 : TestType tested = (TestType) ( this ) ;
102391 :
102392 0 : std::vector < unsigned char* > :: const_iterator block = SgElementwiseMultiplyOp::pools.begin();
102393 :
102394 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
102395 : // while (found == false && block < Memory_Block_List.end())
102396 0 : while ( (found == false) && (block != SgElementwiseMultiplyOp::pools.end()) )
102397 : {
102398 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgElementwiseMultiplyOp::pool_size * sizeof(SgElementwiseMultiplyOp) ) ) ;
102399 0 : ++block;
102400 : }
102401 :
102402 : // Special handling for static data
102403 :
102404 :
102405 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
102406 0 : ROSE_ASSERT(found == true);
102407 :
102408 0 : return found;
102409 : }
102410 : /* #line 102411 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
102411 :
102412 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
102413 :
102414 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
102415 :
102416 : /* #line 102417 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
102417 :
102418 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
102419 :
102420 : void
102421 0 : SgElementwisePowerOp::checkDataMemberPointersIfInMemoryPool()
102422 : {
102423 : // ------------ checking pointers of SgElementwisePowerOp -------------------
102424 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
102425 :
102426 0 : if ( p_lhs_operand_i != NULL )
102427 : {
102428 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102429 : {
102430 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
102431 : {
102432 0 : std::cout << "SgElementwisePowerOp :: ";
102433 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
102434 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
102435 : }
102436 : }
102437 : else
102438 : {
102439 0 : std::cout << "SgElementwisePowerOp :: " << std::flush;
102440 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
102441 0 : std::cout << " not valid " << std::endl;
102442 : }
102443 : }
102444 :
102445 0 : if ( p_rhs_operand_i != NULL )
102446 : {
102447 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102448 : {
102449 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
102450 : {
102451 0 : std::cout << "SgElementwisePowerOp :: ";
102452 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
102453 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
102454 : }
102455 : }
102456 : else
102457 : {
102458 0 : std::cout << "SgElementwisePowerOp :: " << std::flush;
102459 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
102460 0 : std::cout << " not valid " << std::endl;
102461 : }
102462 : }
102463 :
102464 0 : if ( p_expression_type != NULL )
102465 : {
102466 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102467 : {
102468 0 : if ( p_expression_type->isInMemoryPool() == false )
102469 : {
102470 0 : std::cout << "SgElementwisePowerOp :: ";
102471 0 : std::cout << " p_expression_type is not in memory pool of ";
102472 0 : std::cout << p_expression_type->class_name() << std::endl;
102473 : }
102474 : }
102475 : else
102476 : {
102477 0 : std::cout << "SgElementwisePowerOp :: " << std::flush;
102478 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
102479 0 : std::cout << " not valid " << std::endl;
102480 : }
102481 : }
102482 :
102483 0 : if ( p_originalExpressionTree != NULL )
102484 : {
102485 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102486 : {
102487 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
102488 : {
102489 0 : std::cout << "SgElementwisePowerOp :: ";
102490 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
102491 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
102492 : }
102493 : }
102494 : else
102495 : {
102496 0 : std::cout << "SgElementwisePowerOp :: " << std::flush;
102497 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
102498 0 : std::cout << " not valid " << std::endl;
102499 : }
102500 : }
102501 :
102502 0 : if ( p_operatorPosition != NULL )
102503 : {
102504 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102505 : {
102506 0 : if ( p_operatorPosition->isInMemoryPool() == false )
102507 : {
102508 0 : std::cout << "SgElementwisePowerOp :: ";
102509 0 : std::cout << " p_operatorPosition is not in memory pool of ";
102510 0 : std::cout << p_operatorPosition->class_name() << std::endl;
102511 : }
102512 : }
102513 : else
102514 : {
102515 0 : std::cout << "SgElementwisePowerOp :: " << std::flush;
102516 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
102517 0 : std::cout << " not valid " << std::endl;
102518 : }
102519 : }
102520 :
102521 0 : if ( p_startOfConstruct != NULL )
102522 : {
102523 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102524 : {
102525 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
102526 : {
102527 0 : std::cout << "SgElementwisePowerOp :: ";
102528 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
102529 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
102530 : }
102531 : }
102532 : else
102533 : {
102534 0 : std::cout << "SgElementwisePowerOp :: " << std::flush;
102535 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
102536 0 : std::cout << " not valid " << std::endl;
102537 : }
102538 : }
102539 :
102540 0 : if ( p_endOfConstruct != NULL )
102541 : {
102542 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102543 : {
102544 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
102545 : {
102546 0 : std::cout << "SgElementwisePowerOp :: ";
102547 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
102548 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
102549 : }
102550 : }
102551 : else
102552 : {
102553 0 : std::cout << "SgElementwisePowerOp :: " << std::flush;
102554 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
102555 0 : std::cout << " not valid " << std::endl;
102556 : }
102557 : }
102558 :
102559 0 : if ( p_parent != NULL )
102560 : {
102561 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102562 : {
102563 0 : if ( p_parent->isInMemoryPool() == false )
102564 : {
102565 0 : std::cout << "SgElementwisePowerOp :: ";
102566 0 : std::cout << " p_parent is not in memory pool of ";
102567 0 : std::cout << p_parent->class_name() << std::endl;
102568 : }
102569 : }
102570 : else
102571 : {
102572 0 : std::cout << "SgElementwisePowerOp :: " << std::flush;
102573 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
102574 0 : std::cout << " not valid " << std::endl;
102575 : }
102576 : }
102577 :
102578 :
102579 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
102580 :
102581 0 : }
102582 :
102583 :
102584 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
102585 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
102586 : bool
102587 0 : SgElementwisePowerOp::isInMemoryPool ()
102588 : {
102589 0 : typedef unsigned char* TestType;
102590 :
102591 0 : bool found = false;
102592 :
102593 0 : ROSE_ASSERT(this != NULL);
102594 :
102595 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
102596 :
102597 0 : TestType tested = (TestType) ( this ) ;
102598 :
102599 0 : std::vector < unsigned char* > :: const_iterator block = SgElementwisePowerOp::pools.begin();
102600 :
102601 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
102602 : // while (found == false && block < Memory_Block_List.end())
102603 0 : while ( (found == false) && (block != SgElementwisePowerOp::pools.end()) )
102604 : {
102605 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgElementwisePowerOp::pool_size * sizeof(SgElementwisePowerOp) ) ) ;
102606 0 : ++block;
102607 : }
102608 :
102609 : // Special handling for static data
102610 :
102611 :
102612 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
102613 0 : ROSE_ASSERT(found == true);
102614 :
102615 0 : return found;
102616 : }
102617 : /* #line 102618 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
102618 :
102619 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
102620 :
102621 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
102622 :
102623 : /* #line 102624 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
102624 :
102625 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
102626 :
102627 : void
102628 0 : SgElementwiseLeftDivideOp::checkDataMemberPointersIfInMemoryPool()
102629 : {
102630 : // ------------ checking pointers of SgElementwiseLeftDivideOp -------------------
102631 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
102632 :
102633 0 : if ( p_lhs_operand_i != NULL )
102634 : {
102635 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102636 : {
102637 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
102638 : {
102639 0 : std::cout << "SgElementwiseLeftDivideOp :: ";
102640 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
102641 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
102642 : }
102643 : }
102644 : else
102645 : {
102646 0 : std::cout << "SgElementwiseLeftDivideOp :: " << std::flush;
102647 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
102648 0 : std::cout << " not valid " << std::endl;
102649 : }
102650 : }
102651 :
102652 0 : if ( p_rhs_operand_i != NULL )
102653 : {
102654 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102655 : {
102656 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
102657 : {
102658 0 : std::cout << "SgElementwiseLeftDivideOp :: ";
102659 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
102660 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
102661 : }
102662 : }
102663 : else
102664 : {
102665 0 : std::cout << "SgElementwiseLeftDivideOp :: " << std::flush;
102666 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
102667 0 : std::cout << " not valid " << std::endl;
102668 : }
102669 : }
102670 :
102671 0 : if ( p_expression_type != NULL )
102672 : {
102673 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102674 : {
102675 0 : if ( p_expression_type->isInMemoryPool() == false )
102676 : {
102677 0 : std::cout << "SgElementwiseLeftDivideOp :: ";
102678 0 : std::cout << " p_expression_type is not in memory pool of ";
102679 0 : std::cout << p_expression_type->class_name() << std::endl;
102680 : }
102681 : }
102682 : else
102683 : {
102684 0 : std::cout << "SgElementwiseLeftDivideOp :: " << std::flush;
102685 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
102686 0 : std::cout << " not valid " << std::endl;
102687 : }
102688 : }
102689 :
102690 0 : if ( p_originalExpressionTree != NULL )
102691 : {
102692 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102693 : {
102694 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
102695 : {
102696 0 : std::cout << "SgElementwiseLeftDivideOp :: ";
102697 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
102698 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
102699 : }
102700 : }
102701 : else
102702 : {
102703 0 : std::cout << "SgElementwiseLeftDivideOp :: " << std::flush;
102704 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
102705 0 : std::cout << " not valid " << std::endl;
102706 : }
102707 : }
102708 :
102709 0 : if ( p_operatorPosition != NULL )
102710 : {
102711 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102712 : {
102713 0 : if ( p_operatorPosition->isInMemoryPool() == false )
102714 : {
102715 0 : std::cout << "SgElementwiseLeftDivideOp :: ";
102716 0 : std::cout << " p_operatorPosition is not in memory pool of ";
102717 0 : std::cout << p_operatorPosition->class_name() << std::endl;
102718 : }
102719 : }
102720 : else
102721 : {
102722 0 : std::cout << "SgElementwiseLeftDivideOp :: " << std::flush;
102723 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
102724 0 : std::cout << " not valid " << std::endl;
102725 : }
102726 : }
102727 :
102728 0 : if ( p_startOfConstruct != NULL )
102729 : {
102730 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102731 : {
102732 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
102733 : {
102734 0 : std::cout << "SgElementwiseLeftDivideOp :: ";
102735 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
102736 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
102737 : }
102738 : }
102739 : else
102740 : {
102741 0 : std::cout << "SgElementwiseLeftDivideOp :: " << std::flush;
102742 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
102743 0 : std::cout << " not valid " << std::endl;
102744 : }
102745 : }
102746 :
102747 0 : if ( p_endOfConstruct != NULL )
102748 : {
102749 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102750 : {
102751 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
102752 : {
102753 0 : std::cout << "SgElementwiseLeftDivideOp :: ";
102754 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
102755 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
102756 : }
102757 : }
102758 : else
102759 : {
102760 0 : std::cout << "SgElementwiseLeftDivideOp :: " << std::flush;
102761 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
102762 0 : std::cout << " not valid " << std::endl;
102763 : }
102764 : }
102765 :
102766 0 : if ( p_parent != NULL )
102767 : {
102768 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102769 : {
102770 0 : if ( p_parent->isInMemoryPool() == false )
102771 : {
102772 0 : std::cout << "SgElementwiseLeftDivideOp :: ";
102773 0 : std::cout << " p_parent is not in memory pool of ";
102774 0 : std::cout << p_parent->class_name() << std::endl;
102775 : }
102776 : }
102777 : else
102778 : {
102779 0 : std::cout << "SgElementwiseLeftDivideOp :: " << std::flush;
102780 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
102781 0 : std::cout << " not valid " << std::endl;
102782 : }
102783 : }
102784 :
102785 :
102786 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
102787 :
102788 0 : }
102789 :
102790 :
102791 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
102792 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
102793 : bool
102794 0 : SgElementwiseLeftDivideOp::isInMemoryPool ()
102795 : {
102796 0 : typedef unsigned char* TestType;
102797 :
102798 0 : bool found = false;
102799 :
102800 0 : ROSE_ASSERT(this != NULL);
102801 :
102802 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
102803 :
102804 0 : TestType tested = (TestType) ( this ) ;
102805 :
102806 0 : std::vector < unsigned char* > :: const_iterator block = SgElementwiseLeftDivideOp::pools.begin();
102807 :
102808 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
102809 : // while (found == false && block < Memory_Block_List.end())
102810 0 : while ( (found == false) && (block != SgElementwiseLeftDivideOp::pools.end()) )
102811 : {
102812 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgElementwiseLeftDivideOp::pool_size * sizeof(SgElementwiseLeftDivideOp) ) ) ;
102813 0 : ++block;
102814 : }
102815 :
102816 : // Special handling for static data
102817 :
102818 :
102819 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
102820 0 : ROSE_ASSERT(found == true);
102821 :
102822 0 : return found;
102823 : }
102824 : /* #line 102825 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
102825 :
102826 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
102827 :
102828 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
102829 :
102830 : /* #line 102831 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
102831 :
102832 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
102833 :
102834 : void
102835 0 : SgElementwiseDivideOp::checkDataMemberPointersIfInMemoryPool()
102836 : {
102837 : // ------------ checking pointers of SgElementwiseDivideOp -------------------
102838 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
102839 :
102840 0 : if ( p_lhs_operand_i != NULL )
102841 : {
102842 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102843 : {
102844 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
102845 : {
102846 0 : std::cout << "SgElementwiseDivideOp :: ";
102847 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
102848 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
102849 : }
102850 : }
102851 : else
102852 : {
102853 0 : std::cout << "SgElementwiseDivideOp :: " << std::flush;
102854 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
102855 0 : std::cout << " not valid " << std::endl;
102856 : }
102857 : }
102858 :
102859 0 : if ( p_rhs_operand_i != NULL )
102860 : {
102861 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102862 : {
102863 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
102864 : {
102865 0 : std::cout << "SgElementwiseDivideOp :: ";
102866 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
102867 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
102868 : }
102869 : }
102870 : else
102871 : {
102872 0 : std::cout << "SgElementwiseDivideOp :: " << std::flush;
102873 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
102874 0 : std::cout << " not valid " << std::endl;
102875 : }
102876 : }
102877 :
102878 0 : if ( p_expression_type != NULL )
102879 : {
102880 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102881 : {
102882 0 : if ( p_expression_type->isInMemoryPool() == false )
102883 : {
102884 0 : std::cout << "SgElementwiseDivideOp :: ";
102885 0 : std::cout << " p_expression_type is not in memory pool of ";
102886 0 : std::cout << p_expression_type->class_name() << std::endl;
102887 : }
102888 : }
102889 : else
102890 : {
102891 0 : std::cout << "SgElementwiseDivideOp :: " << std::flush;
102892 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
102893 0 : std::cout << " not valid " << std::endl;
102894 : }
102895 : }
102896 :
102897 0 : if ( p_originalExpressionTree != NULL )
102898 : {
102899 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102900 : {
102901 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
102902 : {
102903 0 : std::cout << "SgElementwiseDivideOp :: ";
102904 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
102905 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
102906 : }
102907 : }
102908 : else
102909 : {
102910 0 : std::cout << "SgElementwiseDivideOp :: " << std::flush;
102911 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
102912 0 : std::cout << " not valid " << std::endl;
102913 : }
102914 : }
102915 :
102916 0 : if ( p_operatorPosition != NULL )
102917 : {
102918 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102919 : {
102920 0 : if ( p_operatorPosition->isInMemoryPool() == false )
102921 : {
102922 0 : std::cout << "SgElementwiseDivideOp :: ";
102923 0 : std::cout << " p_operatorPosition is not in memory pool of ";
102924 0 : std::cout << p_operatorPosition->class_name() << std::endl;
102925 : }
102926 : }
102927 : else
102928 : {
102929 0 : std::cout << "SgElementwiseDivideOp :: " << std::flush;
102930 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
102931 0 : std::cout << " not valid " << std::endl;
102932 : }
102933 : }
102934 :
102935 0 : if ( p_startOfConstruct != NULL )
102936 : {
102937 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102938 : {
102939 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
102940 : {
102941 0 : std::cout << "SgElementwiseDivideOp :: ";
102942 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
102943 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
102944 : }
102945 : }
102946 : else
102947 : {
102948 0 : std::cout << "SgElementwiseDivideOp :: " << std::flush;
102949 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
102950 0 : std::cout << " not valid " << std::endl;
102951 : }
102952 : }
102953 :
102954 0 : if ( p_endOfConstruct != NULL )
102955 : {
102956 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102957 : {
102958 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
102959 : {
102960 0 : std::cout << "SgElementwiseDivideOp :: ";
102961 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
102962 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
102963 : }
102964 : }
102965 : else
102966 : {
102967 0 : std::cout << "SgElementwiseDivideOp :: " << std::flush;
102968 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
102969 0 : std::cout << " not valid " << std::endl;
102970 : }
102971 : }
102972 :
102973 0 : if ( p_parent != NULL )
102974 : {
102975 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
102976 : {
102977 0 : if ( p_parent->isInMemoryPool() == false )
102978 : {
102979 0 : std::cout << "SgElementwiseDivideOp :: ";
102980 0 : std::cout << " p_parent is not in memory pool of ";
102981 0 : std::cout << p_parent->class_name() << std::endl;
102982 : }
102983 : }
102984 : else
102985 : {
102986 0 : std::cout << "SgElementwiseDivideOp :: " << std::flush;
102987 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
102988 0 : std::cout << " not valid " << std::endl;
102989 : }
102990 : }
102991 :
102992 :
102993 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
102994 :
102995 0 : }
102996 :
102997 :
102998 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
102999 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
103000 : bool
103001 0 : SgElementwiseDivideOp::isInMemoryPool ()
103002 : {
103003 0 : typedef unsigned char* TestType;
103004 :
103005 0 : bool found = false;
103006 :
103007 0 : ROSE_ASSERT(this != NULL);
103008 :
103009 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
103010 :
103011 0 : TestType tested = (TestType) ( this ) ;
103012 :
103013 0 : std::vector < unsigned char* > :: const_iterator block = SgElementwiseDivideOp::pools.begin();
103014 :
103015 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
103016 : // while (found == false && block < Memory_Block_List.end())
103017 0 : while ( (found == false) && (block != SgElementwiseDivideOp::pools.end()) )
103018 : {
103019 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgElementwiseDivideOp::pool_size * sizeof(SgElementwiseDivideOp) ) ) ;
103020 0 : ++block;
103021 : }
103022 :
103023 : // Special handling for static data
103024 :
103025 :
103026 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
103027 0 : ROSE_ASSERT(found == true);
103028 :
103029 0 : return found;
103030 : }
103031 : /* #line 103032 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
103032 :
103033 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
103034 :
103035 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
103036 :
103037 : /* #line 103038 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
103038 :
103039 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
103040 :
103041 : void
103042 0 : SgElementwiseAddOp::checkDataMemberPointersIfInMemoryPool()
103043 : {
103044 : // ------------ checking pointers of SgElementwiseAddOp -------------------
103045 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
103046 :
103047 0 : if ( p_lhs_operand_i != NULL )
103048 : {
103049 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103050 : {
103051 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
103052 : {
103053 0 : std::cout << "SgElementwiseAddOp :: ";
103054 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
103055 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
103056 : }
103057 : }
103058 : else
103059 : {
103060 0 : std::cout << "SgElementwiseAddOp :: " << std::flush;
103061 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
103062 0 : std::cout << " not valid " << std::endl;
103063 : }
103064 : }
103065 :
103066 0 : if ( p_rhs_operand_i != NULL )
103067 : {
103068 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103069 : {
103070 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
103071 : {
103072 0 : std::cout << "SgElementwiseAddOp :: ";
103073 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
103074 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
103075 : }
103076 : }
103077 : else
103078 : {
103079 0 : std::cout << "SgElementwiseAddOp :: " << std::flush;
103080 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
103081 0 : std::cout << " not valid " << std::endl;
103082 : }
103083 : }
103084 :
103085 0 : if ( p_expression_type != NULL )
103086 : {
103087 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103088 : {
103089 0 : if ( p_expression_type->isInMemoryPool() == false )
103090 : {
103091 0 : std::cout << "SgElementwiseAddOp :: ";
103092 0 : std::cout << " p_expression_type is not in memory pool of ";
103093 0 : std::cout << p_expression_type->class_name() << std::endl;
103094 : }
103095 : }
103096 : else
103097 : {
103098 0 : std::cout << "SgElementwiseAddOp :: " << std::flush;
103099 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
103100 0 : std::cout << " not valid " << std::endl;
103101 : }
103102 : }
103103 :
103104 0 : if ( p_originalExpressionTree != NULL )
103105 : {
103106 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103107 : {
103108 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
103109 : {
103110 0 : std::cout << "SgElementwiseAddOp :: ";
103111 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
103112 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
103113 : }
103114 : }
103115 : else
103116 : {
103117 0 : std::cout << "SgElementwiseAddOp :: " << std::flush;
103118 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
103119 0 : std::cout << " not valid " << std::endl;
103120 : }
103121 : }
103122 :
103123 0 : if ( p_operatorPosition != NULL )
103124 : {
103125 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103126 : {
103127 0 : if ( p_operatorPosition->isInMemoryPool() == false )
103128 : {
103129 0 : std::cout << "SgElementwiseAddOp :: ";
103130 0 : std::cout << " p_operatorPosition is not in memory pool of ";
103131 0 : std::cout << p_operatorPosition->class_name() << std::endl;
103132 : }
103133 : }
103134 : else
103135 : {
103136 0 : std::cout << "SgElementwiseAddOp :: " << std::flush;
103137 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
103138 0 : std::cout << " not valid " << std::endl;
103139 : }
103140 : }
103141 :
103142 0 : if ( p_startOfConstruct != NULL )
103143 : {
103144 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103145 : {
103146 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
103147 : {
103148 0 : std::cout << "SgElementwiseAddOp :: ";
103149 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
103150 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
103151 : }
103152 : }
103153 : else
103154 : {
103155 0 : std::cout << "SgElementwiseAddOp :: " << std::flush;
103156 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
103157 0 : std::cout << " not valid " << std::endl;
103158 : }
103159 : }
103160 :
103161 0 : if ( p_endOfConstruct != NULL )
103162 : {
103163 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103164 : {
103165 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
103166 : {
103167 0 : std::cout << "SgElementwiseAddOp :: ";
103168 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
103169 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
103170 : }
103171 : }
103172 : else
103173 : {
103174 0 : std::cout << "SgElementwiseAddOp :: " << std::flush;
103175 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
103176 0 : std::cout << " not valid " << std::endl;
103177 : }
103178 : }
103179 :
103180 0 : if ( p_parent != NULL )
103181 : {
103182 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103183 : {
103184 0 : if ( p_parent->isInMemoryPool() == false )
103185 : {
103186 0 : std::cout << "SgElementwiseAddOp :: ";
103187 0 : std::cout << " p_parent is not in memory pool of ";
103188 0 : std::cout << p_parent->class_name() << std::endl;
103189 : }
103190 : }
103191 : else
103192 : {
103193 0 : std::cout << "SgElementwiseAddOp :: " << std::flush;
103194 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
103195 0 : std::cout << " not valid " << std::endl;
103196 : }
103197 : }
103198 :
103199 :
103200 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
103201 :
103202 0 : }
103203 :
103204 :
103205 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
103206 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
103207 : bool
103208 0 : SgElementwiseAddOp::isInMemoryPool ()
103209 : {
103210 0 : typedef unsigned char* TestType;
103211 :
103212 0 : bool found = false;
103213 :
103214 0 : ROSE_ASSERT(this != NULL);
103215 :
103216 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
103217 :
103218 0 : TestType tested = (TestType) ( this ) ;
103219 :
103220 0 : std::vector < unsigned char* > :: const_iterator block = SgElementwiseAddOp::pools.begin();
103221 :
103222 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
103223 : // while (found == false && block < Memory_Block_List.end())
103224 0 : while ( (found == false) && (block != SgElementwiseAddOp::pools.end()) )
103225 : {
103226 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgElementwiseAddOp::pool_size * sizeof(SgElementwiseAddOp) ) ) ;
103227 0 : ++block;
103228 : }
103229 :
103230 : // Special handling for static data
103231 :
103232 :
103233 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
103234 0 : ROSE_ASSERT(found == true);
103235 :
103236 0 : return found;
103237 : }
103238 : /* #line 103239 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
103239 :
103240 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
103241 :
103242 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
103243 :
103244 : /* #line 103245 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
103245 :
103246 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
103247 :
103248 : void
103249 0 : SgElementwiseSubtractOp::checkDataMemberPointersIfInMemoryPool()
103250 : {
103251 : // ------------ checking pointers of SgElementwiseSubtractOp -------------------
103252 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
103253 :
103254 0 : if ( p_lhs_operand_i != NULL )
103255 : {
103256 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103257 : {
103258 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
103259 : {
103260 0 : std::cout << "SgElementwiseSubtractOp :: ";
103261 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
103262 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
103263 : }
103264 : }
103265 : else
103266 : {
103267 0 : std::cout << "SgElementwiseSubtractOp :: " << std::flush;
103268 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
103269 0 : std::cout << " not valid " << std::endl;
103270 : }
103271 : }
103272 :
103273 0 : if ( p_rhs_operand_i != NULL )
103274 : {
103275 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103276 : {
103277 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
103278 : {
103279 0 : std::cout << "SgElementwiseSubtractOp :: ";
103280 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
103281 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
103282 : }
103283 : }
103284 : else
103285 : {
103286 0 : std::cout << "SgElementwiseSubtractOp :: " << std::flush;
103287 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
103288 0 : std::cout << " not valid " << std::endl;
103289 : }
103290 : }
103291 :
103292 0 : if ( p_expression_type != NULL )
103293 : {
103294 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103295 : {
103296 0 : if ( p_expression_type->isInMemoryPool() == false )
103297 : {
103298 0 : std::cout << "SgElementwiseSubtractOp :: ";
103299 0 : std::cout << " p_expression_type is not in memory pool of ";
103300 0 : std::cout << p_expression_type->class_name() << std::endl;
103301 : }
103302 : }
103303 : else
103304 : {
103305 0 : std::cout << "SgElementwiseSubtractOp :: " << std::flush;
103306 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
103307 0 : std::cout << " not valid " << std::endl;
103308 : }
103309 : }
103310 :
103311 0 : if ( p_originalExpressionTree != NULL )
103312 : {
103313 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103314 : {
103315 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
103316 : {
103317 0 : std::cout << "SgElementwiseSubtractOp :: ";
103318 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
103319 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
103320 : }
103321 : }
103322 : else
103323 : {
103324 0 : std::cout << "SgElementwiseSubtractOp :: " << std::flush;
103325 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
103326 0 : std::cout << " not valid " << std::endl;
103327 : }
103328 : }
103329 :
103330 0 : if ( p_operatorPosition != NULL )
103331 : {
103332 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103333 : {
103334 0 : if ( p_operatorPosition->isInMemoryPool() == false )
103335 : {
103336 0 : std::cout << "SgElementwiseSubtractOp :: ";
103337 0 : std::cout << " p_operatorPosition is not in memory pool of ";
103338 0 : std::cout << p_operatorPosition->class_name() << std::endl;
103339 : }
103340 : }
103341 : else
103342 : {
103343 0 : std::cout << "SgElementwiseSubtractOp :: " << std::flush;
103344 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
103345 0 : std::cout << " not valid " << std::endl;
103346 : }
103347 : }
103348 :
103349 0 : if ( p_startOfConstruct != NULL )
103350 : {
103351 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103352 : {
103353 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
103354 : {
103355 0 : std::cout << "SgElementwiseSubtractOp :: ";
103356 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
103357 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
103358 : }
103359 : }
103360 : else
103361 : {
103362 0 : std::cout << "SgElementwiseSubtractOp :: " << std::flush;
103363 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
103364 0 : std::cout << " not valid " << std::endl;
103365 : }
103366 : }
103367 :
103368 0 : if ( p_endOfConstruct != NULL )
103369 : {
103370 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103371 : {
103372 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
103373 : {
103374 0 : std::cout << "SgElementwiseSubtractOp :: ";
103375 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
103376 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
103377 : }
103378 : }
103379 : else
103380 : {
103381 0 : std::cout << "SgElementwiseSubtractOp :: " << std::flush;
103382 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
103383 0 : std::cout << " not valid " << std::endl;
103384 : }
103385 : }
103386 :
103387 0 : if ( p_parent != NULL )
103388 : {
103389 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103390 : {
103391 0 : if ( p_parent->isInMemoryPool() == false )
103392 : {
103393 0 : std::cout << "SgElementwiseSubtractOp :: ";
103394 0 : std::cout << " p_parent is not in memory pool of ";
103395 0 : std::cout << p_parent->class_name() << std::endl;
103396 : }
103397 : }
103398 : else
103399 : {
103400 0 : std::cout << "SgElementwiseSubtractOp :: " << std::flush;
103401 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
103402 0 : std::cout << " not valid " << std::endl;
103403 : }
103404 : }
103405 :
103406 :
103407 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
103408 :
103409 0 : }
103410 :
103411 :
103412 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
103413 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
103414 : bool
103415 0 : SgElementwiseSubtractOp::isInMemoryPool ()
103416 : {
103417 0 : typedef unsigned char* TestType;
103418 :
103419 0 : bool found = false;
103420 :
103421 0 : ROSE_ASSERT(this != NULL);
103422 :
103423 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
103424 :
103425 0 : TestType tested = (TestType) ( this ) ;
103426 :
103427 0 : std::vector < unsigned char* > :: const_iterator block = SgElementwiseSubtractOp::pools.begin();
103428 :
103429 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
103430 : // while (found == false && block < Memory_Block_List.end())
103431 0 : while ( (found == false) && (block != SgElementwiseSubtractOp::pools.end()) )
103432 : {
103433 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgElementwiseSubtractOp::pool_size * sizeof(SgElementwiseSubtractOp) ) ) ;
103434 0 : ++block;
103435 : }
103436 :
103437 : // Special handling for static data
103438 :
103439 :
103440 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
103441 0 : ROSE_ASSERT(found == true);
103442 :
103443 0 : return found;
103444 : }
103445 : /* #line 103446 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
103446 :
103447 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
103448 :
103449 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
103450 :
103451 : /* #line 103452 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
103452 :
103453 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
103454 :
103455 : void
103456 0 : SgPowerOp::checkDataMemberPointersIfInMemoryPool()
103457 : {
103458 : // ------------ checking pointers of SgPowerOp -------------------
103459 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
103460 :
103461 0 : if ( p_lhs_operand_i != NULL )
103462 : {
103463 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103464 : {
103465 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
103466 : {
103467 0 : std::cout << "SgPowerOp :: ";
103468 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
103469 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
103470 : }
103471 : }
103472 : else
103473 : {
103474 0 : std::cout << "SgPowerOp :: " << std::flush;
103475 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
103476 0 : std::cout << " not valid " << std::endl;
103477 : }
103478 : }
103479 :
103480 0 : if ( p_rhs_operand_i != NULL )
103481 : {
103482 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103483 : {
103484 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
103485 : {
103486 0 : std::cout << "SgPowerOp :: ";
103487 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
103488 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
103489 : }
103490 : }
103491 : else
103492 : {
103493 0 : std::cout << "SgPowerOp :: " << std::flush;
103494 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
103495 0 : std::cout << " not valid " << std::endl;
103496 : }
103497 : }
103498 :
103499 0 : if ( p_expression_type != NULL )
103500 : {
103501 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103502 : {
103503 0 : if ( p_expression_type->isInMemoryPool() == false )
103504 : {
103505 0 : std::cout << "SgPowerOp :: ";
103506 0 : std::cout << " p_expression_type is not in memory pool of ";
103507 0 : std::cout << p_expression_type->class_name() << std::endl;
103508 : }
103509 : }
103510 : else
103511 : {
103512 0 : std::cout << "SgPowerOp :: " << std::flush;
103513 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
103514 0 : std::cout << " not valid " << std::endl;
103515 : }
103516 : }
103517 :
103518 0 : if ( p_originalExpressionTree != NULL )
103519 : {
103520 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103521 : {
103522 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
103523 : {
103524 0 : std::cout << "SgPowerOp :: ";
103525 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
103526 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
103527 : }
103528 : }
103529 : else
103530 : {
103531 0 : std::cout << "SgPowerOp :: " << std::flush;
103532 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
103533 0 : std::cout << " not valid " << std::endl;
103534 : }
103535 : }
103536 :
103537 0 : if ( p_operatorPosition != NULL )
103538 : {
103539 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103540 : {
103541 0 : if ( p_operatorPosition->isInMemoryPool() == false )
103542 : {
103543 0 : std::cout << "SgPowerOp :: ";
103544 0 : std::cout << " p_operatorPosition is not in memory pool of ";
103545 0 : std::cout << p_operatorPosition->class_name() << std::endl;
103546 : }
103547 : }
103548 : else
103549 : {
103550 0 : std::cout << "SgPowerOp :: " << std::flush;
103551 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
103552 0 : std::cout << " not valid " << std::endl;
103553 : }
103554 : }
103555 :
103556 0 : if ( p_startOfConstruct != NULL )
103557 : {
103558 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103559 : {
103560 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
103561 : {
103562 0 : std::cout << "SgPowerOp :: ";
103563 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
103564 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
103565 : }
103566 : }
103567 : else
103568 : {
103569 0 : std::cout << "SgPowerOp :: " << std::flush;
103570 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
103571 0 : std::cout << " not valid " << std::endl;
103572 : }
103573 : }
103574 :
103575 0 : if ( p_endOfConstruct != NULL )
103576 : {
103577 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103578 : {
103579 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
103580 : {
103581 0 : std::cout << "SgPowerOp :: ";
103582 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
103583 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
103584 : }
103585 : }
103586 : else
103587 : {
103588 0 : std::cout << "SgPowerOp :: " << std::flush;
103589 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
103590 0 : std::cout << " not valid " << std::endl;
103591 : }
103592 : }
103593 :
103594 0 : if ( p_parent != NULL )
103595 : {
103596 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103597 : {
103598 0 : if ( p_parent->isInMemoryPool() == false )
103599 : {
103600 0 : std::cout << "SgPowerOp :: ";
103601 0 : std::cout << " p_parent is not in memory pool of ";
103602 0 : std::cout << p_parent->class_name() << std::endl;
103603 : }
103604 : }
103605 : else
103606 : {
103607 0 : std::cout << "SgPowerOp :: " << std::flush;
103608 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
103609 0 : std::cout << " not valid " << std::endl;
103610 : }
103611 : }
103612 :
103613 :
103614 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
103615 :
103616 0 : }
103617 :
103618 :
103619 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
103620 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
103621 : bool
103622 0 : SgPowerOp::isInMemoryPool ()
103623 : {
103624 0 : typedef unsigned char* TestType;
103625 :
103626 0 : bool found = false;
103627 :
103628 0 : ROSE_ASSERT(this != NULL);
103629 :
103630 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
103631 :
103632 0 : TestType tested = (TestType) ( this ) ;
103633 :
103634 0 : std::vector < unsigned char* > :: const_iterator block = SgPowerOp::pools.begin();
103635 :
103636 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
103637 : // while (found == false && block < Memory_Block_List.end())
103638 0 : while ( (found == false) && (block != SgPowerOp::pools.end()) )
103639 : {
103640 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgPowerOp::pool_size * sizeof(SgPowerOp) ) ) ;
103641 0 : ++block;
103642 : }
103643 :
103644 : // Special handling for static data
103645 :
103646 :
103647 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
103648 0 : ROSE_ASSERT(found == true);
103649 :
103650 0 : return found;
103651 : }
103652 : /* #line 103653 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
103653 :
103654 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
103655 :
103656 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
103657 :
103658 : /* #line 103659 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
103659 :
103660 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
103661 :
103662 : void
103663 0 : SgLeftDivideOp::checkDataMemberPointersIfInMemoryPool()
103664 : {
103665 : // ------------ checking pointers of SgLeftDivideOp -------------------
103666 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
103667 :
103668 0 : if ( p_lhs_operand_i != NULL )
103669 : {
103670 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103671 : {
103672 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
103673 : {
103674 0 : std::cout << "SgLeftDivideOp :: ";
103675 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
103676 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
103677 : }
103678 : }
103679 : else
103680 : {
103681 0 : std::cout << "SgLeftDivideOp :: " << std::flush;
103682 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
103683 0 : std::cout << " not valid " << std::endl;
103684 : }
103685 : }
103686 :
103687 0 : if ( p_rhs_operand_i != NULL )
103688 : {
103689 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103690 : {
103691 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
103692 : {
103693 0 : std::cout << "SgLeftDivideOp :: ";
103694 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
103695 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
103696 : }
103697 : }
103698 : else
103699 : {
103700 0 : std::cout << "SgLeftDivideOp :: " << std::flush;
103701 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
103702 0 : std::cout << " not valid " << std::endl;
103703 : }
103704 : }
103705 :
103706 0 : if ( p_expression_type != NULL )
103707 : {
103708 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103709 : {
103710 0 : if ( p_expression_type->isInMemoryPool() == false )
103711 : {
103712 0 : std::cout << "SgLeftDivideOp :: ";
103713 0 : std::cout << " p_expression_type is not in memory pool of ";
103714 0 : std::cout << p_expression_type->class_name() << std::endl;
103715 : }
103716 : }
103717 : else
103718 : {
103719 0 : std::cout << "SgLeftDivideOp :: " << std::flush;
103720 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
103721 0 : std::cout << " not valid " << std::endl;
103722 : }
103723 : }
103724 :
103725 0 : if ( p_originalExpressionTree != NULL )
103726 : {
103727 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103728 : {
103729 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
103730 : {
103731 0 : std::cout << "SgLeftDivideOp :: ";
103732 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
103733 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
103734 : }
103735 : }
103736 : else
103737 : {
103738 0 : std::cout << "SgLeftDivideOp :: " << std::flush;
103739 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
103740 0 : std::cout << " not valid " << std::endl;
103741 : }
103742 : }
103743 :
103744 0 : if ( p_operatorPosition != NULL )
103745 : {
103746 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103747 : {
103748 0 : if ( p_operatorPosition->isInMemoryPool() == false )
103749 : {
103750 0 : std::cout << "SgLeftDivideOp :: ";
103751 0 : std::cout << " p_operatorPosition is not in memory pool of ";
103752 0 : std::cout << p_operatorPosition->class_name() << std::endl;
103753 : }
103754 : }
103755 : else
103756 : {
103757 0 : std::cout << "SgLeftDivideOp :: " << std::flush;
103758 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
103759 0 : std::cout << " not valid " << std::endl;
103760 : }
103761 : }
103762 :
103763 0 : if ( p_startOfConstruct != NULL )
103764 : {
103765 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103766 : {
103767 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
103768 : {
103769 0 : std::cout << "SgLeftDivideOp :: ";
103770 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
103771 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
103772 : }
103773 : }
103774 : else
103775 : {
103776 0 : std::cout << "SgLeftDivideOp :: " << std::flush;
103777 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
103778 0 : std::cout << " not valid " << std::endl;
103779 : }
103780 : }
103781 :
103782 0 : if ( p_endOfConstruct != NULL )
103783 : {
103784 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103785 : {
103786 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
103787 : {
103788 0 : std::cout << "SgLeftDivideOp :: ";
103789 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
103790 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
103791 : }
103792 : }
103793 : else
103794 : {
103795 0 : std::cout << "SgLeftDivideOp :: " << std::flush;
103796 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
103797 0 : std::cout << " not valid " << std::endl;
103798 : }
103799 : }
103800 :
103801 0 : if ( p_parent != NULL )
103802 : {
103803 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103804 : {
103805 0 : if ( p_parent->isInMemoryPool() == false )
103806 : {
103807 0 : std::cout << "SgLeftDivideOp :: ";
103808 0 : std::cout << " p_parent is not in memory pool of ";
103809 0 : std::cout << p_parent->class_name() << std::endl;
103810 : }
103811 : }
103812 : else
103813 : {
103814 0 : std::cout << "SgLeftDivideOp :: " << std::flush;
103815 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
103816 0 : std::cout << " not valid " << std::endl;
103817 : }
103818 : }
103819 :
103820 :
103821 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
103822 :
103823 0 : }
103824 :
103825 :
103826 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
103827 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
103828 : bool
103829 0 : SgLeftDivideOp::isInMemoryPool ()
103830 : {
103831 0 : typedef unsigned char* TestType;
103832 :
103833 0 : bool found = false;
103834 :
103835 0 : ROSE_ASSERT(this != NULL);
103836 :
103837 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
103838 :
103839 0 : TestType tested = (TestType) ( this ) ;
103840 :
103841 0 : std::vector < unsigned char* > :: const_iterator block = SgLeftDivideOp::pools.begin();
103842 :
103843 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
103844 : // while (found == false && block < Memory_Block_List.end())
103845 0 : while ( (found == false) && (block != SgLeftDivideOp::pools.end()) )
103846 : {
103847 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLeftDivideOp::pool_size * sizeof(SgLeftDivideOp) ) ) ;
103848 0 : ++block;
103849 : }
103850 :
103851 : // Special handling for static data
103852 :
103853 :
103854 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
103855 0 : ROSE_ASSERT(found == true);
103856 :
103857 0 : return found;
103858 : }
103859 : /* #line 103860 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
103860 :
103861 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
103862 :
103863 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
103864 :
103865 : /* #line 103866 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
103866 :
103867 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
103868 :
103869 : void
103870 0 : SgSIMDBinaryOp::checkDataMemberPointersIfInMemoryPool()
103871 : {
103872 : // ------------ checking pointers of SgSIMDBinaryOp -------------------
103873 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
103874 :
103875 0 : if ( p_lhs_operand_i != NULL )
103876 : {
103877 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103878 : {
103879 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
103880 : {
103881 0 : std::cout << "SgSIMDBinaryOp :: ";
103882 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
103883 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
103884 : }
103885 : }
103886 : else
103887 : {
103888 0 : std::cout << "SgSIMDBinaryOp :: " << std::flush;
103889 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
103890 0 : std::cout << " not valid " << std::endl;
103891 : }
103892 : }
103893 :
103894 0 : if ( p_rhs_operand_i != NULL )
103895 : {
103896 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103897 : {
103898 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
103899 : {
103900 0 : std::cout << "SgSIMDBinaryOp :: ";
103901 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
103902 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
103903 : }
103904 : }
103905 : else
103906 : {
103907 0 : std::cout << "SgSIMDBinaryOp :: " << std::flush;
103908 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
103909 0 : std::cout << " not valid " << std::endl;
103910 : }
103911 : }
103912 :
103913 0 : if ( p_expression_type != NULL )
103914 : {
103915 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103916 : {
103917 0 : if ( p_expression_type->isInMemoryPool() == false )
103918 : {
103919 0 : std::cout << "SgSIMDBinaryOp :: ";
103920 0 : std::cout << " p_expression_type is not in memory pool of ";
103921 0 : std::cout << p_expression_type->class_name() << std::endl;
103922 : }
103923 : }
103924 : else
103925 : {
103926 0 : std::cout << "SgSIMDBinaryOp :: " << std::flush;
103927 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
103928 0 : std::cout << " not valid " << std::endl;
103929 : }
103930 : }
103931 :
103932 0 : if ( p_originalExpressionTree != NULL )
103933 : {
103934 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103935 : {
103936 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
103937 : {
103938 0 : std::cout << "SgSIMDBinaryOp :: ";
103939 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
103940 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
103941 : }
103942 : }
103943 : else
103944 : {
103945 0 : std::cout << "SgSIMDBinaryOp :: " << std::flush;
103946 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
103947 0 : std::cout << " not valid " << std::endl;
103948 : }
103949 : }
103950 :
103951 0 : if ( p_operatorPosition != NULL )
103952 : {
103953 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103954 : {
103955 0 : if ( p_operatorPosition->isInMemoryPool() == false )
103956 : {
103957 0 : std::cout << "SgSIMDBinaryOp :: ";
103958 0 : std::cout << " p_operatorPosition is not in memory pool of ";
103959 0 : std::cout << p_operatorPosition->class_name() << std::endl;
103960 : }
103961 : }
103962 : else
103963 : {
103964 0 : std::cout << "SgSIMDBinaryOp :: " << std::flush;
103965 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
103966 0 : std::cout << " not valid " << std::endl;
103967 : }
103968 : }
103969 :
103970 0 : if ( p_startOfConstruct != NULL )
103971 : {
103972 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103973 : {
103974 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
103975 : {
103976 0 : std::cout << "SgSIMDBinaryOp :: ";
103977 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
103978 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
103979 : }
103980 : }
103981 : else
103982 : {
103983 0 : std::cout << "SgSIMDBinaryOp :: " << std::flush;
103984 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
103985 0 : std::cout << " not valid " << std::endl;
103986 : }
103987 : }
103988 :
103989 0 : if ( p_endOfConstruct != NULL )
103990 : {
103991 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
103992 : {
103993 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
103994 : {
103995 0 : std::cout << "SgSIMDBinaryOp :: ";
103996 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
103997 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
103998 : }
103999 : }
104000 : else
104001 : {
104002 0 : std::cout << "SgSIMDBinaryOp :: " << std::flush;
104003 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
104004 0 : std::cout << " not valid " << std::endl;
104005 : }
104006 : }
104007 :
104008 0 : if ( p_parent != NULL )
104009 : {
104010 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104011 : {
104012 0 : if ( p_parent->isInMemoryPool() == false )
104013 : {
104014 0 : std::cout << "SgSIMDBinaryOp :: ";
104015 0 : std::cout << " p_parent is not in memory pool of ";
104016 0 : std::cout << p_parent->class_name() << std::endl;
104017 : }
104018 : }
104019 : else
104020 : {
104021 0 : std::cout << "SgSIMDBinaryOp :: " << std::flush;
104022 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
104023 0 : std::cout << " not valid " << std::endl;
104024 : }
104025 : }
104026 :
104027 :
104028 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
104029 :
104030 0 : }
104031 :
104032 :
104033 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
104034 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
104035 : bool
104036 0 : SgSIMDBinaryOp::isInMemoryPool ()
104037 : {
104038 0 : typedef unsigned char* TestType;
104039 :
104040 0 : bool found = false;
104041 :
104042 0 : ROSE_ASSERT(this != NULL);
104043 :
104044 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
104045 :
104046 0 : TestType tested = (TestType) ( this ) ;
104047 :
104048 0 : std::vector < unsigned char* > :: const_iterator block = SgSIMDBinaryOp::pools.begin();
104049 :
104050 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
104051 : // while (found == false && block < Memory_Block_List.end())
104052 0 : while ( (found == false) && (block != SgSIMDBinaryOp::pools.end()) )
104053 : {
104054 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSIMDBinaryOp::pool_size * sizeof(SgSIMDBinaryOp) ) ) ;
104055 0 : ++block;
104056 : }
104057 :
104058 : // Special handling for static data
104059 :
104060 :
104061 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
104062 0 : ROSE_ASSERT(found == true);
104063 :
104064 0 : return found;
104065 : }
104066 : /* #line 104067 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
104067 :
104068 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
104069 :
104070 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
104071 :
104072 : /* #line 104073 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
104073 :
104074 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
104075 :
104076 : void
104077 0 : SgSIMDAddOp::checkDataMemberPointersIfInMemoryPool()
104078 : {
104079 : // ------------ checking pointers of SgSIMDAddOp -------------------
104080 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
104081 :
104082 0 : if ( p_lhs_operand_i != NULL )
104083 : {
104084 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104085 : {
104086 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
104087 : {
104088 0 : std::cout << "SgSIMDAddOp :: ";
104089 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
104090 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
104091 : }
104092 : }
104093 : else
104094 : {
104095 0 : std::cout << "SgSIMDAddOp :: " << std::flush;
104096 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
104097 0 : std::cout << " not valid " << std::endl;
104098 : }
104099 : }
104100 :
104101 0 : if ( p_rhs_operand_i != NULL )
104102 : {
104103 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104104 : {
104105 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
104106 : {
104107 0 : std::cout << "SgSIMDAddOp :: ";
104108 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
104109 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
104110 : }
104111 : }
104112 : else
104113 : {
104114 0 : std::cout << "SgSIMDAddOp :: " << std::flush;
104115 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
104116 0 : std::cout << " not valid " << std::endl;
104117 : }
104118 : }
104119 :
104120 0 : if ( p_expression_type != NULL )
104121 : {
104122 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104123 : {
104124 0 : if ( p_expression_type->isInMemoryPool() == false )
104125 : {
104126 0 : std::cout << "SgSIMDAddOp :: ";
104127 0 : std::cout << " p_expression_type is not in memory pool of ";
104128 0 : std::cout << p_expression_type->class_name() << std::endl;
104129 : }
104130 : }
104131 : else
104132 : {
104133 0 : std::cout << "SgSIMDAddOp :: " << std::flush;
104134 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
104135 0 : std::cout << " not valid " << std::endl;
104136 : }
104137 : }
104138 :
104139 0 : if ( p_originalExpressionTree != NULL )
104140 : {
104141 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104142 : {
104143 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
104144 : {
104145 0 : std::cout << "SgSIMDAddOp :: ";
104146 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
104147 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
104148 : }
104149 : }
104150 : else
104151 : {
104152 0 : std::cout << "SgSIMDAddOp :: " << std::flush;
104153 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
104154 0 : std::cout << " not valid " << std::endl;
104155 : }
104156 : }
104157 :
104158 0 : if ( p_operatorPosition != NULL )
104159 : {
104160 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104161 : {
104162 0 : if ( p_operatorPosition->isInMemoryPool() == false )
104163 : {
104164 0 : std::cout << "SgSIMDAddOp :: ";
104165 0 : std::cout << " p_operatorPosition is not in memory pool of ";
104166 0 : std::cout << p_operatorPosition->class_name() << std::endl;
104167 : }
104168 : }
104169 : else
104170 : {
104171 0 : std::cout << "SgSIMDAddOp :: " << std::flush;
104172 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
104173 0 : std::cout << " not valid " << std::endl;
104174 : }
104175 : }
104176 :
104177 0 : if ( p_startOfConstruct != NULL )
104178 : {
104179 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104180 : {
104181 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
104182 : {
104183 0 : std::cout << "SgSIMDAddOp :: ";
104184 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
104185 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
104186 : }
104187 : }
104188 : else
104189 : {
104190 0 : std::cout << "SgSIMDAddOp :: " << std::flush;
104191 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
104192 0 : std::cout << " not valid " << std::endl;
104193 : }
104194 : }
104195 :
104196 0 : if ( p_endOfConstruct != NULL )
104197 : {
104198 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104199 : {
104200 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
104201 : {
104202 0 : std::cout << "SgSIMDAddOp :: ";
104203 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
104204 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
104205 : }
104206 : }
104207 : else
104208 : {
104209 0 : std::cout << "SgSIMDAddOp :: " << std::flush;
104210 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
104211 0 : std::cout << " not valid " << std::endl;
104212 : }
104213 : }
104214 :
104215 0 : if ( p_parent != NULL )
104216 : {
104217 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104218 : {
104219 0 : if ( p_parent->isInMemoryPool() == false )
104220 : {
104221 0 : std::cout << "SgSIMDAddOp :: ";
104222 0 : std::cout << " p_parent is not in memory pool of ";
104223 0 : std::cout << p_parent->class_name() << std::endl;
104224 : }
104225 : }
104226 : else
104227 : {
104228 0 : std::cout << "SgSIMDAddOp :: " << std::flush;
104229 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
104230 0 : std::cout << " not valid " << std::endl;
104231 : }
104232 : }
104233 :
104234 :
104235 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
104236 :
104237 0 : }
104238 :
104239 :
104240 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
104241 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
104242 : bool
104243 0 : SgSIMDAddOp::isInMemoryPool ()
104244 : {
104245 0 : typedef unsigned char* TestType;
104246 :
104247 0 : bool found = false;
104248 :
104249 0 : ROSE_ASSERT(this != NULL);
104250 :
104251 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
104252 :
104253 0 : TestType tested = (TestType) ( this ) ;
104254 :
104255 0 : std::vector < unsigned char* > :: const_iterator block = SgSIMDAddOp::pools.begin();
104256 :
104257 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
104258 : // while (found == false && block < Memory_Block_List.end())
104259 0 : while ( (found == false) && (block != SgSIMDAddOp::pools.end()) )
104260 : {
104261 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSIMDAddOp::pool_size * sizeof(SgSIMDAddOp) ) ) ;
104262 0 : ++block;
104263 : }
104264 :
104265 : // Special handling for static data
104266 :
104267 :
104268 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
104269 0 : ROSE_ASSERT(found == true);
104270 :
104271 0 : return found;
104272 : }
104273 : /* #line 104274 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
104274 :
104275 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
104276 :
104277 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
104278 :
104279 : /* #line 104280 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
104280 :
104281 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
104282 :
104283 : void
104284 0 : SgSIMDSubOp::checkDataMemberPointersIfInMemoryPool()
104285 : {
104286 : // ------------ checking pointers of SgSIMDSubOp -------------------
104287 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
104288 :
104289 0 : if ( p_lhs_operand_i != NULL )
104290 : {
104291 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104292 : {
104293 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
104294 : {
104295 0 : std::cout << "SgSIMDSubOp :: ";
104296 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
104297 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
104298 : }
104299 : }
104300 : else
104301 : {
104302 0 : std::cout << "SgSIMDSubOp :: " << std::flush;
104303 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
104304 0 : std::cout << " not valid " << std::endl;
104305 : }
104306 : }
104307 :
104308 0 : if ( p_rhs_operand_i != NULL )
104309 : {
104310 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104311 : {
104312 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
104313 : {
104314 0 : std::cout << "SgSIMDSubOp :: ";
104315 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
104316 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
104317 : }
104318 : }
104319 : else
104320 : {
104321 0 : std::cout << "SgSIMDSubOp :: " << std::flush;
104322 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
104323 0 : std::cout << " not valid " << std::endl;
104324 : }
104325 : }
104326 :
104327 0 : if ( p_expression_type != NULL )
104328 : {
104329 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104330 : {
104331 0 : if ( p_expression_type->isInMemoryPool() == false )
104332 : {
104333 0 : std::cout << "SgSIMDSubOp :: ";
104334 0 : std::cout << " p_expression_type is not in memory pool of ";
104335 0 : std::cout << p_expression_type->class_name() << std::endl;
104336 : }
104337 : }
104338 : else
104339 : {
104340 0 : std::cout << "SgSIMDSubOp :: " << std::flush;
104341 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
104342 0 : std::cout << " not valid " << std::endl;
104343 : }
104344 : }
104345 :
104346 0 : if ( p_originalExpressionTree != NULL )
104347 : {
104348 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104349 : {
104350 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
104351 : {
104352 0 : std::cout << "SgSIMDSubOp :: ";
104353 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
104354 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
104355 : }
104356 : }
104357 : else
104358 : {
104359 0 : std::cout << "SgSIMDSubOp :: " << std::flush;
104360 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
104361 0 : std::cout << " not valid " << std::endl;
104362 : }
104363 : }
104364 :
104365 0 : if ( p_operatorPosition != NULL )
104366 : {
104367 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104368 : {
104369 0 : if ( p_operatorPosition->isInMemoryPool() == false )
104370 : {
104371 0 : std::cout << "SgSIMDSubOp :: ";
104372 0 : std::cout << " p_operatorPosition is not in memory pool of ";
104373 0 : std::cout << p_operatorPosition->class_name() << std::endl;
104374 : }
104375 : }
104376 : else
104377 : {
104378 0 : std::cout << "SgSIMDSubOp :: " << std::flush;
104379 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
104380 0 : std::cout << " not valid " << std::endl;
104381 : }
104382 : }
104383 :
104384 0 : if ( p_startOfConstruct != NULL )
104385 : {
104386 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104387 : {
104388 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
104389 : {
104390 0 : std::cout << "SgSIMDSubOp :: ";
104391 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
104392 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
104393 : }
104394 : }
104395 : else
104396 : {
104397 0 : std::cout << "SgSIMDSubOp :: " << std::flush;
104398 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
104399 0 : std::cout << " not valid " << std::endl;
104400 : }
104401 : }
104402 :
104403 0 : if ( p_endOfConstruct != NULL )
104404 : {
104405 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104406 : {
104407 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
104408 : {
104409 0 : std::cout << "SgSIMDSubOp :: ";
104410 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
104411 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
104412 : }
104413 : }
104414 : else
104415 : {
104416 0 : std::cout << "SgSIMDSubOp :: " << std::flush;
104417 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
104418 0 : std::cout << " not valid " << std::endl;
104419 : }
104420 : }
104421 :
104422 0 : if ( p_parent != NULL )
104423 : {
104424 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104425 : {
104426 0 : if ( p_parent->isInMemoryPool() == false )
104427 : {
104428 0 : std::cout << "SgSIMDSubOp :: ";
104429 0 : std::cout << " p_parent is not in memory pool of ";
104430 0 : std::cout << p_parent->class_name() << std::endl;
104431 : }
104432 : }
104433 : else
104434 : {
104435 0 : std::cout << "SgSIMDSubOp :: " << std::flush;
104436 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
104437 0 : std::cout << " not valid " << std::endl;
104438 : }
104439 : }
104440 :
104441 :
104442 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
104443 :
104444 0 : }
104445 :
104446 :
104447 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
104448 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
104449 : bool
104450 0 : SgSIMDSubOp::isInMemoryPool ()
104451 : {
104452 0 : typedef unsigned char* TestType;
104453 :
104454 0 : bool found = false;
104455 :
104456 0 : ROSE_ASSERT(this != NULL);
104457 :
104458 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
104459 :
104460 0 : TestType tested = (TestType) ( this ) ;
104461 :
104462 0 : std::vector < unsigned char* > :: const_iterator block = SgSIMDSubOp::pools.begin();
104463 :
104464 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
104465 : // while (found == false && block < Memory_Block_List.end())
104466 0 : while ( (found == false) && (block != SgSIMDSubOp::pools.end()) )
104467 : {
104468 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSIMDSubOp::pool_size * sizeof(SgSIMDSubOp) ) ) ;
104469 0 : ++block;
104470 : }
104471 :
104472 : // Special handling for static data
104473 :
104474 :
104475 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
104476 0 : ROSE_ASSERT(found == true);
104477 :
104478 0 : return found;
104479 : }
104480 : /* #line 104481 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
104481 :
104482 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
104483 :
104484 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
104485 :
104486 : /* #line 104487 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
104487 :
104488 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
104489 :
104490 : void
104491 0 : SgSIMDMulOp::checkDataMemberPointersIfInMemoryPool()
104492 : {
104493 : // ------------ checking pointers of SgSIMDMulOp -------------------
104494 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
104495 :
104496 0 : if ( p_lhs_operand_i != NULL )
104497 : {
104498 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104499 : {
104500 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
104501 : {
104502 0 : std::cout << "SgSIMDMulOp :: ";
104503 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
104504 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
104505 : }
104506 : }
104507 : else
104508 : {
104509 0 : std::cout << "SgSIMDMulOp :: " << std::flush;
104510 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
104511 0 : std::cout << " not valid " << std::endl;
104512 : }
104513 : }
104514 :
104515 0 : if ( p_rhs_operand_i != NULL )
104516 : {
104517 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104518 : {
104519 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
104520 : {
104521 0 : std::cout << "SgSIMDMulOp :: ";
104522 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
104523 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
104524 : }
104525 : }
104526 : else
104527 : {
104528 0 : std::cout << "SgSIMDMulOp :: " << std::flush;
104529 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
104530 0 : std::cout << " not valid " << std::endl;
104531 : }
104532 : }
104533 :
104534 0 : if ( p_expression_type != NULL )
104535 : {
104536 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104537 : {
104538 0 : if ( p_expression_type->isInMemoryPool() == false )
104539 : {
104540 0 : std::cout << "SgSIMDMulOp :: ";
104541 0 : std::cout << " p_expression_type is not in memory pool of ";
104542 0 : std::cout << p_expression_type->class_name() << std::endl;
104543 : }
104544 : }
104545 : else
104546 : {
104547 0 : std::cout << "SgSIMDMulOp :: " << std::flush;
104548 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
104549 0 : std::cout << " not valid " << std::endl;
104550 : }
104551 : }
104552 :
104553 0 : if ( p_originalExpressionTree != NULL )
104554 : {
104555 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104556 : {
104557 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
104558 : {
104559 0 : std::cout << "SgSIMDMulOp :: ";
104560 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
104561 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
104562 : }
104563 : }
104564 : else
104565 : {
104566 0 : std::cout << "SgSIMDMulOp :: " << std::flush;
104567 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
104568 0 : std::cout << " not valid " << std::endl;
104569 : }
104570 : }
104571 :
104572 0 : if ( p_operatorPosition != NULL )
104573 : {
104574 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104575 : {
104576 0 : if ( p_operatorPosition->isInMemoryPool() == false )
104577 : {
104578 0 : std::cout << "SgSIMDMulOp :: ";
104579 0 : std::cout << " p_operatorPosition is not in memory pool of ";
104580 0 : std::cout << p_operatorPosition->class_name() << std::endl;
104581 : }
104582 : }
104583 : else
104584 : {
104585 0 : std::cout << "SgSIMDMulOp :: " << std::flush;
104586 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
104587 0 : std::cout << " not valid " << std::endl;
104588 : }
104589 : }
104590 :
104591 0 : if ( p_startOfConstruct != NULL )
104592 : {
104593 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104594 : {
104595 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
104596 : {
104597 0 : std::cout << "SgSIMDMulOp :: ";
104598 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
104599 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
104600 : }
104601 : }
104602 : else
104603 : {
104604 0 : std::cout << "SgSIMDMulOp :: " << std::flush;
104605 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
104606 0 : std::cout << " not valid " << std::endl;
104607 : }
104608 : }
104609 :
104610 0 : if ( p_endOfConstruct != NULL )
104611 : {
104612 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104613 : {
104614 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
104615 : {
104616 0 : std::cout << "SgSIMDMulOp :: ";
104617 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
104618 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
104619 : }
104620 : }
104621 : else
104622 : {
104623 0 : std::cout << "SgSIMDMulOp :: " << std::flush;
104624 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
104625 0 : std::cout << " not valid " << std::endl;
104626 : }
104627 : }
104628 :
104629 0 : if ( p_parent != NULL )
104630 : {
104631 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104632 : {
104633 0 : if ( p_parent->isInMemoryPool() == false )
104634 : {
104635 0 : std::cout << "SgSIMDMulOp :: ";
104636 0 : std::cout << " p_parent is not in memory pool of ";
104637 0 : std::cout << p_parent->class_name() << std::endl;
104638 : }
104639 : }
104640 : else
104641 : {
104642 0 : std::cout << "SgSIMDMulOp :: " << std::flush;
104643 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
104644 0 : std::cout << " not valid " << std::endl;
104645 : }
104646 : }
104647 :
104648 :
104649 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
104650 :
104651 0 : }
104652 :
104653 :
104654 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
104655 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
104656 : bool
104657 0 : SgSIMDMulOp::isInMemoryPool ()
104658 : {
104659 0 : typedef unsigned char* TestType;
104660 :
104661 0 : bool found = false;
104662 :
104663 0 : ROSE_ASSERT(this != NULL);
104664 :
104665 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
104666 :
104667 0 : TestType tested = (TestType) ( this ) ;
104668 :
104669 0 : std::vector < unsigned char* > :: const_iterator block = SgSIMDMulOp::pools.begin();
104670 :
104671 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
104672 : // while (found == false && block < Memory_Block_List.end())
104673 0 : while ( (found == false) && (block != SgSIMDMulOp::pools.end()) )
104674 : {
104675 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSIMDMulOp::pool_size * sizeof(SgSIMDMulOp) ) ) ;
104676 0 : ++block;
104677 : }
104678 :
104679 : // Special handling for static data
104680 :
104681 :
104682 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
104683 0 : ROSE_ASSERT(found == true);
104684 :
104685 0 : return found;
104686 : }
104687 : /* #line 104688 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
104688 :
104689 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
104690 :
104691 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
104692 :
104693 : /* #line 104694 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
104694 :
104695 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
104696 :
104697 : void
104698 0 : SgSIMDDivOp::checkDataMemberPointersIfInMemoryPool()
104699 : {
104700 : // ------------ checking pointers of SgSIMDDivOp -------------------
104701 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
104702 :
104703 0 : if ( p_lhs_operand_i != NULL )
104704 : {
104705 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104706 : {
104707 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
104708 : {
104709 0 : std::cout << "SgSIMDDivOp :: ";
104710 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
104711 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
104712 : }
104713 : }
104714 : else
104715 : {
104716 0 : std::cout << "SgSIMDDivOp :: " << std::flush;
104717 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
104718 0 : std::cout << " not valid " << std::endl;
104719 : }
104720 : }
104721 :
104722 0 : if ( p_rhs_operand_i != NULL )
104723 : {
104724 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104725 : {
104726 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
104727 : {
104728 0 : std::cout << "SgSIMDDivOp :: ";
104729 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
104730 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
104731 : }
104732 : }
104733 : else
104734 : {
104735 0 : std::cout << "SgSIMDDivOp :: " << std::flush;
104736 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
104737 0 : std::cout << " not valid " << std::endl;
104738 : }
104739 : }
104740 :
104741 0 : if ( p_expression_type != NULL )
104742 : {
104743 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104744 : {
104745 0 : if ( p_expression_type->isInMemoryPool() == false )
104746 : {
104747 0 : std::cout << "SgSIMDDivOp :: ";
104748 0 : std::cout << " p_expression_type is not in memory pool of ";
104749 0 : std::cout << p_expression_type->class_name() << std::endl;
104750 : }
104751 : }
104752 : else
104753 : {
104754 0 : std::cout << "SgSIMDDivOp :: " << std::flush;
104755 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
104756 0 : std::cout << " not valid " << std::endl;
104757 : }
104758 : }
104759 :
104760 0 : if ( p_originalExpressionTree != NULL )
104761 : {
104762 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104763 : {
104764 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
104765 : {
104766 0 : std::cout << "SgSIMDDivOp :: ";
104767 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
104768 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
104769 : }
104770 : }
104771 : else
104772 : {
104773 0 : std::cout << "SgSIMDDivOp :: " << std::flush;
104774 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
104775 0 : std::cout << " not valid " << std::endl;
104776 : }
104777 : }
104778 :
104779 0 : if ( p_operatorPosition != NULL )
104780 : {
104781 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104782 : {
104783 0 : if ( p_operatorPosition->isInMemoryPool() == false )
104784 : {
104785 0 : std::cout << "SgSIMDDivOp :: ";
104786 0 : std::cout << " p_operatorPosition is not in memory pool of ";
104787 0 : std::cout << p_operatorPosition->class_name() << std::endl;
104788 : }
104789 : }
104790 : else
104791 : {
104792 0 : std::cout << "SgSIMDDivOp :: " << std::flush;
104793 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
104794 0 : std::cout << " not valid " << std::endl;
104795 : }
104796 : }
104797 :
104798 0 : if ( p_startOfConstruct != NULL )
104799 : {
104800 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104801 : {
104802 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
104803 : {
104804 0 : std::cout << "SgSIMDDivOp :: ";
104805 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
104806 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
104807 : }
104808 : }
104809 : else
104810 : {
104811 0 : std::cout << "SgSIMDDivOp :: " << std::flush;
104812 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
104813 0 : std::cout << " not valid " << std::endl;
104814 : }
104815 : }
104816 :
104817 0 : if ( p_endOfConstruct != NULL )
104818 : {
104819 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104820 : {
104821 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
104822 : {
104823 0 : std::cout << "SgSIMDDivOp :: ";
104824 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
104825 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
104826 : }
104827 : }
104828 : else
104829 : {
104830 0 : std::cout << "SgSIMDDivOp :: " << std::flush;
104831 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
104832 0 : std::cout << " not valid " << std::endl;
104833 : }
104834 : }
104835 :
104836 0 : if ( p_parent != NULL )
104837 : {
104838 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104839 : {
104840 0 : if ( p_parent->isInMemoryPool() == false )
104841 : {
104842 0 : std::cout << "SgSIMDDivOp :: ";
104843 0 : std::cout << " p_parent is not in memory pool of ";
104844 0 : std::cout << p_parent->class_name() << std::endl;
104845 : }
104846 : }
104847 : else
104848 : {
104849 0 : std::cout << "SgSIMDDivOp :: " << std::flush;
104850 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
104851 0 : std::cout << " not valid " << std::endl;
104852 : }
104853 : }
104854 :
104855 :
104856 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
104857 :
104858 0 : }
104859 :
104860 :
104861 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
104862 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
104863 : bool
104864 0 : SgSIMDDivOp::isInMemoryPool ()
104865 : {
104866 0 : typedef unsigned char* TestType;
104867 :
104868 0 : bool found = false;
104869 :
104870 0 : ROSE_ASSERT(this != NULL);
104871 :
104872 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
104873 :
104874 0 : TestType tested = (TestType) ( this ) ;
104875 :
104876 0 : std::vector < unsigned char* > :: const_iterator block = SgSIMDDivOp::pools.begin();
104877 :
104878 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
104879 : // while (found == false && block < Memory_Block_List.end())
104880 0 : while ( (found == false) && (block != SgSIMDDivOp::pools.end()) )
104881 : {
104882 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSIMDDivOp::pool_size * sizeof(SgSIMDDivOp) ) ) ;
104883 0 : ++block;
104884 : }
104885 :
104886 : // Special handling for static data
104887 :
104888 :
104889 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
104890 0 : ROSE_ASSERT(found == true);
104891 :
104892 0 : return found;
104893 : }
104894 : /* #line 104895 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
104895 :
104896 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
104897 :
104898 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
104899 :
104900 : /* #line 104901 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
104901 :
104902 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
104903 :
104904 : void
104905 0 : SgSIMDFmaOp::checkDataMemberPointersIfInMemoryPool()
104906 : {
104907 : // ------------ checking pointers of SgSIMDFmaOp -------------------
104908 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
104909 :
104910 0 : if ( p_lhs_operand_i != NULL )
104911 : {
104912 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104913 : {
104914 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
104915 : {
104916 0 : std::cout << "SgSIMDFmaOp :: ";
104917 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
104918 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
104919 : }
104920 : }
104921 : else
104922 : {
104923 0 : std::cout << "SgSIMDFmaOp :: " << std::flush;
104924 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
104925 0 : std::cout << " not valid " << std::endl;
104926 : }
104927 : }
104928 :
104929 0 : if ( p_rhs_operand_i != NULL )
104930 : {
104931 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104932 : {
104933 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
104934 : {
104935 0 : std::cout << "SgSIMDFmaOp :: ";
104936 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
104937 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
104938 : }
104939 : }
104940 : else
104941 : {
104942 0 : std::cout << "SgSIMDFmaOp :: " << std::flush;
104943 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
104944 0 : std::cout << " not valid " << std::endl;
104945 : }
104946 : }
104947 :
104948 0 : if ( p_expression_type != NULL )
104949 : {
104950 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104951 : {
104952 0 : if ( p_expression_type->isInMemoryPool() == false )
104953 : {
104954 0 : std::cout << "SgSIMDFmaOp :: ";
104955 0 : std::cout << " p_expression_type is not in memory pool of ";
104956 0 : std::cout << p_expression_type->class_name() << std::endl;
104957 : }
104958 : }
104959 : else
104960 : {
104961 0 : std::cout << "SgSIMDFmaOp :: " << std::flush;
104962 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
104963 0 : std::cout << " not valid " << std::endl;
104964 : }
104965 : }
104966 :
104967 0 : if ( p_originalExpressionTree != NULL )
104968 : {
104969 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104970 : {
104971 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
104972 : {
104973 0 : std::cout << "SgSIMDFmaOp :: ";
104974 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
104975 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
104976 : }
104977 : }
104978 : else
104979 : {
104980 0 : std::cout << "SgSIMDFmaOp :: " << std::flush;
104981 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
104982 0 : std::cout << " not valid " << std::endl;
104983 : }
104984 : }
104985 :
104986 0 : if ( p_operatorPosition != NULL )
104987 : {
104988 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
104989 : {
104990 0 : if ( p_operatorPosition->isInMemoryPool() == false )
104991 : {
104992 0 : std::cout << "SgSIMDFmaOp :: ";
104993 0 : std::cout << " p_operatorPosition is not in memory pool of ";
104994 0 : std::cout << p_operatorPosition->class_name() << std::endl;
104995 : }
104996 : }
104997 : else
104998 : {
104999 0 : std::cout << "SgSIMDFmaOp :: " << std::flush;
105000 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
105001 0 : std::cout << " not valid " << std::endl;
105002 : }
105003 : }
105004 :
105005 0 : if ( p_startOfConstruct != NULL )
105006 : {
105007 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105008 : {
105009 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
105010 : {
105011 0 : std::cout << "SgSIMDFmaOp :: ";
105012 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
105013 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
105014 : }
105015 : }
105016 : else
105017 : {
105018 0 : std::cout << "SgSIMDFmaOp :: " << std::flush;
105019 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
105020 0 : std::cout << " not valid " << std::endl;
105021 : }
105022 : }
105023 :
105024 0 : if ( p_endOfConstruct != NULL )
105025 : {
105026 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105027 : {
105028 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
105029 : {
105030 0 : std::cout << "SgSIMDFmaOp :: ";
105031 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
105032 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
105033 : }
105034 : }
105035 : else
105036 : {
105037 0 : std::cout << "SgSIMDFmaOp :: " << std::flush;
105038 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
105039 0 : std::cout << " not valid " << std::endl;
105040 : }
105041 : }
105042 :
105043 0 : if ( p_parent != NULL )
105044 : {
105045 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105046 : {
105047 0 : if ( p_parent->isInMemoryPool() == false )
105048 : {
105049 0 : std::cout << "SgSIMDFmaOp :: ";
105050 0 : std::cout << " p_parent is not in memory pool of ";
105051 0 : std::cout << p_parent->class_name() << std::endl;
105052 : }
105053 : }
105054 : else
105055 : {
105056 0 : std::cout << "SgSIMDFmaOp :: " << std::flush;
105057 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
105058 0 : std::cout << " not valid " << std::endl;
105059 : }
105060 : }
105061 :
105062 :
105063 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
105064 :
105065 0 : }
105066 :
105067 :
105068 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
105069 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
105070 : bool
105071 0 : SgSIMDFmaOp::isInMemoryPool ()
105072 : {
105073 0 : typedef unsigned char* TestType;
105074 :
105075 0 : bool found = false;
105076 :
105077 0 : ROSE_ASSERT(this != NULL);
105078 :
105079 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
105080 :
105081 0 : TestType tested = (TestType) ( this ) ;
105082 :
105083 0 : std::vector < unsigned char* > :: const_iterator block = SgSIMDFmaOp::pools.begin();
105084 :
105085 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
105086 : // while (found == false && block < Memory_Block_List.end())
105087 0 : while ( (found == false) && (block != SgSIMDFmaOp::pools.end()) )
105088 : {
105089 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSIMDFmaOp::pool_size * sizeof(SgSIMDFmaOp) ) ) ;
105090 0 : ++block;
105091 : }
105092 :
105093 : // Special handling for static data
105094 :
105095 :
105096 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
105097 0 : ROSE_ASSERT(found == true);
105098 :
105099 0 : return found;
105100 : }
105101 : /* #line 105102 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
105102 :
105103 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
105104 :
105105 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
105106 :
105107 : /* #line 105108 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
105108 :
105109 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
105110 :
105111 : void
105112 0 : SgSIMDLoad::checkDataMemberPointersIfInMemoryPool()
105113 : {
105114 : // ------------ checking pointers of SgSIMDLoad -------------------
105115 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
105116 :
105117 0 : if ( p_lhs_operand_i != NULL )
105118 : {
105119 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105120 : {
105121 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
105122 : {
105123 0 : std::cout << "SgSIMDLoad :: ";
105124 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
105125 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
105126 : }
105127 : }
105128 : else
105129 : {
105130 0 : std::cout << "SgSIMDLoad :: " << std::flush;
105131 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
105132 0 : std::cout << " not valid " << std::endl;
105133 : }
105134 : }
105135 :
105136 0 : if ( p_rhs_operand_i != NULL )
105137 : {
105138 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105139 : {
105140 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
105141 : {
105142 0 : std::cout << "SgSIMDLoad :: ";
105143 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
105144 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
105145 : }
105146 : }
105147 : else
105148 : {
105149 0 : std::cout << "SgSIMDLoad :: " << std::flush;
105150 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
105151 0 : std::cout << " not valid " << std::endl;
105152 : }
105153 : }
105154 :
105155 0 : if ( p_expression_type != NULL )
105156 : {
105157 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105158 : {
105159 0 : if ( p_expression_type->isInMemoryPool() == false )
105160 : {
105161 0 : std::cout << "SgSIMDLoad :: ";
105162 0 : std::cout << " p_expression_type is not in memory pool of ";
105163 0 : std::cout << p_expression_type->class_name() << std::endl;
105164 : }
105165 : }
105166 : else
105167 : {
105168 0 : std::cout << "SgSIMDLoad :: " << std::flush;
105169 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
105170 0 : std::cout << " not valid " << std::endl;
105171 : }
105172 : }
105173 :
105174 0 : if ( p_originalExpressionTree != NULL )
105175 : {
105176 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105177 : {
105178 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
105179 : {
105180 0 : std::cout << "SgSIMDLoad :: ";
105181 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
105182 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
105183 : }
105184 : }
105185 : else
105186 : {
105187 0 : std::cout << "SgSIMDLoad :: " << std::flush;
105188 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
105189 0 : std::cout << " not valid " << std::endl;
105190 : }
105191 : }
105192 :
105193 0 : if ( p_operatorPosition != NULL )
105194 : {
105195 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105196 : {
105197 0 : if ( p_operatorPosition->isInMemoryPool() == false )
105198 : {
105199 0 : std::cout << "SgSIMDLoad :: ";
105200 0 : std::cout << " p_operatorPosition is not in memory pool of ";
105201 0 : std::cout << p_operatorPosition->class_name() << std::endl;
105202 : }
105203 : }
105204 : else
105205 : {
105206 0 : std::cout << "SgSIMDLoad :: " << std::flush;
105207 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
105208 0 : std::cout << " not valid " << std::endl;
105209 : }
105210 : }
105211 :
105212 0 : if ( p_startOfConstruct != NULL )
105213 : {
105214 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105215 : {
105216 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
105217 : {
105218 0 : std::cout << "SgSIMDLoad :: ";
105219 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
105220 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
105221 : }
105222 : }
105223 : else
105224 : {
105225 0 : std::cout << "SgSIMDLoad :: " << std::flush;
105226 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
105227 0 : std::cout << " not valid " << std::endl;
105228 : }
105229 : }
105230 :
105231 0 : if ( p_endOfConstruct != NULL )
105232 : {
105233 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105234 : {
105235 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
105236 : {
105237 0 : std::cout << "SgSIMDLoad :: ";
105238 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
105239 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
105240 : }
105241 : }
105242 : else
105243 : {
105244 0 : std::cout << "SgSIMDLoad :: " << std::flush;
105245 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
105246 0 : std::cout << " not valid " << std::endl;
105247 : }
105248 : }
105249 :
105250 0 : if ( p_parent != NULL )
105251 : {
105252 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105253 : {
105254 0 : if ( p_parent->isInMemoryPool() == false )
105255 : {
105256 0 : std::cout << "SgSIMDLoad :: ";
105257 0 : std::cout << " p_parent is not in memory pool of ";
105258 0 : std::cout << p_parent->class_name() << std::endl;
105259 : }
105260 : }
105261 : else
105262 : {
105263 0 : std::cout << "SgSIMDLoad :: " << std::flush;
105264 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
105265 0 : std::cout << " not valid " << std::endl;
105266 : }
105267 : }
105268 :
105269 :
105270 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
105271 :
105272 0 : }
105273 :
105274 :
105275 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
105276 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
105277 : bool
105278 0 : SgSIMDLoad::isInMemoryPool ()
105279 : {
105280 0 : typedef unsigned char* TestType;
105281 :
105282 0 : bool found = false;
105283 :
105284 0 : ROSE_ASSERT(this != NULL);
105285 :
105286 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
105287 :
105288 0 : TestType tested = (TestType) ( this ) ;
105289 :
105290 0 : std::vector < unsigned char* > :: const_iterator block = SgSIMDLoad::pools.begin();
105291 :
105292 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
105293 : // while (found == false && block < Memory_Block_List.end())
105294 0 : while ( (found == false) && (block != SgSIMDLoad::pools.end()) )
105295 : {
105296 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSIMDLoad::pool_size * sizeof(SgSIMDLoad) ) ) ;
105297 0 : ++block;
105298 : }
105299 :
105300 : // Special handling for static data
105301 :
105302 :
105303 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
105304 0 : ROSE_ASSERT(found == true);
105305 :
105306 0 : return found;
105307 : }
105308 : /* #line 105309 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
105309 :
105310 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
105311 :
105312 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
105313 :
105314 : /* #line 105315 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
105315 :
105316 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
105317 :
105318 : void
105319 0 : SgSIMDBroadcast::checkDataMemberPointersIfInMemoryPool()
105320 : {
105321 : // ------------ checking pointers of SgSIMDBroadcast -------------------
105322 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
105323 :
105324 0 : if ( p_lhs_operand_i != NULL )
105325 : {
105326 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105327 : {
105328 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
105329 : {
105330 0 : std::cout << "SgSIMDBroadcast :: ";
105331 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
105332 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
105333 : }
105334 : }
105335 : else
105336 : {
105337 0 : std::cout << "SgSIMDBroadcast :: " << std::flush;
105338 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
105339 0 : std::cout << " not valid " << std::endl;
105340 : }
105341 : }
105342 :
105343 0 : if ( p_rhs_operand_i != NULL )
105344 : {
105345 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105346 : {
105347 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
105348 : {
105349 0 : std::cout << "SgSIMDBroadcast :: ";
105350 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
105351 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
105352 : }
105353 : }
105354 : else
105355 : {
105356 0 : std::cout << "SgSIMDBroadcast :: " << std::flush;
105357 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
105358 0 : std::cout << " not valid " << std::endl;
105359 : }
105360 : }
105361 :
105362 0 : if ( p_expression_type != NULL )
105363 : {
105364 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105365 : {
105366 0 : if ( p_expression_type->isInMemoryPool() == false )
105367 : {
105368 0 : std::cout << "SgSIMDBroadcast :: ";
105369 0 : std::cout << " p_expression_type is not in memory pool of ";
105370 0 : std::cout << p_expression_type->class_name() << std::endl;
105371 : }
105372 : }
105373 : else
105374 : {
105375 0 : std::cout << "SgSIMDBroadcast :: " << std::flush;
105376 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
105377 0 : std::cout << " not valid " << std::endl;
105378 : }
105379 : }
105380 :
105381 0 : if ( p_originalExpressionTree != NULL )
105382 : {
105383 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105384 : {
105385 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
105386 : {
105387 0 : std::cout << "SgSIMDBroadcast :: ";
105388 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
105389 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
105390 : }
105391 : }
105392 : else
105393 : {
105394 0 : std::cout << "SgSIMDBroadcast :: " << std::flush;
105395 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
105396 0 : std::cout << " not valid " << std::endl;
105397 : }
105398 : }
105399 :
105400 0 : if ( p_operatorPosition != NULL )
105401 : {
105402 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105403 : {
105404 0 : if ( p_operatorPosition->isInMemoryPool() == false )
105405 : {
105406 0 : std::cout << "SgSIMDBroadcast :: ";
105407 0 : std::cout << " p_operatorPosition is not in memory pool of ";
105408 0 : std::cout << p_operatorPosition->class_name() << std::endl;
105409 : }
105410 : }
105411 : else
105412 : {
105413 0 : std::cout << "SgSIMDBroadcast :: " << std::flush;
105414 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
105415 0 : std::cout << " not valid " << std::endl;
105416 : }
105417 : }
105418 :
105419 0 : if ( p_startOfConstruct != NULL )
105420 : {
105421 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105422 : {
105423 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
105424 : {
105425 0 : std::cout << "SgSIMDBroadcast :: ";
105426 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
105427 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
105428 : }
105429 : }
105430 : else
105431 : {
105432 0 : std::cout << "SgSIMDBroadcast :: " << std::flush;
105433 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
105434 0 : std::cout << " not valid " << std::endl;
105435 : }
105436 : }
105437 :
105438 0 : if ( p_endOfConstruct != NULL )
105439 : {
105440 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105441 : {
105442 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
105443 : {
105444 0 : std::cout << "SgSIMDBroadcast :: ";
105445 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
105446 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
105447 : }
105448 : }
105449 : else
105450 : {
105451 0 : std::cout << "SgSIMDBroadcast :: " << std::flush;
105452 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
105453 0 : std::cout << " not valid " << std::endl;
105454 : }
105455 : }
105456 :
105457 0 : if ( p_parent != NULL )
105458 : {
105459 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105460 : {
105461 0 : if ( p_parent->isInMemoryPool() == false )
105462 : {
105463 0 : std::cout << "SgSIMDBroadcast :: ";
105464 0 : std::cout << " p_parent is not in memory pool of ";
105465 0 : std::cout << p_parent->class_name() << std::endl;
105466 : }
105467 : }
105468 : else
105469 : {
105470 0 : std::cout << "SgSIMDBroadcast :: " << std::flush;
105471 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
105472 0 : std::cout << " not valid " << std::endl;
105473 : }
105474 : }
105475 :
105476 :
105477 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
105478 :
105479 0 : }
105480 :
105481 :
105482 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
105483 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
105484 : bool
105485 0 : SgSIMDBroadcast::isInMemoryPool ()
105486 : {
105487 0 : typedef unsigned char* TestType;
105488 :
105489 0 : bool found = false;
105490 :
105491 0 : ROSE_ASSERT(this != NULL);
105492 :
105493 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
105494 :
105495 0 : TestType tested = (TestType) ( this ) ;
105496 :
105497 0 : std::vector < unsigned char* > :: const_iterator block = SgSIMDBroadcast::pools.begin();
105498 :
105499 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
105500 : // while (found == false && block < Memory_Block_List.end())
105501 0 : while ( (found == false) && (block != SgSIMDBroadcast::pools.end()) )
105502 : {
105503 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSIMDBroadcast::pool_size * sizeof(SgSIMDBroadcast) ) ) ;
105504 0 : ++block;
105505 : }
105506 :
105507 : // Special handling for static data
105508 :
105509 :
105510 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
105511 0 : ROSE_ASSERT(found == true);
105512 :
105513 0 : return found;
105514 : }
105515 : /* #line 105516 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
105516 :
105517 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
105518 :
105519 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
105520 :
105521 : /* #line 105522 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
105522 :
105523 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
105524 :
105525 : void
105526 0 : SgSIMDStore::checkDataMemberPointersIfInMemoryPool()
105527 : {
105528 : // ------------ checking pointers of SgSIMDStore -------------------
105529 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
105530 :
105531 0 : if ( p_lhs_operand_i != NULL )
105532 : {
105533 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105534 : {
105535 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
105536 : {
105537 0 : std::cout << "SgSIMDStore :: ";
105538 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
105539 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
105540 : }
105541 : }
105542 : else
105543 : {
105544 0 : std::cout << "SgSIMDStore :: " << std::flush;
105545 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
105546 0 : std::cout << " not valid " << std::endl;
105547 : }
105548 : }
105549 :
105550 0 : if ( p_rhs_operand_i != NULL )
105551 : {
105552 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105553 : {
105554 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
105555 : {
105556 0 : std::cout << "SgSIMDStore :: ";
105557 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
105558 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
105559 : }
105560 : }
105561 : else
105562 : {
105563 0 : std::cout << "SgSIMDStore :: " << std::flush;
105564 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
105565 0 : std::cout << " not valid " << std::endl;
105566 : }
105567 : }
105568 :
105569 0 : if ( p_expression_type != NULL )
105570 : {
105571 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105572 : {
105573 0 : if ( p_expression_type->isInMemoryPool() == false )
105574 : {
105575 0 : std::cout << "SgSIMDStore :: ";
105576 0 : std::cout << " p_expression_type is not in memory pool of ";
105577 0 : std::cout << p_expression_type->class_name() << std::endl;
105578 : }
105579 : }
105580 : else
105581 : {
105582 0 : std::cout << "SgSIMDStore :: " << std::flush;
105583 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
105584 0 : std::cout << " not valid " << std::endl;
105585 : }
105586 : }
105587 :
105588 0 : if ( p_originalExpressionTree != NULL )
105589 : {
105590 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105591 : {
105592 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
105593 : {
105594 0 : std::cout << "SgSIMDStore :: ";
105595 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
105596 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
105597 : }
105598 : }
105599 : else
105600 : {
105601 0 : std::cout << "SgSIMDStore :: " << std::flush;
105602 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
105603 0 : std::cout << " not valid " << std::endl;
105604 : }
105605 : }
105606 :
105607 0 : if ( p_operatorPosition != NULL )
105608 : {
105609 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105610 : {
105611 0 : if ( p_operatorPosition->isInMemoryPool() == false )
105612 : {
105613 0 : std::cout << "SgSIMDStore :: ";
105614 0 : std::cout << " p_operatorPosition is not in memory pool of ";
105615 0 : std::cout << p_operatorPosition->class_name() << std::endl;
105616 : }
105617 : }
105618 : else
105619 : {
105620 0 : std::cout << "SgSIMDStore :: " << std::flush;
105621 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
105622 0 : std::cout << " not valid " << std::endl;
105623 : }
105624 : }
105625 :
105626 0 : if ( p_startOfConstruct != NULL )
105627 : {
105628 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105629 : {
105630 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
105631 : {
105632 0 : std::cout << "SgSIMDStore :: ";
105633 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
105634 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
105635 : }
105636 : }
105637 : else
105638 : {
105639 0 : std::cout << "SgSIMDStore :: " << std::flush;
105640 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
105641 0 : std::cout << " not valid " << std::endl;
105642 : }
105643 : }
105644 :
105645 0 : if ( p_endOfConstruct != NULL )
105646 : {
105647 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105648 : {
105649 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
105650 : {
105651 0 : std::cout << "SgSIMDStore :: ";
105652 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
105653 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
105654 : }
105655 : }
105656 : else
105657 : {
105658 0 : std::cout << "SgSIMDStore :: " << std::flush;
105659 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
105660 0 : std::cout << " not valid " << std::endl;
105661 : }
105662 : }
105663 :
105664 0 : if ( p_parent != NULL )
105665 : {
105666 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105667 : {
105668 0 : if ( p_parent->isInMemoryPool() == false )
105669 : {
105670 0 : std::cout << "SgSIMDStore :: ";
105671 0 : std::cout << " p_parent is not in memory pool of ";
105672 0 : std::cout << p_parent->class_name() << std::endl;
105673 : }
105674 : }
105675 : else
105676 : {
105677 0 : std::cout << "SgSIMDStore :: " << std::flush;
105678 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
105679 0 : std::cout << " not valid " << std::endl;
105680 : }
105681 : }
105682 :
105683 :
105684 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
105685 :
105686 0 : }
105687 :
105688 :
105689 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
105690 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
105691 : bool
105692 0 : SgSIMDStore::isInMemoryPool ()
105693 : {
105694 0 : typedef unsigned char* TestType;
105695 :
105696 0 : bool found = false;
105697 :
105698 0 : ROSE_ASSERT(this != NULL);
105699 :
105700 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
105701 :
105702 0 : TestType tested = (TestType) ( this ) ;
105703 :
105704 0 : std::vector < unsigned char* > :: const_iterator block = SgSIMDStore::pools.begin();
105705 :
105706 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
105707 : // while (found == false && block < Memory_Block_List.end())
105708 0 : while ( (found == false) && (block != SgSIMDStore::pools.end()) )
105709 : {
105710 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSIMDStore::pool_size * sizeof(SgSIMDStore) ) ) ;
105711 0 : ++block;
105712 : }
105713 :
105714 : // Special handling for static data
105715 :
105716 :
105717 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
105718 0 : ROSE_ASSERT(found == true);
105719 :
105720 0 : return found;
105721 : }
105722 : /* #line 105723 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
105723 :
105724 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
105725 :
105726 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
105727 :
105728 : /* #line 105729 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
105729 :
105730 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
105731 :
105732 : void
105733 0 : SgSIMDPartialStore::checkDataMemberPointersIfInMemoryPool()
105734 : {
105735 : // ------------ checking pointers of SgSIMDPartialStore -------------------
105736 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
105737 :
105738 0 : if ( p_lhs_operand_i != NULL )
105739 : {
105740 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105741 : {
105742 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
105743 : {
105744 0 : std::cout << "SgSIMDPartialStore :: ";
105745 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
105746 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
105747 : }
105748 : }
105749 : else
105750 : {
105751 0 : std::cout << "SgSIMDPartialStore :: " << std::flush;
105752 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
105753 0 : std::cout << " not valid " << std::endl;
105754 : }
105755 : }
105756 :
105757 0 : if ( p_rhs_operand_i != NULL )
105758 : {
105759 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105760 : {
105761 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
105762 : {
105763 0 : std::cout << "SgSIMDPartialStore :: ";
105764 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
105765 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
105766 : }
105767 : }
105768 : else
105769 : {
105770 0 : std::cout << "SgSIMDPartialStore :: " << std::flush;
105771 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
105772 0 : std::cout << " not valid " << std::endl;
105773 : }
105774 : }
105775 :
105776 0 : if ( p_expression_type != NULL )
105777 : {
105778 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105779 : {
105780 0 : if ( p_expression_type->isInMemoryPool() == false )
105781 : {
105782 0 : std::cout << "SgSIMDPartialStore :: ";
105783 0 : std::cout << " p_expression_type is not in memory pool of ";
105784 0 : std::cout << p_expression_type->class_name() << std::endl;
105785 : }
105786 : }
105787 : else
105788 : {
105789 0 : std::cout << "SgSIMDPartialStore :: " << std::flush;
105790 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
105791 0 : std::cout << " not valid " << std::endl;
105792 : }
105793 : }
105794 :
105795 0 : if ( p_originalExpressionTree != NULL )
105796 : {
105797 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105798 : {
105799 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
105800 : {
105801 0 : std::cout << "SgSIMDPartialStore :: ";
105802 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
105803 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
105804 : }
105805 : }
105806 : else
105807 : {
105808 0 : std::cout << "SgSIMDPartialStore :: " << std::flush;
105809 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
105810 0 : std::cout << " not valid " << std::endl;
105811 : }
105812 : }
105813 :
105814 0 : if ( p_operatorPosition != NULL )
105815 : {
105816 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105817 : {
105818 0 : if ( p_operatorPosition->isInMemoryPool() == false )
105819 : {
105820 0 : std::cout << "SgSIMDPartialStore :: ";
105821 0 : std::cout << " p_operatorPosition is not in memory pool of ";
105822 0 : std::cout << p_operatorPosition->class_name() << std::endl;
105823 : }
105824 : }
105825 : else
105826 : {
105827 0 : std::cout << "SgSIMDPartialStore :: " << std::flush;
105828 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
105829 0 : std::cout << " not valid " << std::endl;
105830 : }
105831 : }
105832 :
105833 0 : if ( p_startOfConstruct != NULL )
105834 : {
105835 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105836 : {
105837 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
105838 : {
105839 0 : std::cout << "SgSIMDPartialStore :: ";
105840 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
105841 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
105842 : }
105843 : }
105844 : else
105845 : {
105846 0 : std::cout << "SgSIMDPartialStore :: " << std::flush;
105847 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
105848 0 : std::cout << " not valid " << std::endl;
105849 : }
105850 : }
105851 :
105852 0 : if ( p_endOfConstruct != NULL )
105853 : {
105854 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105855 : {
105856 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
105857 : {
105858 0 : std::cout << "SgSIMDPartialStore :: ";
105859 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
105860 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
105861 : }
105862 : }
105863 : else
105864 : {
105865 0 : std::cout << "SgSIMDPartialStore :: " << std::flush;
105866 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
105867 0 : std::cout << " not valid " << std::endl;
105868 : }
105869 : }
105870 :
105871 0 : if ( p_parent != NULL )
105872 : {
105873 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105874 : {
105875 0 : if ( p_parent->isInMemoryPool() == false )
105876 : {
105877 0 : std::cout << "SgSIMDPartialStore :: ";
105878 0 : std::cout << " p_parent is not in memory pool of ";
105879 0 : std::cout << p_parent->class_name() << std::endl;
105880 : }
105881 : }
105882 : else
105883 : {
105884 0 : std::cout << "SgSIMDPartialStore :: " << std::flush;
105885 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
105886 0 : std::cout << " not valid " << std::endl;
105887 : }
105888 : }
105889 :
105890 :
105891 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
105892 :
105893 0 : }
105894 :
105895 :
105896 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
105897 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
105898 : bool
105899 0 : SgSIMDPartialStore::isInMemoryPool ()
105900 : {
105901 0 : typedef unsigned char* TestType;
105902 :
105903 0 : bool found = false;
105904 :
105905 0 : ROSE_ASSERT(this != NULL);
105906 :
105907 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
105908 :
105909 0 : TestType tested = (TestType) ( this ) ;
105910 :
105911 0 : std::vector < unsigned char* > :: const_iterator block = SgSIMDPartialStore::pools.begin();
105912 :
105913 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
105914 : // while (found == false && block < Memory_Block_List.end())
105915 0 : while ( (found == false) && (block != SgSIMDPartialStore::pools.end()) )
105916 : {
105917 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSIMDPartialStore::pool_size * sizeof(SgSIMDPartialStore) ) ) ;
105918 0 : ++block;
105919 : }
105920 :
105921 : // Special handling for static data
105922 :
105923 :
105924 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
105925 0 : ROSE_ASSERT(found == true);
105926 :
105927 0 : return found;
105928 : }
105929 : /* #line 105930 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
105930 :
105931 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
105932 :
105933 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
105934 :
105935 : /* #line 105936 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
105936 :
105937 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
105938 :
105939 : void
105940 0 : SgSIMDScalarStore::checkDataMemberPointersIfInMemoryPool()
105941 : {
105942 : // ------------ checking pointers of SgSIMDScalarStore -------------------
105943 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
105944 :
105945 0 : if ( p_lhs_operand_i != NULL )
105946 : {
105947 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105948 : {
105949 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
105950 : {
105951 0 : std::cout << "SgSIMDScalarStore :: ";
105952 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
105953 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
105954 : }
105955 : }
105956 : else
105957 : {
105958 0 : std::cout << "SgSIMDScalarStore :: " << std::flush;
105959 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
105960 0 : std::cout << " not valid " << std::endl;
105961 : }
105962 : }
105963 :
105964 0 : if ( p_rhs_operand_i != NULL )
105965 : {
105966 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105967 : {
105968 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
105969 : {
105970 0 : std::cout << "SgSIMDScalarStore :: ";
105971 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
105972 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
105973 : }
105974 : }
105975 : else
105976 : {
105977 0 : std::cout << "SgSIMDScalarStore :: " << std::flush;
105978 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
105979 0 : std::cout << " not valid " << std::endl;
105980 : }
105981 : }
105982 :
105983 0 : if ( p_expression_type != NULL )
105984 : {
105985 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
105986 : {
105987 0 : if ( p_expression_type->isInMemoryPool() == false )
105988 : {
105989 0 : std::cout << "SgSIMDScalarStore :: ";
105990 0 : std::cout << " p_expression_type is not in memory pool of ";
105991 0 : std::cout << p_expression_type->class_name() << std::endl;
105992 : }
105993 : }
105994 : else
105995 : {
105996 0 : std::cout << "SgSIMDScalarStore :: " << std::flush;
105997 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
105998 0 : std::cout << " not valid " << std::endl;
105999 : }
106000 : }
106001 :
106002 0 : if ( p_originalExpressionTree != NULL )
106003 : {
106004 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106005 : {
106006 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
106007 : {
106008 0 : std::cout << "SgSIMDScalarStore :: ";
106009 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
106010 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
106011 : }
106012 : }
106013 : else
106014 : {
106015 0 : std::cout << "SgSIMDScalarStore :: " << std::flush;
106016 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
106017 0 : std::cout << " not valid " << std::endl;
106018 : }
106019 : }
106020 :
106021 0 : if ( p_operatorPosition != NULL )
106022 : {
106023 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106024 : {
106025 0 : if ( p_operatorPosition->isInMemoryPool() == false )
106026 : {
106027 0 : std::cout << "SgSIMDScalarStore :: ";
106028 0 : std::cout << " p_operatorPosition is not in memory pool of ";
106029 0 : std::cout << p_operatorPosition->class_name() << std::endl;
106030 : }
106031 : }
106032 : else
106033 : {
106034 0 : std::cout << "SgSIMDScalarStore :: " << std::flush;
106035 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
106036 0 : std::cout << " not valid " << std::endl;
106037 : }
106038 : }
106039 :
106040 0 : if ( p_startOfConstruct != NULL )
106041 : {
106042 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106043 : {
106044 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
106045 : {
106046 0 : std::cout << "SgSIMDScalarStore :: ";
106047 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
106048 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
106049 : }
106050 : }
106051 : else
106052 : {
106053 0 : std::cout << "SgSIMDScalarStore :: " << std::flush;
106054 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
106055 0 : std::cout << " not valid " << std::endl;
106056 : }
106057 : }
106058 :
106059 0 : if ( p_endOfConstruct != NULL )
106060 : {
106061 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106062 : {
106063 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
106064 : {
106065 0 : std::cout << "SgSIMDScalarStore :: ";
106066 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
106067 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
106068 : }
106069 : }
106070 : else
106071 : {
106072 0 : std::cout << "SgSIMDScalarStore :: " << std::flush;
106073 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
106074 0 : std::cout << " not valid " << std::endl;
106075 : }
106076 : }
106077 :
106078 0 : if ( p_parent != NULL )
106079 : {
106080 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106081 : {
106082 0 : if ( p_parent->isInMemoryPool() == false )
106083 : {
106084 0 : std::cout << "SgSIMDScalarStore :: ";
106085 0 : std::cout << " p_parent is not in memory pool of ";
106086 0 : std::cout << p_parent->class_name() << std::endl;
106087 : }
106088 : }
106089 : else
106090 : {
106091 0 : std::cout << "SgSIMDScalarStore :: " << std::flush;
106092 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
106093 0 : std::cout << " not valid " << std::endl;
106094 : }
106095 : }
106096 :
106097 :
106098 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
106099 :
106100 0 : }
106101 :
106102 :
106103 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
106104 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
106105 : bool
106106 0 : SgSIMDScalarStore::isInMemoryPool ()
106107 : {
106108 0 : typedef unsigned char* TestType;
106109 :
106110 0 : bool found = false;
106111 :
106112 0 : ROSE_ASSERT(this != NULL);
106113 :
106114 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
106115 :
106116 0 : TestType tested = (TestType) ( this ) ;
106117 :
106118 0 : std::vector < unsigned char* > :: const_iterator block = SgSIMDScalarStore::pools.begin();
106119 :
106120 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
106121 : // while (found == false && block < Memory_Block_List.end())
106122 0 : while ( (found == false) && (block != SgSIMDScalarStore::pools.end()) )
106123 : {
106124 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSIMDScalarStore::pool_size * sizeof(SgSIMDScalarStore) ) ) ;
106125 0 : ++block;
106126 : }
106127 :
106128 : // Special handling for static data
106129 :
106130 :
106131 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
106132 0 : ROSE_ASSERT(found == true);
106133 :
106134 0 : return found;
106135 : }
106136 : /* #line 106137 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
106137 :
106138 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
106139 :
106140 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
106141 :
106142 : /* #line 106143 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
106143 :
106144 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
106145 :
106146 : void
106147 0 : SgSIMDGather::checkDataMemberPointersIfInMemoryPool()
106148 : {
106149 : // ------------ checking pointers of SgSIMDGather -------------------
106150 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
106151 :
106152 0 : if ( p_lhs_operand_i != NULL )
106153 : {
106154 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106155 : {
106156 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
106157 : {
106158 0 : std::cout << "SgSIMDGather :: ";
106159 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
106160 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
106161 : }
106162 : }
106163 : else
106164 : {
106165 0 : std::cout << "SgSIMDGather :: " << std::flush;
106166 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
106167 0 : std::cout << " not valid " << std::endl;
106168 : }
106169 : }
106170 :
106171 0 : if ( p_rhs_operand_i != NULL )
106172 : {
106173 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106174 : {
106175 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
106176 : {
106177 0 : std::cout << "SgSIMDGather :: ";
106178 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
106179 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
106180 : }
106181 : }
106182 : else
106183 : {
106184 0 : std::cout << "SgSIMDGather :: " << std::flush;
106185 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
106186 0 : std::cout << " not valid " << std::endl;
106187 : }
106188 : }
106189 :
106190 0 : if ( p_expression_type != NULL )
106191 : {
106192 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106193 : {
106194 0 : if ( p_expression_type->isInMemoryPool() == false )
106195 : {
106196 0 : std::cout << "SgSIMDGather :: ";
106197 0 : std::cout << " p_expression_type is not in memory pool of ";
106198 0 : std::cout << p_expression_type->class_name() << std::endl;
106199 : }
106200 : }
106201 : else
106202 : {
106203 0 : std::cout << "SgSIMDGather :: " << std::flush;
106204 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
106205 0 : std::cout << " not valid " << std::endl;
106206 : }
106207 : }
106208 :
106209 0 : if ( p_originalExpressionTree != NULL )
106210 : {
106211 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106212 : {
106213 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
106214 : {
106215 0 : std::cout << "SgSIMDGather :: ";
106216 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
106217 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
106218 : }
106219 : }
106220 : else
106221 : {
106222 0 : std::cout << "SgSIMDGather :: " << std::flush;
106223 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
106224 0 : std::cout << " not valid " << std::endl;
106225 : }
106226 : }
106227 :
106228 0 : if ( p_operatorPosition != NULL )
106229 : {
106230 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106231 : {
106232 0 : if ( p_operatorPosition->isInMemoryPool() == false )
106233 : {
106234 0 : std::cout << "SgSIMDGather :: ";
106235 0 : std::cout << " p_operatorPosition is not in memory pool of ";
106236 0 : std::cout << p_operatorPosition->class_name() << std::endl;
106237 : }
106238 : }
106239 : else
106240 : {
106241 0 : std::cout << "SgSIMDGather :: " << std::flush;
106242 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
106243 0 : std::cout << " not valid " << std::endl;
106244 : }
106245 : }
106246 :
106247 0 : if ( p_startOfConstruct != NULL )
106248 : {
106249 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106250 : {
106251 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
106252 : {
106253 0 : std::cout << "SgSIMDGather :: ";
106254 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
106255 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
106256 : }
106257 : }
106258 : else
106259 : {
106260 0 : std::cout << "SgSIMDGather :: " << std::flush;
106261 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
106262 0 : std::cout << " not valid " << std::endl;
106263 : }
106264 : }
106265 :
106266 0 : if ( p_endOfConstruct != NULL )
106267 : {
106268 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106269 : {
106270 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
106271 : {
106272 0 : std::cout << "SgSIMDGather :: ";
106273 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
106274 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
106275 : }
106276 : }
106277 : else
106278 : {
106279 0 : std::cout << "SgSIMDGather :: " << std::flush;
106280 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
106281 0 : std::cout << " not valid " << std::endl;
106282 : }
106283 : }
106284 :
106285 0 : if ( p_parent != NULL )
106286 : {
106287 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106288 : {
106289 0 : if ( p_parent->isInMemoryPool() == false )
106290 : {
106291 0 : std::cout << "SgSIMDGather :: ";
106292 0 : std::cout << " p_parent is not in memory pool of ";
106293 0 : std::cout << p_parent->class_name() << std::endl;
106294 : }
106295 : }
106296 : else
106297 : {
106298 0 : std::cout << "SgSIMDGather :: " << std::flush;
106299 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
106300 0 : std::cout << " not valid " << std::endl;
106301 : }
106302 : }
106303 :
106304 :
106305 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
106306 :
106307 0 : }
106308 :
106309 :
106310 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
106311 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
106312 : bool
106313 0 : SgSIMDGather::isInMemoryPool ()
106314 : {
106315 0 : typedef unsigned char* TestType;
106316 :
106317 0 : bool found = false;
106318 :
106319 0 : ROSE_ASSERT(this != NULL);
106320 :
106321 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
106322 :
106323 0 : TestType tested = (TestType) ( this ) ;
106324 :
106325 0 : std::vector < unsigned char* > :: const_iterator block = SgSIMDGather::pools.begin();
106326 :
106327 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
106328 : // while (found == false && block < Memory_Block_List.end())
106329 0 : while ( (found == false) && (block != SgSIMDGather::pools.end()) )
106330 : {
106331 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSIMDGather::pool_size * sizeof(SgSIMDGather) ) ) ;
106332 0 : ++block;
106333 : }
106334 :
106335 : // Special handling for static data
106336 :
106337 :
106338 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
106339 0 : ROSE_ASSERT(found == true);
106340 :
106341 0 : return found;
106342 : }
106343 : /* #line 106344 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
106344 :
106345 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
106346 :
106347 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
106348 :
106349 : /* #line 106350 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
106350 :
106351 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
106352 :
106353 : void
106354 0 : SgSIMDExplicitGather::checkDataMemberPointersIfInMemoryPool()
106355 : {
106356 : // ------------ checking pointers of SgSIMDExplicitGather -------------------
106357 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
106358 :
106359 0 : if ( p_lhs_operand_i != NULL )
106360 : {
106361 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106362 : {
106363 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
106364 : {
106365 0 : std::cout << "SgSIMDExplicitGather :: ";
106366 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
106367 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
106368 : }
106369 : }
106370 : else
106371 : {
106372 0 : std::cout << "SgSIMDExplicitGather :: " << std::flush;
106373 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
106374 0 : std::cout << " not valid " << std::endl;
106375 : }
106376 : }
106377 :
106378 0 : if ( p_rhs_operand_i != NULL )
106379 : {
106380 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106381 : {
106382 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
106383 : {
106384 0 : std::cout << "SgSIMDExplicitGather :: ";
106385 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
106386 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
106387 : }
106388 : }
106389 : else
106390 : {
106391 0 : std::cout << "SgSIMDExplicitGather :: " << std::flush;
106392 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
106393 0 : std::cout << " not valid " << std::endl;
106394 : }
106395 : }
106396 :
106397 0 : if ( p_expression_type != NULL )
106398 : {
106399 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106400 : {
106401 0 : if ( p_expression_type->isInMemoryPool() == false )
106402 : {
106403 0 : std::cout << "SgSIMDExplicitGather :: ";
106404 0 : std::cout << " p_expression_type is not in memory pool of ";
106405 0 : std::cout << p_expression_type->class_name() << std::endl;
106406 : }
106407 : }
106408 : else
106409 : {
106410 0 : std::cout << "SgSIMDExplicitGather :: " << std::flush;
106411 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
106412 0 : std::cout << " not valid " << std::endl;
106413 : }
106414 : }
106415 :
106416 0 : if ( p_originalExpressionTree != NULL )
106417 : {
106418 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106419 : {
106420 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
106421 : {
106422 0 : std::cout << "SgSIMDExplicitGather :: ";
106423 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
106424 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
106425 : }
106426 : }
106427 : else
106428 : {
106429 0 : std::cout << "SgSIMDExplicitGather :: " << std::flush;
106430 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
106431 0 : std::cout << " not valid " << std::endl;
106432 : }
106433 : }
106434 :
106435 0 : if ( p_operatorPosition != NULL )
106436 : {
106437 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106438 : {
106439 0 : if ( p_operatorPosition->isInMemoryPool() == false )
106440 : {
106441 0 : std::cout << "SgSIMDExplicitGather :: ";
106442 0 : std::cout << " p_operatorPosition is not in memory pool of ";
106443 0 : std::cout << p_operatorPosition->class_name() << std::endl;
106444 : }
106445 : }
106446 : else
106447 : {
106448 0 : std::cout << "SgSIMDExplicitGather :: " << std::flush;
106449 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
106450 0 : std::cout << " not valid " << std::endl;
106451 : }
106452 : }
106453 :
106454 0 : if ( p_startOfConstruct != NULL )
106455 : {
106456 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106457 : {
106458 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
106459 : {
106460 0 : std::cout << "SgSIMDExplicitGather :: ";
106461 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
106462 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
106463 : }
106464 : }
106465 : else
106466 : {
106467 0 : std::cout << "SgSIMDExplicitGather :: " << std::flush;
106468 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
106469 0 : std::cout << " not valid " << std::endl;
106470 : }
106471 : }
106472 :
106473 0 : if ( p_endOfConstruct != NULL )
106474 : {
106475 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106476 : {
106477 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
106478 : {
106479 0 : std::cout << "SgSIMDExplicitGather :: ";
106480 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
106481 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
106482 : }
106483 : }
106484 : else
106485 : {
106486 0 : std::cout << "SgSIMDExplicitGather :: " << std::flush;
106487 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
106488 0 : std::cout << " not valid " << std::endl;
106489 : }
106490 : }
106491 :
106492 0 : if ( p_parent != NULL )
106493 : {
106494 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106495 : {
106496 0 : if ( p_parent->isInMemoryPool() == false )
106497 : {
106498 0 : std::cout << "SgSIMDExplicitGather :: ";
106499 0 : std::cout << " p_parent is not in memory pool of ";
106500 0 : std::cout << p_parent->class_name() << std::endl;
106501 : }
106502 : }
106503 : else
106504 : {
106505 0 : std::cout << "SgSIMDExplicitGather :: " << std::flush;
106506 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
106507 0 : std::cout << " not valid " << std::endl;
106508 : }
106509 : }
106510 :
106511 :
106512 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
106513 :
106514 0 : }
106515 :
106516 :
106517 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
106518 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
106519 : bool
106520 0 : SgSIMDExplicitGather::isInMemoryPool ()
106521 : {
106522 0 : typedef unsigned char* TestType;
106523 :
106524 0 : bool found = false;
106525 :
106526 0 : ROSE_ASSERT(this != NULL);
106527 :
106528 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
106529 :
106530 0 : TestType tested = (TestType) ( this ) ;
106531 :
106532 0 : std::vector < unsigned char* > :: const_iterator block = SgSIMDExplicitGather::pools.begin();
106533 :
106534 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
106535 : // while (found == false && block < Memory_Block_List.end())
106536 0 : while ( (found == false) && (block != SgSIMDExplicitGather::pools.end()) )
106537 : {
106538 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSIMDExplicitGather::pool_size * sizeof(SgSIMDExplicitGather) ) ) ;
106539 0 : ++block;
106540 : }
106541 :
106542 : // Special handling for static data
106543 :
106544 :
106545 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
106546 0 : ROSE_ASSERT(found == true);
106547 :
106548 0 : return found;
106549 : }
106550 : /* #line 106551 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
106551 :
106552 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
106553 :
106554 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
106555 :
106556 : /* #line 106557 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
106557 :
106558 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
106559 :
106560 : void
106561 0 : SgSIMDScatter::checkDataMemberPointersIfInMemoryPool()
106562 : {
106563 : // ------------ checking pointers of SgSIMDScatter -------------------
106564 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
106565 :
106566 0 : if ( p_lhs_operand_i != NULL )
106567 : {
106568 0 : if ( p_lhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106569 : {
106570 0 : if ( p_lhs_operand_i->isInMemoryPool() == false )
106571 : {
106572 0 : std::cout << "SgSIMDScatter :: ";
106573 0 : std::cout << " p_lhs_operand_i is not in memory pool of ";
106574 0 : std::cout << p_lhs_operand_i->class_name() << std::endl;
106575 : }
106576 : }
106577 : else
106578 : {
106579 0 : std::cout << "SgSIMDScatter :: " << std::flush;
106580 0 : std::cout << "SgExpression* p_lhs_operand_i = " << p_lhs_operand_i << " --> " << std::flush;
106581 0 : std::cout << " not valid " << std::endl;
106582 : }
106583 : }
106584 :
106585 0 : if ( p_rhs_operand_i != NULL )
106586 : {
106587 0 : if ( p_rhs_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106588 : {
106589 0 : if ( p_rhs_operand_i->isInMemoryPool() == false )
106590 : {
106591 0 : std::cout << "SgSIMDScatter :: ";
106592 0 : std::cout << " p_rhs_operand_i is not in memory pool of ";
106593 0 : std::cout << p_rhs_operand_i->class_name() << std::endl;
106594 : }
106595 : }
106596 : else
106597 : {
106598 0 : std::cout << "SgSIMDScatter :: " << std::flush;
106599 0 : std::cout << "SgExpression* p_rhs_operand_i = " << p_rhs_operand_i << " --> " << std::flush;
106600 0 : std::cout << " not valid " << std::endl;
106601 : }
106602 : }
106603 :
106604 0 : if ( p_expression_type != NULL )
106605 : {
106606 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106607 : {
106608 0 : if ( p_expression_type->isInMemoryPool() == false )
106609 : {
106610 0 : std::cout << "SgSIMDScatter :: ";
106611 0 : std::cout << " p_expression_type is not in memory pool of ";
106612 0 : std::cout << p_expression_type->class_name() << std::endl;
106613 : }
106614 : }
106615 : else
106616 : {
106617 0 : std::cout << "SgSIMDScatter :: " << std::flush;
106618 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
106619 0 : std::cout << " not valid " << std::endl;
106620 : }
106621 : }
106622 :
106623 0 : if ( p_originalExpressionTree != NULL )
106624 : {
106625 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106626 : {
106627 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
106628 : {
106629 0 : std::cout << "SgSIMDScatter :: ";
106630 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
106631 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
106632 : }
106633 : }
106634 : else
106635 : {
106636 0 : std::cout << "SgSIMDScatter :: " << std::flush;
106637 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
106638 0 : std::cout << " not valid " << std::endl;
106639 : }
106640 : }
106641 :
106642 0 : if ( p_operatorPosition != NULL )
106643 : {
106644 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106645 : {
106646 0 : if ( p_operatorPosition->isInMemoryPool() == false )
106647 : {
106648 0 : std::cout << "SgSIMDScatter :: ";
106649 0 : std::cout << " p_operatorPosition is not in memory pool of ";
106650 0 : std::cout << p_operatorPosition->class_name() << std::endl;
106651 : }
106652 : }
106653 : else
106654 : {
106655 0 : std::cout << "SgSIMDScatter :: " << std::flush;
106656 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
106657 0 : std::cout << " not valid " << std::endl;
106658 : }
106659 : }
106660 :
106661 0 : if ( p_startOfConstruct != NULL )
106662 : {
106663 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106664 : {
106665 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
106666 : {
106667 0 : std::cout << "SgSIMDScatter :: ";
106668 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
106669 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
106670 : }
106671 : }
106672 : else
106673 : {
106674 0 : std::cout << "SgSIMDScatter :: " << std::flush;
106675 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
106676 0 : std::cout << " not valid " << std::endl;
106677 : }
106678 : }
106679 :
106680 0 : if ( p_endOfConstruct != NULL )
106681 : {
106682 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106683 : {
106684 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
106685 : {
106686 0 : std::cout << "SgSIMDScatter :: ";
106687 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
106688 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
106689 : }
106690 : }
106691 : else
106692 : {
106693 0 : std::cout << "SgSIMDScatter :: " << std::flush;
106694 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
106695 0 : std::cout << " not valid " << std::endl;
106696 : }
106697 : }
106698 :
106699 0 : if ( p_parent != NULL )
106700 : {
106701 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106702 : {
106703 0 : if ( p_parent->isInMemoryPool() == false )
106704 : {
106705 0 : std::cout << "SgSIMDScatter :: ";
106706 0 : std::cout << " p_parent is not in memory pool of ";
106707 0 : std::cout << p_parent->class_name() << std::endl;
106708 : }
106709 : }
106710 : else
106711 : {
106712 0 : std::cout << "SgSIMDScatter :: " << std::flush;
106713 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
106714 0 : std::cout << " not valid " << std::endl;
106715 : }
106716 : }
106717 :
106718 :
106719 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
106720 :
106721 0 : }
106722 :
106723 :
106724 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
106725 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
106726 : bool
106727 0 : SgSIMDScatter::isInMemoryPool ()
106728 : {
106729 0 : typedef unsigned char* TestType;
106730 :
106731 0 : bool found = false;
106732 :
106733 0 : ROSE_ASSERT(this != NULL);
106734 :
106735 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
106736 :
106737 0 : TestType tested = (TestType) ( this ) ;
106738 :
106739 0 : std::vector < unsigned char* > :: const_iterator block = SgSIMDScatter::pools.begin();
106740 :
106741 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
106742 : // while (found == false && block < Memory_Block_List.end())
106743 0 : while ( (found == false) && (block != SgSIMDScatter::pools.end()) )
106744 : {
106745 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSIMDScatter::pool_size * sizeof(SgSIMDScatter) ) ) ;
106746 0 : ++block;
106747 : }
106748 :
106749 : // Special handling for static data
106750 :
106751 :
106752 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
106753 0 : ROSE_ASSERT(found == true);
106754 :
106755 0 : return found;
106756 : }
106757 : /* #line 106758 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
106758 :
106759 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
106760 :
106761 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
106762 :
106763 : /* #line 106764 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
106764 :
106765 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
106766 :
106767 : void
106768 0 : SgExprListExp::checkDataMemberPointersIfInMemoryPool()
106769 : {
106770 : // ------------ checking pointers of SgExprListExp -------------------
106771 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
106772 :
106773 0 : SgExpressionPtrList::iterator i_expressions = p_expressions.begin() ;
106774 0 : for ( ; i_expressions != p_expressions.end(); ++i_expressions )
106775 : {
106776 0 : if ( (*i_expressions) != NULL )
106777 : {
106778 0 : if ( (*i_expressions)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106779 : {
106780 0 : if ( (*i_expressions)->isInMemoryPool() == false )
106781 : {
106782 0 : std::cout << "SgExprListExp :: ";
106783 0 : std::cout << " p_expressions ( list of poitners to IR nodes ), entry is not in memory pool of ";
106784 0 : std::cout << (*i_expressions)->class_name() << std::endl;
106785 : }
106786 : }
106787 : else
106788 : {
106789 0 : std::cout << "SgExprListExp :: " << std::flush;
106790 0 : std::cout << "SgExpressionPtrList p_expressions --> " << std::flush;
106791 0 : std::cout << " entry not valid " << std::endl;
106792 : }
106793 : }
106794 : else
106795 : {
106796 0 : std::cout << "SgExpressionPtrList p_expressions --> NULL " << std::endl;
106797 : }
106798 : }
106799 :
106800 0 : if ( p_operatorPosition != NULL )
106801 : {
106802 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106803 : {
106804 0 : if ( p_operatorPosition->isInMemoryPool() == false )
106805 : {
106806 0 : std::cout << "SgExprListExp :: ";
106807 0 : std::cout << " p_operatorPosition is not in memory pool of ";
106808 0 : std::cout << p_operatorPosition->class_name() << std::endl;
106809 : }
106810 : }
106811 : else
106812 : {
106813 0 : std::cout << "SgExprListExp :: " << std::flush;
106814 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
106815 0 : std::cout << " not valid " << std::endl;
106816 : }
106817 : }
106818 :
106819 0 : if ( p_startOfConstruct != NULL )
106820 : {
106821 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106822 : {
106823 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
106824 : {
106825 0 : std::cout << "SgExprListExp :: ";
106826 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
106827 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
106828 : }
106829 : }
106830 : else
106831 : {
106832 0 : std::cout << "SgExprListExp :: " << std::flush;
106833 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
106834 0 : std::cout << " not valid " << std::endl;
106835 : }
106836 : }
106837 :
106838 0 : if ( p_endOfConstruct != NULL )
106839 : {
106840 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106841 : {
106842 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
106843 : {
106844 0 : std::cout << "SgExprListExp :: ";
106845 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
106846 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
106847 : }
106848 : }
106849 : else
106850 : {
106851 0 : std::cout << "SgExprListExp :: " << std::flush;
106852 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
106853 0 : std::cout << " not valid " << std::endl;
106854 : }
106855 : }
106856 :
106857 0 : if ( p_parent != NULL )
106858 : {
106859 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106860 : {
106861 0 : if ( p_parent->isInMemoryPool() == false )
106862 : {
106863 0 : std::cout << "SgExprListExp :: ";
106864 0 : std::cout << " p_parent is not in memory pool of ";
106865 0 : std::cout << p_parent->class_name() << std::endl;
106866 : }
106867 : }
106868 : else
106869 : {
106870 0 : std::cout << "SgExprListExp :: " << std::flush;
106871 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
106872 0 : std::cout << " not valid " << std::endl;
106873 : }
106874 : }
106875 :
106876 :
106877 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
106878 :
106879 0 : }
106880 :
106881 :
106882 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
106883 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
106884 : bool
106885 0 : SgExprListExp::isInMemoryPool ()
106886 : {
106887 0 : typedef unsigned char* TestType;
106888 :
106889 0 : bool found = false;
106890 :
106891 0 : ROSE_ASSERT(this != NULL);
106892 :
106893 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
106894 :
106895 0 : TestType tested = (TestType) ( this ) ;
106896 :
106897 0 : std::vector < unsigned char* > :: const_iterator block = SgExprListExp::pools.begin();
106898 :
106899 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
106900 : // while (found == false && block < Memory_Block_List.end())
106901 0 : while ( (found == false) && (block != SgExprListExp::pools.end()) )
106902 : {
106903 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgExprListExp::pool_size * sizeof(SgExprListExp) ) ) ;
106904 0 : ++block;
106905 : }
106906 :
106907 : // Special handling for static data
106908 :
106909 :
106910 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
106911 0 : ROSE_ASSERT(found == true);
106912 :
106913 0 : return found;
106914 : }
106915 : /* #line 106916 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
106916 :
106917 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
106918 :
106919 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
106920 :
106921 : /* #line 106922 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
106922 :
106923 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
106924 :
106925 : void
106926 0 : SgListExp::checkDataMemberPointersIfInMemoryPool()
106927 : {
106928 : // ------------ checking pointers of SgListExp -------------------
106929 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
106930 :
106931 0 : SgExpressionPtrList::iterator i_expressions = p_expressions.begin() ;
106932 0 : for ( ; i_expressions != p_expressions.end(); ++i_expressions )
106933 : {
106934 0 : if ( (*i_expressions) != NULL )
106935 : {
106936 0 : if ( (*i_expressions)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106937 : {
106938 0 : if ( (*i_expressions)->isInMemoryPool() == false )
106939 : {
106940 0 : std::cout << "SgListExp :: ";
106941 0 : std::cout << " p_expressions ( list of poitners to IR nodes ), entry is not in memory pool of ";
106942 0 : std::cout << (*i_expressions)->class_name() << std::endl;
106943 : }
106944 : }
106945 : else
106946 : {
106947 0 : std::cout << "SgListExp :: " << std::flush;
106948 0 : std::cout << "SgExpressionPtrList p_expressions --> " << std::flush;
106949 0 : std::cout << " entry not valid " << std::endl;
106950 : }
106951 : }
106952 : else
106953 : {
106954 0 : std::cout << "SgExpressionPtrList p_expressions --> NULL " << std::endl;
106955 : }
106956 : }
106957 :
106958 0 : if ( p_operatorPosition != NULL )
106959 : {
106960 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106961 : {
106962 0 : if ( p_operatorPosition->isInMemoryPool() == false )
106963 : {
106964 0 : std::cout << "SgListExp :: ";
106965 0 : std::cout << " p_operatorPosition is not in memory pool of ";
106966 0 : std::cout << p_operatorPosition->class_name() << std::endl;
106967 : }
106968 : }
106969 : else
106970 : {
106971 0 : std::cout << "SgListExp :: " << std::flush;
106972 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
106973 0 : std::cout << " not valid " << std::endl;
106974 : }
106975 : }
106976 :
106977 0 : if ( p_startOfConstruct != NULL )
106978 : {
106979 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106980 : {
106981 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
106982 : {
106983 0 : std::cout << "SgListExp :: ";
106984 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
106985 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
106986 : }
106987 : }
106988 : else
106989 : {
106990 0 : std::cout << "SgListExp :: " << std::flush;
106991 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
106992 0 : std::cout << " not valid " << std::endl;
106993 : }
106994 : }
106995 :
106996 0 : if ( p_endOfConstruct != NULL )
106997 : {
106998 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
106999 : {
107000 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
107001 : {
107002 0 : std::cout << "SgListExp :: ";
107003 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
107004 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
107005 : }
107006 : }
107007 : else
107008 : {
107009 0 : std::cout << "SgListExp :: " << std::flush;
107010 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
107011 0 : std::cout << " not valid " << std::endl;
107012 : }
107013 : }
107014 :
107015 0 : if ( p_parent != NULL )
107016 : {
107017 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107018 : {
107019 0 : if ( p_parent->isInMemoryPool() == false )
107020 : {
107021 0 : std::cout << "SgListExp :: ";
107022 0 : std::cout << " p_parent is not in memory pool of ";
107023 0 : std::cout << p_parent->class_name() << std::endl;
107024 : }
107025 : }
107026 : else
107027 : {
107028 0 : std::cout << "SgListExp :: " << std::flush;
107029 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
107030 0 : std::cout << " not valid " << std::endl;
107031 : }
107032 : }
107033 :
107034 :
107035 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107036 :
107037 0 : }
107038 :
107039 :
107040 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
107041 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
107042 : bool
107043 0 : SgListExp::isInMemoryPool ()
107044 : {
107045 0 : typedef unsigned char* TestType;
107046 :
107047 0 : bool found = false;
107048 :
107049 0 : ROSE_ASSERT(this != NULL);
107050 :
107051 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
107052 :
107053 0 : TestType tested = (TestType) ( this ) ;
107054 :
107055 0 : std::vector < unsigned char* > :: const_iterator block = SgListExp::pools.begin();
107056 :
107057 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
107058 : // while (found == false && block < Memory_Block_List.end())
107059 0 : while ( (found == false) && (block != SgListExp::pools.end()) )
107060 : {
107061 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgListExp::pool_size * sizeof(SgListExp) ) ) ;
107062 0 : ++block;
107063 : }
107064 :
107065 : // Special handling for static data
107066 :
107067 :
107068 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
107069 0 : ROSE_ASSERT(found == true);
107070 :
107071 0 : return found;
107072 : }
107073 : /* #line 107074 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
107074 :
107075 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
107076 :
107077 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107078 :
107079 : /* #line 107080 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
107080 :
107081 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107082 :
107083 : void
107084 0 : SgTupleExp::checkDataMemberPointersIfInMemoryPool()
107085 : {
107086 : // ------------ checking pointers of SgTupleExp -------------------
107087 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
107088 :
107089 0 : SgExpressionPtrList::iterator i_expressions = p_expressions.begin() ;
107090 0 : for ( ; i_expressions != p_expressions.end(); ++i_expressions )
107091 : {
107092 0 : if ( (*i_expressions) != NULL )
107093 : {
107094 0 : if ( (*i_expressions)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107095 : {
107096 0 : if ( (*i_expressions)->isInMemoryPool() == false )
107097 : {
107098 0 : std::cout << "SgTupleExp :: ";
107099 0 : std::cout << " p_expressions ( list of poitners to IR nodes ), entry is not in memory pool of ";
107100 0 : std::cout << (*i_expressions)->class_name() << std::endl;
107101 : }
107102 : }
107103 : else
107104 : {
107105 0 : std::cout << "SgTupleExp :: " << std::flush;
107106 0 : std::cout << "SgExpressionPtrList p_expressions --> " << std::flush;
107107 0 : std::cout << " entry not valid " << std::endl;
107108 : }
107109 : }
107110 : else
107111 : {
107112 0 : std::cout << "SgExpressionPtrList p_expressions --> NULL " << std::endl;
107113 : }
107114 : }
107115 :
107116 0 : if ( p_operatorPosition != NULL )
107117 : {
107118 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107119 : {
107120 0 : if ( p_operatorPosition->isInMemoryPool() == false )
107121 : {
107122 0 : std::cout << "SgTupleExp :: ";
107123 0 : std::cout << " p_operatorPosition is not in memory pool of ";
107124 0 : std::cout << p_operatorPosition->class_name() << std::endl;
107125 : }
107126 : }
107127 : else
107128 : {
107129 0 : std::cout << "SgTupleExp :: " << std::flush;
107130 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
107131 0 : std::cout << " not valid " << std::endl;
107132 : }
107133 : }
107134 :
107135 0 : if ( p_startOfConstruct != NULL )
107136 : {
107137 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107138 : {
107139 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
107140 : {
107141 0 : std::cout << "SgTupleExp :: ";
107142 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
107143 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
107144 : }
107145 : }
107146 : else
107147 : {
107148 0 : std::cout << "SgTupleExp :: " << std::flush;
107149 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
107150 0 : std::cout << " not valid " << std::endl;
107151 : }
107152 : }
107153 :
107154 0 : if ( p_endOfConstruct != NULL )
107155 : {
107156 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107157 : {
107158 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
107159 : {
107160 0 : std::cout << "SgTupleExp :: ";
107161 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
107162 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
107163 : }
107164 : }
107165 : else
107166 : {
107167 0 : std::cout << "SgTupleExp :: " << std::flush;
107168 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
107169 0 : std::cout << " not valid " << std::endl;
107170 : }
107171 : }
107172 :
107173 0 : if ( p_parent != NULL )
107174 : {
107175 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107176 : {
107177 0 : if ( p_parent->isInMemoryPool() == false )
107178 : {
107179 0 : std::cout << "SgTupleExp :: ";
107180 0 : std::cout << " p_parent is not in memory pool of ";
107181 0 : std::cout << p_parent->class_name() << std::endl;
107182 : }
107183 : }
107184 : else
107185 : {
107186 0 : std::cout << "SgTupleExp :: " << std::flush;
107187 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
107188 0 : std::cout << " not valid " << std::endl;
107189 : }
107190 : }
107191 :
107192 :
107193 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107194 :
107195 0 : }
107196 :
107197 :
107198 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
107199 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
107200 : bool
107201 0 : SgTupleExp::isInMemoryPool ()
107202 : {
107203 0 : typedef unsigned char* TestType;
107204 :
107205 0 : bool found = false;
107206 :
107207 0 : ROSE_ASSERT(this != NULL);
107208 :
107209 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
107210 :
107211 0 : TestType tested = (TestType) ( this ) ;
107212 :
107213 0 : std::vector < unsigned char* > :: const_iterator block = SgTupleExp::pools.begin();
107214 :
107215 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
107216 : // while (found == false && block < Memory_Block_List.end())
107217 0 : while ( (found == false) && (block != SgTupleExp::pools.end()) )
107218 : {
107219 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTupleExp::pool_size * sizeof(SgTupleExp) ) ) ;
107220 0 : ++block;
107221 : }
107222 :
107223 : // Special handling for static data
107224 :
107225 :
107226 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
107227 0 : ROSE_ASSERT(found == true);
107228 :
107229 0 : return found;
107230 : }
107231 : /* #line 107232 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
107232 :
107233 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
107234 :
107235 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107236 :
107237 : /* #line 107238 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
107238 :
107239 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107240 :
107241 : void
107242 0 : SgMatrixExp::checkDataMemberPointersIfInMemoryPool()
107243 : {
107244 : // ------------ checking pointers of SgMatrixExp -------------------
107245 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
107246 :
107247 0 : SgExpressionPtrList::iterator i_expressions = p_expressions.begin() ;
107248 0 : for ( ; i_expressions != p_expressions.end(); ++i_expressions )
107249 : {
107250 0 : if ( (*i_expressions) != NULL )
107251 : {
107252 0 : if ( (*i_expressions)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107253 : {
107254 0 : if ( (*i_expressions)->isInMemoryPool() == false )
107255 : {
107256 0 : std::cout << "SgMatrixExp :: ";
107257 0 : std::cout << " p_expressions ( list of poitners to IR nodes ), entry is not in memory pool of ";
107258 0 : std::cout << (*i_expressions)->class_name() << std::endl;
107259 : }
107260 : }
107261 : else
107262 : {
107263 0 : std::cout << "SgMatrixExp :: " << std::flush;
107264 0 : std::cout << "SgExpressionPtrList p_expressions --> " << std::flush;
107265 0 : std::cout << " entry not valid " << std::endl;
107266 : }
107267 : }
107268 : else
107269 : {
107270 0 : std::cout << "SgExpressionPtrList p_expressions --> NULL " << std::endl;
107271 : }
107272 : }
107273 :
107274 0 : if ( p_operatorPosition != NULL )
107275 : {
107276 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107277 : {
107278 0 : if ( p_operatorPosition->isInMemoryPool() == false )
107279 : {
107280 0 : std::cout << "SgMatrixExp :: ";
107281 0 : std::cout << " p_operatorPosition is not in memory pool of ";
107282 0 : std::cout << p_operatorPosition->class_name() << std::endl;
107283 : }
107284 : }
107285 : else
107286 : {
107287 0 : std::cout << "SgMatrixExp :: " << std::flush;
107288 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
107289 0 : std::cout << " not valid " << std::endl;
107290 : }
107291 : }
107292 :
107293 0 : if ( p_startOfConstruct != NULL )
107294 : {
107295 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107296 : {
107297 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
107298 : {
107299 0 : std::cout << "SgMatrixExp :: ";
107300 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
107301 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
107302 : }
107303 : }
107304 : else
107305 : {
107306 0 : std::cout << "SgMatrixExp :: " << std::flush;
107307 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
107308 0 : std::cout << " not valid " << std::endl;
107309 : }
107310 : }
107311 :
107312 0 : if ( p_endOfConstruct != NULL )
107313 : {
107314 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107315 : {
107316 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
107317 : {
107318 0 : std::cout << "SgMatrixExp :: ";
107319 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
107320 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
107321 : }
107322 : }
107323 : else
107324 : {
107325 0 : std::cout << "SgMatrixExp :: " << std::flush;
107326 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
107327 0 : std::cout << " not valid " << std::endl;
107328 : }
107329 : }
107330 :
107331 0 : if ( p_parent != NULL )
107332 : {
107333 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107334 : {
107335 0 : if ( p_parent->isInMemoryPool() == false )
107336 : {
107337 0 : std::cout << "SgMatrixExp :: ";
107338 0 : std::cout << " p_parent is not in memory pool of ";
107339 0 : std::cout << p_parent->class_name() << std::endl;
107340 : }
107341 : }
107342 : else
107343 : {
107344 0 : std::cout << "SgMatrixExp :: " << std::flush;
107345 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
107346 0 : std::cout << " not valid " << std::endl;
107347 : }
107348 : }
107349 :
107350 :
107351 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107352 :
107353 0 : }
107354 :
107355 :
107356 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
107357 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
107358 : bool
107359 0 : SgMatrixExp::isInMemoryPool ()
107360 : {
107361 0 : typedef unsigned char* TestType;
107362 :
107363 0 : bool found = false;
107364 :
107365 0 : ROSE_ASSERT(this != NULL);
107366 :
107367 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
107368 :
107369 0 : TestType tested = (TestType) ( this ) ;
107370 :
107371 0 : std::vector < unsigned char* > :: const_iterator block = SgMatrixExp::pools.begin();
107372 :
107373 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
107374 : // while (found == false && block < Memory_Block_List.end())
107375 0 : while ( (found == false) && (block != SgMatrixExp::pools.end()) )
107376 : {
107377 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgMatrixExp::pool_size * sizeof(SgMatrixExp) ) ) ;
107378 0 : ++block;
107379 : }
107380 :
107381 : // Special handling for static data
107382 :
107383 :
107384 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
107385 0 : ROSE_ASSERT(found == true);
107386 :
107387 0 : return found;
107388 : }
107389 : /* #line 107390 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
107390 :
107391 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
107392 :
107393 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107394 :
107395 : /* #line 107396 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
107396 :
107397 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107398 :
107399 : void
107400 0 : SgVarRefExp::checkDataMemberPointersIfInMemoryPool()
107401 : {
107402 : // ------------ checking pointers of SgVarRefExp -------------------
107403 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
107404 :
107405 0 : if ( p_symbol != NULL )
107406 : {
107407 0 : if ( p_symbol->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107408 : {
107409 0 : if ( p_symbol->isInMemoryPool() == false )
107410 : {
107411 0 : std::cout << "SgVarRefExp :: ";
107412 0 : std::cout << " p_symbol is not in memory pool of ";
107413 0 : std::cout << p_symbol->class_name() << std::endl;
107414 : }
107415 : }
107416 : else
107417 : {
107418 0 : std::cout << "SgVarRefExp :: " << std::flush;
107419 0 : std::cout << "SgVariableSymbol* p_symbol = " << p_symbol << " --> " << std::flush;
107420 0 : std::cout << " not valid " << std::endl;
107421 : }
107422 : }
107423 :
107424 0 : if ( p_originalExpressionTree != NULL )
107425 : {
107426 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107427 : {
107428 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
107429 : {
107430 0 : std::cout << "SgVarRefExp :: ";
107431 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
107432 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
107433 : }
107434 : }
107435 : else
107436 : {
107437 0 : std::cout << "SgVarRefExp :: " << std::flush;
107438 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
107439 0 : std::cout << " not valid " << std::endl;
107440 : }
107441 : }
107442 :
107443 0 : if ( p_operatorPosition != NULL )
107444 : {
107445 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107446 : {
107447 0 : if ( p_operatorPosition->isInMemoryPool() == false )
107448 : {
107449 0 : std::cout << "SgVarRefExp :: ";
107450 0 : std::cout << " p_operatorPosition is not in memory pool of ";
107451 0 : std::cout << p_operatorPosition->class_name() << std::endl;
107452 : }
107453 : }
107454 : else
107455 : {
107456 0 : std::cout << "SgVarRefExp :: " << std::flush;
107457 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
107458 0 : std::cout << " not valid " << std::endl;
107459 : }
107460 : }
107461 :
107462 0 : if ( p_startOfConstruct != NULL )
107463 : {
107464 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107465 : {
107466 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
107467 : {
107468 0 : std::cout << "SgVarRefExp :: ";
107469 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
107470 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
107471 : }
107472 : }
107473 : else
107474 : {
107475 0 : std::cout << "SgVarRefExp :: " << std::flush;
107476 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
107477 0 : std::cout << " not valid " << std::endl;
107478 : }
107479 : }
107480 :
107481 0 : if ( p_endOfConstruct != NULL )
107482 : {
107483 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107484 : {
107485 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
107486 : {
107487 0 : std::cout << "SgVarRefExp :: ";
107488 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
107489 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
107490 : }
107491 : }
107492 : else
107493 : {
107494 0 : std::cout << "SgVarRefExp :: " << std::flush;
107495 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
107496 0 : std::cout << " not valid " << std::endl;
107497 : }
107498 : }
107499 :
107500 0 : if ( p_parent != NULL )
107501 : {
107502 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107503 : {
107504 0 : if ( p_parent->isInMemoryPool() == false )
107505 : {
107506 0 : std::cout << "SgVarRefExp :: ";
107507 0 : std::cout << " p_parent is not in memory pool of ";
107508 0 : std::cout << p_parent->class_name() << std::endl;
107509 : }
107510 : }
107511 : else
107512 : {
107513 0 : std::cout << "SgVarRefExp :: " << std::flush;
107514 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
107515 0 : std::cout << " not valid " << std::endl;
107516 : }
107517 : }
107518 :
107519 :
107520 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107521 :
107522 0 : }
107523 :
107524 :
107525 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
107526 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
107527 : bool
107528 0 : SgVarRefExp::isInMemoryPool ()
107529 : {
107530 0 : typedef unsigned char* TestType;
107531 :
107532 0 : bool found = false;
107533 :
107534 0 : ROSE_ASSERT(this != NULL);
107535 :
107536 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
107537 :
107538 0 : TestType tested = (TestType) ( this ) ;
107539 :
107540 0 : std::vector < unsigned char* > :: const_iterator block = SgVarRefExp::pools.begin();
107541 :
107542 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
107543 : // while (found == false && block < Memory_Block_List.end())
107544 0 : while ( (found == false) && (block != SgVarRefExp::pools.end()) )
107545 : {
107546 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgVarRefExp::pool_size * sizeof(SgVarRefExp) ) ) ;
107547 0 : ++block;
107548 : }
107549 :
107550 : // Special handling for static data
107551 :
107552 :
107553 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
107554 0 : ROSE_ASSERT(found == true);
107555 :
107556 0 : return found;
107557 : }
107558 : /* #line 107559 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
107559 :
107560 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
107561 :
107562 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107563 :
107564 : /* #line 107565 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
107565 :
107566 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107567 :
107568 : void
107569 0 : SgClassNameRefExp::checkDataMemberPointersIfInMemoryPool()
107570 : {
107571 : // ------------ checking pointers of SgClassNameRefExp -------------------
107572 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
107573 :
107574 0 : if ( p_symbol != NULL )
107575 : {
107576 0 : if ( p_symbol->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107577 : {
107578 0 : if ( p_symbol->isInMemoryPool() == false )
107579 : {
107580 0 : std::cout << "SgClassNameRefExp :: ";
107581 0 : std::cout << " p_symbol is not in memory pool of ";
107582 0 : std::cout << p_symbol->class_name() << std::endl;
107583 : }
107584 : }
107585 : else
107586 : {
107587 0 : std::cout << "SgClassNameRefExp :: " << std::flush;
107588 0 : std::cout << "SgClassSymbol* p_symbol = " << p_symbol << " --> " << std::flush;
107589 0 : std::cout << " not valid " << std::endl;
107590 : }
107591 : }
107592 :
107593 0 : if ( p_operatorPosition != NULL )
107594 : {
107595 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107596 : {
107597 0 : if ( p_operatorPosition->isInMemoryPool() == false )
107598 : {
107599 0 : std::cout << "SgClassNameRefExp :: ";
107600 0 : std::cout << " p_operatorPosition is not in memory pool of ";
107601 0 : std::cout << p_operatorPosition->class_name() << std::endl;
107602 : }
107603 : }
107604 : else
107605 : {
107606 0 : std::cout << "SgClassNameRefExp :: " << std::flush;
107607 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
107608 0 : std::cout << " not valid " << std::endl;
107609 : }
107610 : }
107611 :
107612 0 : if ( p_startOfConstruct != NULL )
107613 : {
107614 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107615 : {
107616 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
107617 : {
107618 0 : std::cout << "SgClassNameRefExp :: ";
107619 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
107620 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
107621 : }
107622 : }
107623 : else
107624 : {
107625 0 : std::cout << "SgClassNameRefExp :: " << std::flush;
107626 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
107627 0 : std::cout << " not valid " << std::endl;
107628 : }
107629 : }
107630 :
107631 0 : if ( p_endOfConstruct != NULL )
107632 : {
107633 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107634 : {
107635 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
107636 : {
107637 0 : std::cout << "SgClassNameRefExp :: ";
107638 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
107639 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
107640 : }
107641 : }
107642 : else
107643 : {
107644 0 : std::cout << "SgClassNameRefExp :: " << std::flush;
107645 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
107646 0 : std::cout << " not valid " << std::endl;
107647 : }
107648 : }
107649 :
107650 0 : if ( p_parent != NULL )
107651 : {
107652 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107653 : {
107654 0 : if ( p_parent->isInMemoryPool() == false )
107655 : {
107656 0 : std::cout << "SgClassNameRefExp :: ";
107657 0 : std::cout << " p_parent is not in memory pool of ";
107658 0 : std::cout << p_parent->class_name() << std::endl;
107659 : }
107660 : }
107661 : else
107662 : {
107663 0 : std::cout << "SgClassNameRefExp :: " << std::flush;
107664 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
107665 0 : std::cout << " not valid " << std::endl;
107666 : }
107667 : }
107668 :
107669 :
107670 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107671 :
107672 0 : }
107673 :
107674 :
107675 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
107676 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
107677 : bool
107678 0 : SgClassNameRefExp::isInMemoryPool ()
107679 : {
107680 0 : typedef unsigned char* TestType;
107681 :
107682 0 : bool found = false;
107683 :
107684 0 : ROSE_ASSERT(this != NULL);
107685 :
107686 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
107687 :
107688 0 : TestType tested = (TestType) ( this ) ;
107689 :
107690 0 : std::vector < unsigned char* > :: const_iterator block = SgClassNameRefExp::pools.begin();
107691 :
107692 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
107693 : // while (found == false && block < Memory_Block_List.end())
107694 0 : while ( (found == false) && (block != SgClassNameRefExp::pools.end()) )
107695 : {
107696 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgClassNameRefExp::pool_size * sizeof(SgClassNameRefExp) ) ) ;
107697 0 : ++block;
107698 : }
107699 :
107700 : // Special handling for static data
107701 :
107702 :
107703 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
107704 0 : ROSE_ASSERT(found == true);
107705 :
107706 0 : return found;
107707 : }
107708 : /* #line 107709 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
107709 :
107710 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
107711 :
107712 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107713 :
107714 : /* #line 107715 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
107715 :
107716 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107717 :
107718 : void
107719 0 : SgFunctionRefExp::checkDataMemberPointersIfInMemoryPool()
107720 : {
107721 : // ------------ checking pointers of SgFunctionRefExp -------------------
107722 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
107723 :
107724 0 : if ( p_symbol_i != NULL )
107725 : {
107726 0 : if ( p_symbol_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107727 : {
107728 0 : if ( p_symbol_i->isInMemoryPool() == false )
107729 : {
107730 0 : std::cout << "SgFunctionRefExp :: ";
107731 0 : std::cout << " p_symbol_i is not in memory pool of ";
107732 0 : std::cout << p_symbol_i->class_name() << std::endl;
107733 : }
107734 : }
107735 : else
107736 : {
107737 0 : std::cout << "SgFunctionRefExp :: " << std::flush;
107738 0 : std::cout << "SgFunctionSymbol* p_symbol_i = " << p_symbol_i << " --> " << std::flush;
107739 0 : std::cout << " not valid " << std::endl;
107740 : }
107741 : }
107742 :
107743 0 : if ( p_function_type != NULL )
107744 : {
107745 0 : if ( p_function_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107746 : {
107747 0 : if ( p_function_type->isInMemoryPool() == false )
107748 : {
107749 0 : std::cout << "SgFunctionRefExp :: ";
107750 0 : std::cout << " p_function_type is not in memory pool of ";
107751 0 : std::cout << p_function_type->class_name() << std::endl;
107752 : }
107753 : }
107754 : else
107755 : {
107756 0 : std::cout << "SgFunctionRefExp :: " << std::flush;
107757 0 : std::cout << "SgFunctionType* p_function_type = " << p_function_type << " --> " << std::flush;
107758 0 : std::cout << " not valid " << std::endl;
107759 : }
107760 : }
107761 :
107762 0 : if ( p_originalExpressionTree != NULL )
107763 : {
107764 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107765 : {
107766 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
107767 : {
107768 0 : std::cout << "SgFunctionRefExp :: ";
107769 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
107770 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
107771 : }
107772 : }
107773 : else
107774 : {
107775 0 : std::cout << "SgFunctionRefExp :: " << std::flush;
107776 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
107777 0 : std::cout << " not valid " << std::endl;
107778 : }
107779 : }
107780 :
107781 0 : if ( p_operatorPosition != NULL )
107782 : {
107783 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107784 : {
107785 0 : if ( p_operatorPosition->isInMemoryPool() == false )
107786 : {
107787 0 : std::cout << "SgFunctionRefExp :: ";
107788 0 : std::cout << " p_operatorPosition is not in memory pool of ";
107789 0 : std::cout << p_operatorPosition->class_name() << std::endl;
107790 : }
107791 : }
107792 : else
107793 : {
107794 0 : std::cout << "SgFunctionRefExp :: " << std::flush;
107795 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
107796 0 : std::cout << " not valid " << std::endl;
107797 : }
107798 : }
107799 :
107800 0 : if ( p_startOfConstruct != NULL )
107801 : {
107802 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107803 : {
107804 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
107805 : {
107806 0 : std::cout << "SgFunctionRefExp :: ";
107807 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
107808 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
107809 : }
107810 : }
107811 : else
107812 : {
107813 0 : std::cout << "SgFunctionRefExp :: " << std::flush;
107814 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
107815 0 : std::cout << " not valid " << std::endl;
107816 : }
107817 : }
107818 :
107819 0 : if ( p_endOfConstruct != NULL )
107820 : {
107821 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107822 : {
107823 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
107824 : {
107825 0 : std::cout << "SgFunctionRefExp :: ";
107826 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
107827 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
107828 : }
107829 : }
107830 : else
107831 : {
107832 0 : std::cout << "SgFunctionRefExp :: " << std::flush;
107833 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
107834 0 : std::cout << " not valid " << std::endl;
107835 : }
107836 : }
107837 :
107838 0 : if ( p_parent != NULL )
107839 : {
107840 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107841 : {
107842 0 : if ( p_parent->isInMemoryPool() == false )
107843 : {
107844 0 : std::cout << "SgFunctionRefExp :: ";
107845 0 : std::cout << " p_parent is not in memory pool of ";
107846 0 : std::cout << p_parent->class_name() << std::endl;
107847 : }
107848 : }
107849 : else
107850 : {
107851 0 : std::cout << "SgFunctionRefExp :: " << std::flush;
107852 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
107853 0 : std::cout << " not valid " << std::endl;
107854 : }
107855 : }
107856 :
107857 :
107858 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107859 :
107860 0 : }
107861 :
107862 :
107863 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
107864 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
107865 : bool
107866 0 : SgFunctionRefExp::isInMemoryPool ()
107867 : {
107868 0 : typedef unsigned char* TestType;
107869 :
107870 0 : bool found = false;
107871 :
107872 0 : ROSE_ASSERT(this != NULL);
107873 :
107874 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
107875 :
107876 0 : TestType tested = (TestType) ( this ) ;
107877 :
107878 0 : std::vector < unsigned char* > :: const_iterator block = SgFunctionRefExp::pools.begin();
107879 :
107880 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
107881 : // while (found == false && block < Memory_Block_List.end())
107882 0 : while ( (found == false) && (block != SgFunctionRefExp::pools.end()) )
107883 : {
107884 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFunctionRefExp::pool_size * sizeof(SgFunctionRefExp) ) ) ;
107885 0 : ++block;
107886 : }
107887 :
107888 : // Special handling for static data
107889 :
107890 :
107891 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
107892 0 : ROSE_ASSERT(found == true);
107893 :
107894 0 : return found;
107895 : }
107896 : /* #line 107897 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
107897 :
107898 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
107899 :
107900 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107901 :
107902 : /* #line 107903 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
107903 :
107904 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
107905 :
107906 : void
107907 0 : SgMemberFunctionRefExp::checkDataMemberPointersIfInMemoryPool()
107908 : {
107909 : // ------------ checking pointers of SgMemberFunctionRefExp -------------------
107910 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
107911 :
107912 0 : if ( p_symbol_i != NULL )
107913 : {
107914 0 : if ( p_symbol_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107915 : {
107916 0 : if ( p_symbol_i->isInMemoryPool() == false )
107917 : {
107918 0 : std::cout << "SgMemberFunctionRefExp :: ";
107919 0 : std::cout << " p_symbol_i is not in memory pool of ";
107920 0 : std::cout << p_symbol_i->class_name() << std::endl;
107921 : }
107922 : }
107923 : else
107924 : {
107925 0 : std::cout << "SgMemberFunctionRefExp :: " << std::flush;
107926 0 : std::cout << "SgMemberFunctionSymbol* p_symbol_i = " << p_symbol_i << " --> " << std::flush;
107927 0 : std::cout << " not valid " << std::endl;
107928 : }
107929 : }
107930 :
107931 0 : if ( p_function_type != NULL )
107932 : {
107933 0 : if ( p_function_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107934 : {
107935 0 : if ( p_function_type->isInMemoryPool() == false )
107936 : {
107937 0 : std::cout << "SgMemberFunctionRefExp :: ";
107938 0 : std::cout << " p_function_type is not in memory pool of ";
107939 0 : std::cout << p_function_type->class_name() << std::endl;
107940 : }
107941 : }
107942 : else
107943 : {
107944 0 : std::cout << "SgMemberFunctionRefExp :: " << std::flush;
107945 0 : std::cout << "SgFunctionType* p_function_type = " << p_function_type << " --> " << std::flush;
107946 0 : std::cout << " not valid " << std::endl;
107947 : }
107948 : }
107949 :
107950 0 : if ( p_operatorPosition != NULL )
107951 : {
107952 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107953 : {
107954 0 : if ( p_operatorPosition->isInMemoryPool() == false )
107955 : {
107956 0 : std::cout << "SgMemberFunctionRefExp :: ";
107957 0 : std::cout << " p_operatorPosition is not in memory pool of ";
107958 0 : std::cout << p_operatorPosition->class_name() << std::endl;
107959 : }
107960 : }
107961 : else
107962 : {
107963 0 : std::cout << "SgMemberFunctionRefExp :: " << std::flush;
107964 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
107965 0 : std::cout << " not valid " << std::endl;
107966 : }
107967 : }
107968 :
107969 0 : if ( p_startOfConstruct != NULL )
107970 : {
107971 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107972 : {
107973 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
107974 : {
107975 0 : std::cout << "SgMemberFunctionRefExp :: ";
107976 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
107977 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
107978 : }
107979 : }
107980 : else
107981 : {
107982 0 : std::cout << "SgMemberFunctionRefExp :: " << std::flush;
107983 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
107984 0 : std::cout << " not valid " << std::endl;
107985 : }
107986 : }
107987 :
107988 0 : if ( p_endOfConstruct != NULL )
107989 : {
107990 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
107991 : {
107992 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
107993 : {
107994 0 : std::cout << "SgMemberFunctionRefExp :: ";
107995 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
107996 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
107997 : }
107998 : }
107999 : else
108000 : {
108001 0 : std::cout << "SgMemberFunctionRefExp :: " << std::flush;
108002 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
108003 0 : std::cout << " not valid " << std::endl;
108004 : }
108005 : }
108006 :
108007 0 : if ( p_parent != NULL )
108008 : {
108009 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108010 : {
108011 0 : if ( p_parent->isInMemoryPool() == false )
108012 : {
108013 0 : std::cout << "SgMemberFunctionRefExp :: ";
108014 0 : std::cout << " p_parent is not in memory pool of ";
108015 0 : std::cout << p_parent->class_name() << std::endl;
108016 : }
108017 : }
108018 : else
108019 : {
108020 0 : std::cout << "SgMemberFunctionRefExp :: " << std::flush;
108021 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
108022 0 : std::cout << " not valid " << std::endl;
108023 : }
108024 : }
108025 :
108026 :
108027 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108028 :
108029 0 : }
108030 :
108031 :
108032 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
108033 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
108034 : bool
108035 0 : SgMemberFunctionRefExp::isInMemoryPool ()
108036 : {
108037 0 : typedef unsigned char* TestType;
108038 :
108039 0 : bool found = false;
108040 :
108041 0 : ROSE_ASSERT(this != NULL);
108042 :
108043 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
108044 :
108045 0 : TestType tested = (TestType) ( this ) ;
108046 :
108047 0 : std::vector < unsigned char* > :: const_iterator block = SgMemberFunctionRefExp::pools.begin();
108048 :
108049 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
108050 : // while (found == false && block < Memory_Block_List.end())
108051 0 : while ( (found == false) && (block != SgMemberFunctionRefExp::pools.end()) )
108052 : {
108053 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgMemberFunctionRefExp::pool_size * sizeof(SgMemberFunctionRefExp) ) ) ;
108054 0 : ++block;
108055 : }
108056 :
108057 : // Special handling for static data
108058 :
108059 :
108060 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
108061 0 : ROSE_ASSERT(found == true);
108062 :
108063 0 : return found;
108064 : }
108065 : /* #line 108066 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
108066 :
108067 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
108068 :
108069 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108070 :
108071 : /* #line 108072 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
108072 :
108073 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108074 :
108075 : void
108076 0 : SgValueExp::checkDataMemberPointersIfInMemoryPool()
108077 : {
108078 : // ------------ checking pointers of SgValueExp -------------------
108079 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
108080 :
108081 0 : if ( p_originalExpressionTree != NULL )
108082 : {
108083 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108084 : {
108085 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
108086 : {
108087 0 : std::cout << "SgValueExp :: ";
108088 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
108089 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
108090 : }
108091 : }
108092 : else
108093 : {
108094 0 : std::cout << "SgValueExp :: " << std::flush;
108095 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
108096 0 : std::cout << " not valid " << std::endl;
108097 : }
108098 : }
108099 :
108100 0 : if ( p_operatorPosition != NULL )
108101 : {
108102 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108103 : {
108104 0 : if ( p_operatorPosition->isInMemoryPool() == false )
108105 : {
108106 0 : std::cout << "SgValueExp :: ";
108107 0 : std::cout << " p_operatorPosition is not in memory pool of ";
108108 0 : std::cout << p_operatorPosition->class_name() << std::endl;
108109 : }
108110 : }
108111 : else
108112 : {
108113 0 : std::cout << "SgValueExp :: " << std::flush;
108114 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
108115 0 : std::cout << " not valid " << std::endl;
108116 : }
108117 : }
108118 :
108119 0 : if ( p_startOfConstruct != NULL )
108120 : {
108121 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108122 : {
108123 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
108124 : {
108125 0 : std::cout << "SgValueExp :: ";
108126 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
108127 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
108128 : }
108129 : }
108130 : else
108131 : {
108132 0 : std::cout << "SgValueExp :: " << std::flush;
108133 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
108134 0 : std::cout << " not valid " << std::endl;
108135 : }
108136 : }
108137 :
108138 0 : if ( p_endOfConstruct != NULL )
108139 : {
108140 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108141 : {
108142 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
108143 : {
108144 0 : std::cout << "SgValueExp :: ";
108145 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
108146 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
108147 : }
108148 : }
108149 : else
108150 : {
108151 0 : std::cout << "SgValueExp :: " << std::flush;
108152 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
108153 0 : std::cout << " not valid " << std::endl;
108154 : }
108155 : }
108156 :
108157 0 : if ( p_parent != NULL )
108158 : {
108159 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108160 : {
108161 0 : if ( p_parent->isInMemoryPool() == false )
108162 : {
108163 0 : std::cout << "SgValueExp :: ";
108164 0 : std::cout << " p_parent is not in memory pool of ";
108165 0 : std::cout << p_parent->class_name() << std::endl;
108166 : }
108167 : }
108168 : else
108169 : {
108170 0 : std::cout << "SgValueExp :: " << std::flush;
108171 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
108172 0 : std::cout << " not valid " << std::endl;
108173 : }
108174 : }
108175 :
108176 :
108177 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108178 :
108179 0 : }
108180 :
108181 :
108182 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
108183 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
108184 : bool
108185 0 : SgValueExp::isInMemoryPool ()
108186 : {
108187 0 : typedef unsigned char* TestType;
108188 :
108189 0 : bool found = false;
108190 :
108191 0 : ROSE_ASSERT(this != NULL);
108192 :
108193 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
108194 :
108195 0 : TestType tested = (TestType) ( this ) ;
108196 :
108197 0 : std::vector < unsigned char* > :: const_iterator block = SgValueExp::pools.begin();
108198 :
108199 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
108200 : // while (found == false && block < Memory_Block_List.end())
108201 0 : while ( (found == false) && (block != SgValueExp::pools.end()) )
108202 : {
108203 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgValueExp::pool_size * sizeof(SgValueExp) ) ) ;
108204 0 : ++block;
108205 : }
108206 :
108207 : // Special handling for static data
108208 :
108209 :
108210 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
108211 0 : ROSE_ASSERT(found == true);
108212 :
108213 0 : return found;
108214 : }
108215 : /* #line 108216 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
108216 :
108217 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
108218 :
108219 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108220 :
108221 : /* #line 108222 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
108222 :
108223 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108224 :
108225 : void
108226 0 : SgBoolValExp::checkDataMemberPointersIfInMemoryPool()
108227 : {
108228 : // ------------ checking pointers of SgBoolValExp -------------------
108229 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
108230 :
108231 0 : if ( p_originalExpressionTree != NULL )
108232 : {
108233 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108234 : {
108235 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
108236 : {
108237 0 : std::cout << "SgBoolValExp :: ";
108238 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
108239 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
108240 : }
108241 : }
108242 : else
108243 : {
108244 0 : std::cout << "SgBoolValExp :: " << std::flush;
108245 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
108246 0 : std::cout << " not valid " << std::endl;
108247 : }
108248 : }
108249 :
108250 0 : if ( p_operatorPosition != NULL )
108251 : {
108252 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108253 : {
108254 0 : if ( p_operatorPosition->isInMemoryPool() == false )
108255 : {
108256 0 : std::cout << "SgBoolValExp :: ";
108257 0 : std::cout << " p_operatorPosition is not in memory pool of ";
108258 0 : std::cout << p_operatorPosition->class_name() << std::endl;
108259 : }
108260 : }
108261 : else
108262 : {
108263 0 : std::cout << "SgBoolValExp :: " << std::flush;
108264 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
108265 0 : std::cout << " not valid " << std::endl;
108266 : }
108267 : }
108268 :
108269 0 : if ( p_startOfConstruct != NULL )
108270 : {
108271 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108272 : {
108273 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
108274 : {
108275 0 : std::cout << "SgBoolValExp :: ";
108276 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
108277 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
108278 : }
108279 : }
108280 : else
108281 : {
108282 0 : std::cout << "SgBoolValExp :: " << std::flush;
108283 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
108284 0 : std::cout << " not valid " << std::endl;
108285 : }
108286 : }
108287 :
108288 0 : if ( p_endOfConstruct != NULL )
108289 : {
108290 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108291 : {
108292 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
108293 : {
108294 0 : std::cout << "SgBoolValExp :: ";
108295 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
108296 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
108297 : }
108298 : }
108299 : else
108300 : {
108301 0 : std::cout << "SgBoolValExp :: " << std::flush;
108302 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
108303 0 : std::cout << " not valid " << std::endl;
108304 : }
108305 : }
108306 :
108307 0 : if ( p_parent != NULL )
108308 : {
108309 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108310 : {
108311 0 : if ( p_parent->isInMemoryPool() == false )
108312 : {
108313 0 : std::cout << "SgBoolValExp :: ";
108314 0 : std::cout << " p_parent is not in memory pool of ";
108315 0 : std::cout << p_parent->class_name() << std::endl;
108316 : }
108317 : }
108318 : else
108319 : {
108320 0 : std::cout << "SgBoolValExp :: " << std::flush;
108321 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
108322 0 : std::cout << " not valid " << std::endl;
108323 : }
108324 : }
108325 :
108326 :
108327 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108328 :
108329 0 : }
108330 :
108331 :
108332 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
108333 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
108334 : bool
108335 0 : SgBoolValExp::isInMemoryPool ()
108336 : {
108337 0 : typedef unsigned char* TestType;
108338 :
108339 0 : bool found = false;
108340 :
108341 0 : ROSE_ASSERT(this != NULL);
108342 :
108343 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
108344 :
108345 0 : TestType tested = (TestType) ( this ) ;
108346 :
108347 0 : std::vector < unsigned char* > :: const_iterator block = SgBoolValExp::pools.begin();
108348 :
108349 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
108350 : // while (found == false && block < Memory_Block_List.end())
108351 0 : while ( (found == false) && (block != SgBoolValExp::pools.end()) )
108352 : {
108353 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgBoolValExp::pool_size * sizeof(SgBoolValExp) ) ) ;
108354 0 : ++block;
108355 : }
108356 :
108357 : // Special handling for static data
108358 :
108359 :
108360 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
108361 0 : ROSE_ASSERT(found == true);
108362 :
108363 0 : return found;
108364 : }
108365 : /* #line 108366 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
108366 :
108367 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
108368 :
108369 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108370 :
108371 : /* #line 108372 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
108372 :
108373 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108374 :
108375 : void
108376 0 : SgStringVal::checkDataMemberPointersIfInMemoryPool()
108377 : {
108378 : // ------------ checking pointers of SgStringVal -------------------
108379 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
108380 :
108381 0 : if ( p_originalExpressionTree != NULL )
108382 : {
108383 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108384 : {
108385 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
108386 : {
108387 0 : std::cout << "SgStringVal :: ";
108388 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
108389 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
108390 : }
108391 : }
108392 : else
108393 : {
108394 0 : std::cout << "SgStringVal :: " << std::flush;
108395 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
108396 0 : std::cout << " not valid " << std::endl;
108397 : }
108398 : }
108399 :
108400 0 : if ( p_operatorPosition != NULL )
108401 : {
108402 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108403 : {
108404 0 : if ( p_operatorPosition->isInMemoryPool() == false )
108405 : {
108406 0 : std::cout << "SgStringVal :: ";
108407 0 : std::cout << " p_operatorPosition is not in memory pool of ";
108408 0 : std::cout << p_operatorPosition->class_name() << std::endl;
108409 : }
108410 : }
108411 : else
108412 : {
108413 0 : std::cout << "SgStringVal :: " << std::flush;
108414 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
108415 0 : std::cout << " not valid " << std::endl;
108416 : }
108417 : }
108418 :
108419 0 : if ( p_startOfConstruct != NULL )
108420 : {
108421 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108422 : {
108423 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
108424 : {
108425 0 : std::cout << "SgStringVal :: ";
108426 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
108427 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
108428 : }
108429 : }
108430 : else
108431 : {
108432 0 : std::cout << "SgStringVal :: " << std::flush;
108433 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
108434 0 : std::cout << " not valid " << std::endl;
108435 : }
108436 : }
108437 :
108438 0 : if ( p_endOfConstruct != NULL )
108439 : {
108440 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108441 : {
108442 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
108443 : {
108444 0 : std::cout << "SgStringVal :: ";
108445 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
108446 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
108447 : }
108448 : }
108449 : else
108450 : {
108451 0 : std::cout << "SgStringVal :: " << std::flush;
108452 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
108453 0 : std::cout << " not valid " << std::endl;
108454 : }
108455 : }
108456 :
108457 0 : if ( p_parent != NULL )
108458 : {
108459 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108460 : {
108461 0 : if ( p_parent->isInMemoryPool() == false )
108462 : {
108463 0 : std::cout << "SgStringVal :: ";
108464 0 : std::cout << " p_parent is not in memory pool of ";
108465 0 : std::cout << p_parent->class_name() << std::endl;
108466 : }
108467 : }
108468 : else
108469 : {
108470 0 : std::cout << "SgStringVal :: " << std::flush;
108471 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
108472 0 : std::cout << " not valid " << std::endl;
108473 : }
108474 : }
108475 :
108476 :
108477 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108478 :
108479 0 : }
108480 :
108481 :
108482 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
108483 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
108484 : bool
108485 0 : SgStringVal::isInMemoryPool ()
108486 : {
108487 0 : typedef unsigned char* TestType;
108488 :
108489 0 : bool found = false;
108490 :
108491 0 : ROSE_ASSERT(this != NULL);
108492 :
108493 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
108494 :
108495 0 : TestType tested = (TestType) ( this ) ;
108496 :
108497 0 : std::vector < unsigned char* > :: const_iterator block = SgStringVal::pools.begin();
108498 :
108499 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
108500 : // while (found == false && block < Memory_Block_List.end())
108501 0 : while ( (found == false) && (block != SgStringVal::pools.end()) )
108502 : {
108503 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgStringVal::pool_size * sizeof(SgStringVal) ) ) ;
108504 0 : ++block;
108505 : }
108506 :
108507 : // Special handling for static data
108508 :
108509 :
108510 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
108511 0 : ROSE_ASSERT(found == true);
108512 :
108513 0 : return found;
108514 : }
108515 : /* #line 108516 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
108516 :
108517 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
108518 :
108519 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108520 :
108521 : /* #line 108522 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
108522 :
108523 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108524 :
108525 : void
108526 0 : SgShortVal::checkDataMemberPointersIfInMemoryPool()
108527 : {
108528 : // ------------ checking pointers of SgShortVal -------------------
108529 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
108530 :
108531 0 : if ( p_originalExpressionTree != NULL )
108532 : {
108533 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108534 : {
108535 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
108536 : {
108537 0 : std::cout << "SgShortVal :: ";
108538 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
108539 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
108540 : }
108541 : }
108542 : else
108543 : {
108544 0 : std::cout << "SgShortVal :: " << std::flush;
108545 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
108546 0 : std::cout << " not valid " << std::endl;
108547 : }
108548 : }
108549 :
108550 0 : if ( p_operatorPosition != NULL )
108551 : {
108552 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108553 : {
108554 0 : if ( p_operatorPosition->isInMemoryPool() == false )
108555 : {
108556 0 : std::cout << "SgShortVal :: ";
108557 0 : std::cout << " p_operatorPosition is not in memory pool of ";
108558 0 : std::cout << p_operatorPosition->class_name() << std::endl;
108559 : }
108560 : }
108561 : else
108562 : {
108563 0 : std::cout << "SgShortVal :: " << std::flush;
108564 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
108565 0 : std::cout << " not valid " << std::endl;
108566 : }
108567 : }
108568 :
108569 0 : if ( p_startOfConstruct != NULL )
108570 : {
108571 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108572 : {
108573 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
108574 : {
108575 0 : std::cout << "SgShortVal :: ";
108576 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
108577 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
108578 : }
108579 : }
108580 : else
108581 : {
108582 0 : std::cout << "SgShortVal :: " << std::flush;
108583 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
108584 0 : std::cout << " not valid " << std::endl;
108585 : }
108586 : }
108587 :
108588 0 : if ( p_endOfConstruct != NULL )
108589 : {
108590 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108591 : {
108592 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
108593 : {
108594 0 : std::cout << "SgShortVal :: ";
108595 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
108596 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
108597 : }
108598 : }
108599 : else
108600 : {
108601 0 : std::cout << "SgShortVal :: " << std::flush;
108602 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
108603 0 : std::cout << " not valid " << std::endl;
108604 : }
108605 : }
108606 :
108607 0 : if ( p_parent != NULL )
108608 : {
108609 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108610 : {
108611 0 : if ( p_parent->isInMemoryPool() == false )
108612 : {
108613 0 : std::cout << "SgShortVal :: ";
108614 0 : std::cout << " p_parent is not in memory pool of ";
108615 0 : std::cout << p_parent->class_name() << std::endl;
108616 : }
108617 : }
108618 : else
108619 : {
108620 0 : std::cout << "SgShortVal :: " << std::flush;
108621 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
108622 0 : std::cout << " not valid " << std::endl;
108623 : }
108624 : }
108625 :
108626 :
108627 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108628 :
108629 0 : }
108630 :
108631 :
108632 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
108633 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
108634 : bool
108635 0 : SgShortVal::isInMemoryPool ()
108636 : {
108637 0 : typedef unsigned char* TestType;
108638 :
108639 0 : bool found = false;
108640 :
108641 0 : ROSE_ASSERT(this != NULL);
108642 :
108643 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
108644 :
108645 0 : TestType tested = (TestType) ( this ) ;
108646 :
108647 0 : std::vector < unsigned char* > :: const_iterator block = SgShortVal::pools.begin();
108648 :
108649 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
108650 : // while (found == false && block < Memory_Block_List.end())
108651 0 : while ( (found == false) && (block != SgShortVal::pools.end()) )
108652 : {
108653 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgShortVal::pool_size * sizeof(SgShortVal) ) ) ;
108654 0 : ++block;
108655 : }
108656 :
108657 : // Special handling for static data
108658 :
108659 :
108660 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
108661 0 : ROSE_ASSERT(found == true);
108662 :
108663 0 : return found;
108664 : }
108665 : /* #line 108666 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
108666 :
108667 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
108668 :
108669 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108670 :
108671 : /* #line 108672 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
108672 :
108673 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108674 :
108675 : void
108676 0 : SgCharVal::checkDataMemberPointersIfInMemoryPool()
108677 : {
108678 : // ------------ checking pointers of SgCharVal -------------------
108679 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
108680 :
108681 0 : if ( p_originalExpressionTree != NULL )
108682 : {
108683 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108684 : {
108685 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
108686 : {
108687 0 : std::cout << "SgCharVal :: ";
108688 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
108689 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
108690 : }
108691 : }
108692 : else
108693 : {
108694 0 : std::cout << "SgCharVal :: " << std::flush;
108695 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
108696 0 : std::cout << " not valid " << std::endl;
108697 : }
108698 : }
108699 :
108700 0 : if ( p_operatorPosition != NULL )
108701 : {
108702 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108703 : {
108704 0 : if ( p_operatorPosition->isInMemoryPool() == false )
108705 : {
108706 0 : std::cout << "SgCharVal :: ";
108707 0 : std::cout << " p_operatorPosition is not in memory pool of ";
108708 0 : std::cout << p_operatorPosition->class_name() << std::endl;
108709 : }
108710 : }
108711 : else
108712 : {
108713 0 : std::cout << "SgCharVal :: " << std::flush;
108714 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
108715 0 : std::cout << " not valid " << std::endl;
108716 : }
108717 : }
108718 :
108719 0 : if ( p_startOfConstruct != NULL )
108720 : {
108721 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108722 : {
108723 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
108724 : {
108725 0 : std::cout << "SgCharVal :: ";
108726 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
108727 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
108728 : }
108729 : }
108730 : else
108731 : {
108732 0 : std::cout << "SgCharVal :: " << std::flush;
108733 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
108734 0 : std::cout << " not valid " << std::endl;
108735 : }
108736 : }
108737 :
108738 0 : if ( p_endOfConstruct != NULL )
108739 : {
108740 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108741 : {
108742 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
108743 : {
108744 0 : std::cout << "SgCharVal :: ";
108745 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
108746 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
108747 : }
108748 : }
108749 : else
108750 : {
108751 0 : std::cout << "SgCharVal :: " << std::flush;
108752 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
108753 0 : std::cout << " not valid " << std::endl;
108754 : }
108755 : }
108756 :
108757 0 : if ( p_parent != NULL )
108758 : {
108759 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108760 : {
108761 0 : if ( p_parent->isInMemoryPool() == false )
108762 : {
108763 0 : std::cout << "SgCharVal :: ";
108764 0 : std::cout << " p_parent is not in memory pool of ";
108765 0 : std::cout << p_parent->class_name() << std::endl;
108766 : }
108767 : }
108768 : else
108769 : {
108770 0 : std::cout << "SgCharVal :: " << std::flush;
108771 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
108772 0 : std::cout << " not valid " << std::endl;
108773 : }
108774 : }
108775 :
108776 :
108777 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108778 :
108779 0 : }
108780 :
108781 :
108782 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
108783 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
108784 : bool
108785 0 : SgCharVal::isInMemoryPool ()
108786 : {
108787 0 : typedef unsigned char* TestType;
108788 :
108789 0 : bool found = false;
108790 :
108791 0 : ROSE_ASSERT(this != NULL);
108792 :
108793 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
108794 :
108795 0 : TestType tested = (TestType) ( this ) ;
108796 :
108797 0 : std::vector < unsigned char* > :: const_iterator block = SgCharVal::pools.begin();
108798 :
108799 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
108800 : // while (found == false && block < Memory_Block_List.end())
108801 0 : while ( (found == false) && (block != SgCharVal::pools.end()) )
108802 : {
108803 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCharVal::pool_size * sizeof(SgCharVal) ) ) ;
108804 0 : ++block;
108805 : }
108806 :
108807 : // Special handling for static data
108808 :
108809 :
108810 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
108811 0 : ROSE_ASSERT(found == true);
108812 :
108813 0 : return found;
108814 : }
108815 : /* #line 108816 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
108816 :
108817 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
108818 :
108819 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108820 :
108821 : /* #line 108822 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
108822 :
108823 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108824 :
108825 : void
108826 0 : SgUnsignedCharVal::checkDataMemberPointersIfInMemoryPool()
108827 : {
108828 : // ------------ checking pointers of SgUnsignedCharVal -------------------
108829 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
108830 :
108831 0 : if ( p_originalExpressionTree != NULL )
108832 : {
108833 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108834 : {
108835 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
108836 : {
108837 0 : std::cout << "SgUnsignedCharVal :: ";
108838 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
108839 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
108840 : }
108841 : }
108842 : else
108843 : {
108844 0 : std::cout << "SgUnsignedCharVal :: " << std::flush;
108845 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
108846 0 : std::cout << " not valid " << std::endl;
108847 : }
108848 : }
108849 :
108850 0 : if ( p_operatorPosition != NULL )
108851 : {
108852 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108853 : {
108854 0 : if ( p_operatorPosition->isInMemoryPool() == false )
108855 : {
108856 0 : std::cout << "SgUnsignedCharVal :: ";
108857 0 : std::cout << " p_operatorPosition is not in memory pool of ";
108858 0 : std::cout << p_operatorPosition->class_name() << std::endl;
108859 : }
108860 : }
108861 : else
108862 : {
108863 0 : std::cout << "SgUnsignedCharVal :: " << std::flush;
108864 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
108865 0 : std::cout << " not valid " << std::endl;
108866 : }
108867 : }
108868 :
108869 0 : if ( p_startOfConstruct != NULL )
108870 : {
108871 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108872 : {
108873 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
108874 : {
108875 0 : std::cout << "SgUnsignedCharVal :: ";
108876 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
108877 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
108878 : }
108879 : }
108880 : else
108881 : {
108882 0 : std::cout << "SgUnsignedCharVal :: " << std::flush;
108883 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
108884 0 : std::cout << " not valid " << std::endl;
108885 : }
108886 : }
108887 :
108888 0 : if ( p_endOfConstruct != NULL )
108889 : {
108890 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108891 : {
108892 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
108893 : {
108894 0 : std::cout << "SgUnsignedCharVal :: ";
108895 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
108896 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
108897 : }
108898 : }
108899 : else
108900 : {
108901 0 : std::cout << "SgUnsignedCharVal :: " << std::flush;
108902 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
108903 0 : std::cout << " not valid " << std::endl;
108904 : }
108905 : }
108906 :
108907 0 : if ( p_parent != NULL )
108908 : {
108909 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108910 : {
108911 0 : if ( p_parent->isInMemoryPool() == false )
108912 : {
108913 0 : std::cout << "SgUnsignedCharVal :: ";
108914 0 : std::cout << " p_parent is not in memory pool of ";
108915 0 : std::cout << p_parent->class_name() << std::endl;
108916 : }
108917 : }
108918 : else
108919 : {
108920 0 : std::cout << "SgUnsignedCharVal :: " << std::flush;
108921 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
108922 0 : std::cout << " not valid " << std::endl;
108923 : }
108924 : }
108925 :
108926 :
108927 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108928 :
108929 0 : }
108930 :
108931 :
108932 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
108933 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
108934 : bool
108935 0 : SgUnsignedCharVal::isInMemoryPool ()
108936 : {
108937 0 : typedef unsigned char* TestType;
108938 :
108939 0 : bool found = false;
108940 :
108941 0 : ROSE_ASSERT(this != NULL);
108942 :
108943 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
108944 :
108945 0 : TestType tested = (TestType) ( this ) ;
108946 :
108947 0 : std::vector < unsigned char* > :: const_iterator block = SgUnsignedCharVal::pools.begin();
108948 :
108949 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
108950 : // while (found == false && block < Memory_Block_List.end())
108951 0 : while ( (found == false) && (block != SgUnsignedCharVal::pools.end()) )
108952 : {
108953 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUnsignedCharVal::pool_size * sizeof(SgUnsignedCharVal) ) ) ;
108954 0 : ++block;
108955 : }
108956 :
108957 : // Special handling for static data
108958 :
108959 :
108960 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
108961 0 : ROSE_ASSERT(found == true);
108962 :
108963 0 : return found;
108964 : }
108965 : /* #line 108966 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
108966 :
108967 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
108968 :
108969 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108970 :
108971 : /* #line 108972 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
108972 :
108973 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
108974 :
108975 : void
108976 0 : SgWcharVal::checkDataMemberPointersIfInMemoryPool()
108977 : {
108978 : // ------------ checking pointers of SgWcharVal -------------------
108979 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
108980 :
108981 0 : if ( p_originalExpressionTree != NULL )
108982 : {
108983 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
108984 : {
108985 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
108986 : {
108987 0 : std::cout << "SgWcharVal :: ";
108988 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
108989 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
108990 : }
108991 : }
108992 : else
108993 : {
108994 0 : std::cout << "SgWcharVal :: " << std::flush;
108995 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
108996 0 : std::cout << " not valid " << std::endl;
108997 : }
108998 : }
108999 :
109000 0 : if ( p_operatorPosition != NULL )
109001 : {
109002 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109003 : {
109004 0 : if ( p_operatorPosition->isInMemoryPool() == false )
109005 : {
109006 0 : std::cout << "SgWcharVal :: ";
109007 0 : std::cout << " p_operatorPosition is not in memory pool of ";
109008 0 : std::cout << p_operatorPosition->class_name() << std::endl;
109009 : }
109010 : }
109011 : else
109012 : {
109013 0 : std::cout << "SgWcharVal :: " << std::flush;
109014 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
109015 0 : std::cout << " not valid " << std::endl;
109016 : }
109017 : }
109018 :
109019 0 : if ( p_startOfConstruct != NULL )
109020 : {
109021 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109022 : {
109023 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
109024 : {
109025 0 : std::cout << "SgWcharVal :: ";
109026 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
109027 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
109028 : }
109029 : }
109030 : else
109031 : {
109032 0 : std::cout << "SgWcharVal :: " << std::flush;
109033 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
109034 0 : std::cout << " not valid " << std::endl;
109035 : }
109036 : }
109037 :
109038 0 : if ( p_endOfConstruct != NULL )
109039 : {
109040 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109041 : {
109042 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
109043 : {
109044 0 : std::cout << "SgWcharVal :: ";
109045 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
109046 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
109047 : }
109048 : }
109049 : else
109050 : {
109051 0 : std::cout << "SgWcharVal :: " << std::flush;
109052 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
109053 0 : std::cout << " not valid " << std::endl;
109054 : }
109055 : }
109056 :
109057 0 : if ( p_parent != NULL )
109058 : {
109059 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109060 : {
109061 0 : if ( p_parent->isInMemoryPool() == false )
109062 : {
109063 0 : std::cout << "SgWcharVal :: ";
109064 0 : std::cout << " p_parent is not in memory pool of ";
109065 0 : std::cout << p_parent->class_name() << std::endl;
109066 : }
109067 : }
109068 : else
109069 : {
109070 0 : std::cout << "SgWcharVal :: " << std::flush;
109071 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
109072 0 : std::cout << " not valid " << std::endl;
109073 : }
109074 : }
109075 :
109076 :
109077 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109078 :
109079 0 : }
109080 :
109081 :
109082 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
109083 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
109084 : bool
109085 0 : SgWcharVal::isInMemoryPool ()
109086 : {
109087 0 : typedef unsigned char* TestType;
109088 :
109089 0 : bool found = false;
109090 :
109091 0 : ROSE_ASSERT(this != NULL);
109092 :
109093 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
109094 :
109095 0 : TestType tested = (TestType) ( this ) ;
109096 :
109097 0 : std::vector < unsigned char* > :: const_iterator block = SgWcharVal::pools.begin();
109098 :
109099 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
109100 : // while (found == false && block < Memory_Block_List.end())
109101 0 : while ( (found == false) && (block != SgWcharVal::pools.end()) )
109102 : {
109103 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgWcharVal::pool_size * sizeof(SgWcharVal) ) ) ;
109104 0 : ++block;
109105 : }
109106 :
109107 : // Special handling for static data
109108 :
109109 :
109110 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
109111 0 : ROSE_ASSERT(found == true);
109112 :
109113 0 : return found;
109114 : }
109115 : /* #line 109116 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
109116 :
109117 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
109118 :
109119 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109120 :
109121 : /* #line 109122 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
109122 :
109123 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109124 :
109125 : void
109126 0 : SgUnsignedShortVal::checkDataMemberPointersIfInMemoryPool()
109127 : {
109128 : // ------------ checking pointers of SgUnsignedShortVal -------------------
109129 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
109130 :
109131 0 : if ( p_originalExpressionTree != NULL )
109132 : {
109133 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109134 : {
109135 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
109136 : {
109137 0 : std::cout << "SgUnsignedShortVal :: ";
109138 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
109139 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
109140 : }
109141 : }
109142 : else
109143 : {
109144 0 : std::cout << "SgUnsignedShortVal :: " << std::flush;
109145 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
109146 0 : std::cout << " not valid " << std::endl;
109147 : }
109148 : }
109149 :
109150 0 : if ( p_operatorPosition != NULL )
109151 : {
109152 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109153 : {
109154 0 : if ( p_operatorPosition->isInMemoryPool() == false )
109155 : {
109156 0 : std::cout << "SgUnsignedShortVal :: ";
109157 0 : std::cout << " p_operatorPosition is not in memory pool of ";
109158 0 : std::cout << p_operatorPosition->class_name() << std::endl;
109159 : }
109160 : }
109161 : else
109162 : {
109163 0 : std::cout << "SgUnsignedShortVal :: " << std::flush;
109164 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
109165 0 : std::cout << " not valid " << std::endl;
109166 : }
109167 : }
109168 :
109169 0 : if ( p_startOfConstruct != NULL )
109170 : {
109171 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109172 : {
109173 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
109174 : {
109175 0 : std::cout << "SgUnsignedShortVal :: ";
109176 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
109177 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
109178 : }
109179 : }
109180 : else
109181 : {
109182 0 : std::cout << "SgUnsignedShortVal :: " << std::flush;
109183 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
109184 0 : std::cout << " not valid " << std::endl;
109185 : }
109186 : }
109187 :
109188 0 : if ( p_endOfConstruct != NULL )
109189 : {
109190 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109191 : {
109192 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
109193 : {
109194 0 : std::cout << "SgUnsignedShortVal :: ";
109195 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
109196 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
109197 : }
109198 : }
109199 : else
109200 : {
109201 0 : std::cout << "SgUnsignedShortVal :: " << std::flush;
109202 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
109203 0 : std::cout << " not valid " << std::endl;
109204 : }
109205 : }
109206 :
109207 0 : if ( p_parent != NULL )
109208 : {
109209 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109210 : {
109211 0 : if ( p_parent->isInMemoryPool() == false )
109212 : {
109213 0 : std::cout << "SgUnsignedShortVal :: ";
109214 0 : std::cout << " p_parent is not in memory pool of ";
109215 0 : std::cout << p_parent->class_name() << std::endl;
109216 : }
109217 : }
109218 : else
109219 : {
109220 0 : std::cout << "SgUnsignedShortVal :: " << std::flush;
109221 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
109222 0 : std::cout << " not valid " << std::endl;
109223 : }
109224 : }
109225 :
109226 :
109227 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109228 :
109229 0 : }
109230 :
109231 :
109232 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
109233 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
109234 : bool
109235 0 : SgUnsignedShortVal::isInMemoryPool ()
109236 : {
109237 0 : typedef unsigned char* TestType;
109238 :
109239 0 : bool found = false;
109240 :
109241 0 : ROSE_ASSERT(this != NULL);
109242 :
109243 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
109244 :
109245 0 : TestType tested = (TestType) ( this ) ;
109246 :
109247 0 : std::vector < unsigned char* > :: const_iterator block = SgUnsignedShortVal::pools.begin();
109248 :
109249 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
109250 : // while (found == false && block < Memory_Block_List.end())
109251 0 : while ( (found == false) && (block != SgUnsignedShortVal::pools.end()) )
109252 : {
109253 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUnsignedShortVal::pool_size * sizeof(SgUnsignedShortVal) ) ) ;
109254 0 : ++block;
109255 : }
109256 :
109257 : // Special handling for static data
109258 :
109259 :
109260 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
109261 0 : ROSE_ASSERT(found == true);
109262 :
109263 0 : return found;
109264 : }
109265 : /* #line 109266 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
109266 :
109267 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
109268 :
109269 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109270 :
109271 : /* #line 109272 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
109272 :
109273 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109274 :
109275 : void
109276 0 : SgIntVal::checkDataMemberPointersIfInMemoryPool()
109277 : {
109278 : // ------------ checking pointers of SgIntVal -------------------
109279 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
109280 :
109281 0 : if ( p_originalExpressionTree != NULL )
109282 : {
109283 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109284 : {
109285 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
109286 : {
109287 0 : std::cout << "SgIntVal :: ";
109288 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
109289 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
109290 : }
109291 : }
109292 : else
109293 : {
109294 0 : std::cout << "SgIntVal :: " << std::flush;
109295 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
109296 0 : std::cout << " not valid " << std::endl;
109297 : }
109298 : }
109299 :
109300 0 : if ( p_operatorPosition != NULL )
109301 : {
109302 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109303 : {
109304 0 : if ( p_operatorPosition->isInMemoryPool() == false )
109305 : {
109306 0 : std::cout << "SgIntVal :: ";
109307 0 : std::cout << " p_operatorPosition is not in memory pool of ";
109308 0 : std::cout << p_operatorPosition->class_name() << std::endl;
109309 : }
109310 : }
109311 : else
109312 : {
109313 0 : std::cout << "SgIntVal :: " << std::flush;
109314 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
109315 0 : std::cout << " not valid " << std::endl;
109316 : }
109317 : }
109318 :
109319 0 : if ( p_startOfConstruct != NULL )
109320 : {
109321 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109322 : {
109323 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
109324 : {
109325 0 : std::cout << "SgIntVal :: ";
109326 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
109327 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
109328 : }
109329 : }
109330 : else
109331 : {
109332 0 : std::cout << "SgIntVal :: " << std::flush;
109333 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
109334 0 : std::cout << " not valid " << std::endl;
109335 : }
109336 : }
109337 :
109338 0 : if ( p_endOfConstruct != NULL )
109339 : {
109340 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109341 : {
109342 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
109343 : {
109344 0 : std::cout << "SgIntVal :: ";
109345 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
109346 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
109347 : }
109348 : }
109349 : else
109350 : {
109351 0 : std::cout << "SgIntVal :: " << std::flush;
109352 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
109353 0 : std::cout << " not valid " << std::endl;
109354 : }
109355 : }
109356 :
109357 0 : if ( p_parent != NULL )
109358 : {
109359 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109360 : {
109361 0 : if ( p_parent->isInMemoryPool() == false )
109362 : {
109363 0 : std::cout << "SgIntVal :: ";
109364 0 : std::cout << " p_parent is not in memory pool of ";
109365 0 : std::cout << p_parent->class_name() << std::endl;
109366 : }
109367 : }
109368 : else
109369 : {
109370 0 : std::cout << "SgIntVal :: " << std::flush;
109371 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
109372 0 : std::cout << " not valid " << std::endl;
109373 : }
109374 : }
109375 :
109376 :
109377 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109378 :
109379 0 : }
109380 :
109381 :
109382 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
109383 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
109384 : bool
109385 0 : SgIntVal::isInMemoryPool ()
109386 : {
109387 0 : typedef unsigned char* TestType;
109388 :
109389 0 : bool found = false;
109390 :
109391 0 : ROSE_ASSERT(this != NULL);
109392 :
109393 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
109394 :
109395 0 : TestType tested = (TestType) ( this ) ;
109396 :
109397 0 : std::vector < unsigned char* > :: const_iterator block = SgIntVal::pools.begin();
109398 :
109399 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
109400 : // while (found == false && block < Memory_Block_List.end())
109401 0 : while ( (found == false) && (block != SgIntVal::pools.end()) )
109402 : {
109403 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIntVal::pool_size * sizeof(SgIntVal) ) ) ;
109404 0 : ++block;
109405 : }
109406 :
109407 : // Special handling for static data
109408 :
109409 :
109410 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
109411 0 : ROSE_ASSERT(found == true);
109412 :
109413 0 : return found;
109414 : }
109415 : /* #line 109416 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
109416 :
109417 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
109418 :
109419 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109420 :
109421 : /* #line 109422 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
109422 :
109423 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109424 :
109425 : void
109426 0 : SgEnumVal::checkDataMemberPointersIfInMemoryPool()
109427 : {
109428 : // ------------ checking pointers of SgEnumVal -------------------
109429 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
109430 :
109431 0 : if ( p_declaration != NULL )
109432 : {
109433 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109434 : {
109435 0 : if ( p_declaration->isInMemoryPool() == false )
109436 : {
109437 0 : std::cout << "SgEnumVal :: ";
109438 0 : std::cout << " p_declaration is not in memory pool of ";
109439 0 : std::cout << p_declaration->class_name() << std::endl;
109440 : }
109441 : }
109442 : else
109443 : {
109444 0 : std::cout << "SgEnumVal :: " << std::flush;
109445 0 : std::cout << "SgEnumDeclaration* p_declaration = " << p_declaration << " --> " << std::flush;
109446 0 : std::cout << " not valid " << std::endl;
109447 : }
109448 : }
109449 :
109450 0 : if ( p_originalExpressionTree != NULL )
109451 : {
109452 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109453 : {
109454 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
109455 : {
109456 0 : std::cout << "SgEnumVal :: ";
109457 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
109458 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
109459 : }
109460 : }
109461 : else
109462 : {
109463 0 : std::cout << "SgEnumVal :: " << std::flush;
109464 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
109465 0 : std::cout << " not valid " << std::endl;
109466 : }
109467 : }
109468 :
109469 0 : if ( p_operatorPosition != NULL )
109470 : {
109471 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109472 : {
109473 0 : if ( p_operatorPosition->isInMemoryPool() == false )
109474 : {
109475 0 : std::cout << "SgEnumVal :: ";
109476 0 : std::cout << " p_operatorPosition is not in memory pool of ";
109477 0 : std::cout << p_operatorPosition->class_name() << std::endl;
109478 : }
109479 : }
109480 : else
109481 : {
109482 0 : std::cout << "SgEnumVal :: " << std::flush;
109483 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
109484 0 : std::cout << " not valid " << std::endl;
109485 : }
109486 : }
109487 :
109488 0 : if ( p_startOfConstruct != NULL )
109489 : {
109490 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109491 : {
109492 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
109493 : {
109494 0 : std::cout << "SgEnumVal :: ";
109495 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
109496 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
109497 : }
109498 : }
109499 : else
109500 : {
109501 0 : std::cout << "SgEnumVal :: " << std::flush;
109502 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
109503 0 : std::cout << " not valid " << std::endl;
109504 : }
109505 : }
109506 :
109507 0 : if ( p_endOfConstruct != NULL )
109508 : {
109509 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109510 : {
109511 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
109512 : {
109513 0 : std::cout << "SgEnumVal :: ";
109514 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
109515 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
109516 : }
109517 : }
109518 : else
109519 : {
109520 0 : std::cout << "SgEnumVal :: " << std::flush;
109521 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
109522 0 : std::cout << " not valid " << std::endl;
109523 : }
109524 : }
109525 :
109526 0 : if ( p_parent != NULL )
109527 : {
109528 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109529 : {
109530 0 : if ( p_parent->isInMemoryPool() == false )
109531 : {
109532 0 : std::cout << "SgEnumVal :: ";
109533 0 : std::cout << " p_parent is not in memory pool of ";
109534 0 : std::cout << p_parent->class_name() << std::endl;
109535 : }
109536 : }
109537 : else
109538 : {
109539 0 : std::cout << "SgEnumVal :: " << std::flush;
109540 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
109541 0 : std::cout << " not valid " << std::endl;
109542 : }
109543 : }
109544 :
109545 :
109546 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109547 :
109548 0 : }
109549 :
109550 :
109551 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
109552 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
109553 : bool
109554 0 : SgEnumVal::isInMemoryPool ()
109555 : {
109556 0 : typedef unsigned char* TestType;
109557 :
109558 0 : bool found = false;
109559 :
109560 0 : ROSE_ASSERT(this != NULL);
109561 :
109562 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
109563 :
109564 0 : TestType tested = (TestType) ( this ) ;
109565 :
109566 0 : std::vector < unsigned char* > :: const_iterator block = SgEnumVal::pools.begin();
109567 :
109568 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
109569 : // while (found == false && block < Memory_Block_List.end())
109570 0 : while ( (found == false) && (block != SgEnumVal::pools.end()) )
109571 : {
109572 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgEnumVal::pool_size * sizeof(SgEnumVal) ) ) ;
109573 0 : ++block;
109574 : }
109575 :
109576 : // Special handling for static data
109577 :
109578 :
109579 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
109580 0 : ROSE_ASSERT(found == true);
109581 :
109582 0 : return found;
109583 : }
109584 : /* #line 109585 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
109585 :
109586 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
109587 :
109588 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109589 :
109590 : /* #line 109591 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
109591 :
109592 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109593 :
109594 : void
109595 0 : SgUnsignedIntVal::checkDataMemberPointersIfInMemoryPool()
109596 : {
109597 : // ------------ checking pointers of SgUnsignedIntVal -------------------
109598 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
109599 :
109600 0 : if ( p_originalExpressionTree != NULL )
109601 : {
109602 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109603 : {
109604 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
109605 : {
109606 0 : std::cout << "SgUnsignedIntVal :: ";
109607 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
109608 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
109609 : }
109610 : }
109611 : else
109612 : {
109613 0 : std::cout << "SgUnsignedIntVal :: " << std::flush;
109614 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
109615 0 : std::cout << " not valid " << std::endl;
109616 : }
109617 : }
109618 :
109619 0 : if ( p_operatorPosition != NULL )
109620 : {
109621 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109622 : {
109623 0 : if ( p_operatorPosition->isInMemoryPool() == false )
109624 : {
109625 0 : std::cout << "SgUnsignedIntVal :: ";
109626 0 : std::cout << " p_operatorPosition is not in memory pool of ";
109627 0 : std::cout << p_operatorPosition->class_name() << std::endl;
109628 : }
109629 : }
109630 : else
109631 : {
109632 0 : std::cout << "SgUnsignedIntVal :: " << std::flush;
109633 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
109634 0 : std::cout << " not valid " << std::endl;
109635 : }
109636 : }
109637 :
109638 0 : if ( p_startOfConstruct != NULL )
109639 : {
109640 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109641 : {
109642 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
109643 : {
109644 0 : std::cout << "SgUnsignedIntVal :: ";
109645 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
109646 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
109647 : }
109648 : }
109649 : else
109650 : {
109651 0 : std::cout << "SgUnsignedIntVal :: " << std::flush;
109652 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
109653 0 : std::cout << " not valid " << std::endl;
109654 : }
109655 : }
109656 :
109657 0 : if ( p_endOfConstruct != NULL )
109658 : {
109659 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109660 : {
109661 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
109662 : {
109663 0 : std::cout << "SgUnsignedIntVal :: ";
109664 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
109665 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
109666 : }
109667 : }
109668 : else
109669 : {
109670 0 : std::cout << "SgUnsignedIntVal :: " << std::flush;
109671 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
109672 0 : std::cout << " not valid " << std::endl;
109673 : }
109674 : }
109675 :
109676 0 : if ( p_parent != NULL )
109677 : {
109678 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109679 : {
109680 0 : if ( p_parent->isInMemoryPool() == false )
109681 : {
109682 0 : std::cout << "SgUnsignedIntVal :: ";
109683 0 : std::cout << " p_parent is not in memory pool of ";
109684 0 : std::cout << p_parent->class_name() << std::endl;
109685 : }
109686 : }
109687 : else
109688 : {
109689 0 : std::cout << "SgUnsignedIntVal :: " << std::flush;
109690 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
109691 0 : std::cout << " not valid " << std::endl;
109692 : }
109693 : }
109694 :
109695 :
109696 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109697 :
109698 0 : }
109699 :
109700 :
109701 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
109702 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
109703 : bool
109704 0 : SgUnsignedIntVal::isInMemoryPool ()
109705 : {
109706 0 : typedef unsigned char* TestType;
109707 :
109708 0 : bool found = false;
109709 :
109710 0 : ROSE_ASSERT(this != NULL);
109711 :
109712 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
109713 :
109714 0 : TestType tested = (TestType) ( this ) ;
109715 :
109716 0 : std::vector < unsigned char* > :: const_iterator block = SgUnsignedIntVal::pools.begin();
109717 :
109718 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
109719 : // while (found == false && block < Memory_Block_List.end())
109720 0 : while ( (found == false) && (block != SgUnsignedIntVal::pools.end()) )
109721 : {
109722 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUnsignedIntVal::pool_size * sizeof(SgUnsignedIntVal) ) ) ;
109723 0 : ++block;
109724 : }
109725 :
109726 : // Special handling for static data
109727 :
109728 :
109729 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
109730 0 : ROSE_ASSERT(found == true);
109731 :
109732 0 : return found;
109733 : }
109734 : /* #line 109735 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
109735 :
109736 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
109737 :
109738 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109739 :
109740 : /* #line 109741 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
109741 :
109742 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109743 :
109744 : void
109745 0 : SgLongIntVal::checkDataMemberPointersIfInMemoryPool()
109746 : {
109747 : // ------------ checking pointers of SgLongIntVal -------------------
109748 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
109749 :
109750 0 : if ( p_originalExpressionTree != NULL )
109751 : {
109752 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109753 : {
109754 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
109755 : {
109756 0 : std::cout << "SgLongIntVal :: ";
109757 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
109758 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
109759 : }
109760 : }
109761 : else
109762 : {
109763 0 : std::cout << "SgLongIntVal :: " << std::flush;
109764 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
109765 0 : std::cout << " not valid " << std::endl;
109766 : }
109767 : }
109768 :
109769 0 : if ( p_operatorPosition != NULL )
109770 : {
109771 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109772 : {
109773 0 : if ( p_operatorPosition->isInMemoryPool() == false )
109774 : {
109775 0 : std::cout << "SgLongIntVal :: ";
109776 0 : std::cout << " p_operatorPosition is not in memory pool of ";
109777 0 : std::cout << p_operatorPosition->class_name() << std::endl;
109778 : }
109779 : }
109780 : else
109781 : {
109782 0 : std::cout << "SgLongIntVal :: " << std::flush;
109783 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
109784 0 : std::cout << " not valid " << std::endl;
109785 : }
109786 : }
109787 :
109788 0 : if ( p_startOfConstruct != NULL )
109789 : {
109790 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109791 : {
109792 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
109793 : {
109794 0 : std::cout << "SgLongIntVal :: ";
109795 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
109796 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
109797 : }
109798 : }
109799 : else
109800 : {
109801 0 : std::cout << "SgLongIntVal :: " << std::flush;
109802 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
109803 0 : std::cout << " not valid " << std::endl;
109804 : }
109805 : }
109806 :
109807 0 : if ( p_endOfConstruct != NULL )
109808 : {
109809 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109810 : {
109811 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
109812 : {
109813 0 : std::cout << "SgLongIntVal :: ";
109814 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
109815 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
109816 : }
109817 : }
109818 : else
109819 : {
109820 0 : std::cout << "SgLongIntVal :: " << std::flush;
109821 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
109822 0 : std::cout << " not valid " << std::endl;
109823 : }
109824 : }
109825 :
109826 0 : if ( p_parent != NULL )
109827 : {
109828 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109829 : {
109830 0 : if ( p_parent->isInMemoryPool() == false )
109831 : {
109832 0 : std::cout << "SgLongIntVal :: ";
109833 0 : std::cout << " p_parent is not in memory pool of ";
109834 0 : std::cout << p_parent->class_name() << std::endl;
109835 : }
109836 : }
109837 : else
109838 : {
109839 0 : std::cout << "SgLongIntVal :: " << std::flush;
109840 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
109841 0 : std::cout << " not valid " << std::endl;
109842 : }
109843 : }
109844 :
109845 :
109846 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109847 :
109848 0 : }
109849 :
109850 :
109851 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
109852 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
109853 : bool
109854 0 : SgLongIntVal::isInMemoryPool ()
109855 : {
109856 0 : typedef unsigned char* TestType;
109857 :
109858 0 : bool found = false;
109859 :
109860 0 : ROSE_ASSERT(this != NULL);
109861 :
109862 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
109863 :
109864 0 : TestType tested = (TestType) ( this ) ;
109865 :
109866 0 : std::vector < unsigned char* > :: const_iterator block = SgLongIntVal::pools.begin();
109867 :
109868 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
109869 : // while (found == false && block < Memory_Block_List.end())
109870 0 : while ( (found == false) && (block != SgLongIntVal::pools.end()) )
109871 : {
109872 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLongIntVal::pool_size * sizeof(SgLongIntVal) ) ) ;
109873 0 : ++block;
109874 : }
109875 :
109876 : // Special handling for static data
109877 :
109878 :
109879 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
109880 0 : ROSE_ASSERT(found == true);
109881 :
109882 0 : return found;
109883 : }
109884 : /* #line 109885 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
109885 :
109886 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
109887 :
109888 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109889 :
109890 : /* #line 109891 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
109891 :
109892 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109893 :
109894 : void
109895 0 : SgLongLongIntVal::checkDataMemberPointersIfInMemoryPool()
109896 : {
109897 : // ------------ checking pointers of SgLongLongIntVal -------------------
109898 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
109899 :
109900 0 : if ( p_originalExpressionTree != NULL )
109901 : {
109902 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109903 : {
109904 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
109905 : {
109906 0 : std::cout << "SgLongLongIntVal :: ";
109907 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
109908 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
109909 : }
109910 : }
109911 : else
109912 : {
109913 0 : std::cout << "SgLongLongIntVal :: " << std::flush;
109914 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
109915 0 : std::cout << " not valid " << std::endl;
109916 : }
109917 : }
109918 :
109919 0 : if ( p_operatorPosition != NULL )
109920 : {
109921 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109922 : {
109923 0 : if ( p_operatorPosition->isInMemoryPool() == false )
109924 : {
109925 0 : std::cout << "SgLongLongIntVal :: ";
109926 0 : std::cout << " p_operatorPosition is not in memory pool of ";
109927 0 : std::cout << p_operatorPosition->class_name() << std::endl;
109928 : }
109929 : }
109930 : else
109931 : {
109932 0 : std::cout << "SgLongLongIntVal :: " << std::flush;
109933 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
109934 0 : std::cout << " not valid " << std::endl;
109935 : }
109936 : }
109937 :
109938 0 : if ( p_startOfConstruct != NULL )
109939 : {
109940 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109941 : {
109942 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
109943 : {
109944 0 : std::cout << "SgLongLongIntVal :: ";
109945 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
109946 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
109947 : }
109948 : }
109949 : else
109950 : {
109951 0 : std::cout << "SgLongLongIntVal :: " << std::flush;
109952 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
109953 0 : std::cout << " not valid " << std::endl;
109954 : }
109955 : }
109956 :
109957 0 : if ( p_endOfConstruct != NULL )
109958 : {
109959 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109960 : {
109961 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
109962 : {
109963 0 : std::cout << "SgLongLongIntVal :: ";
109964 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
109965 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
109966 : }
109967 : }
109968 : else
109969 : {
109970 0 : std::cout << "SgLongLongIntVal :: " << std::flush;
109971 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
109972 0 : std::cout << " not valid " << std::endl;
109973 : }
109974 : }
109975 :
109976 0 : if ( p_parent != NULL )
109977 : {
109978 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
109979 : {
109980 0 : if ( p_parent->isInMemoryPool() == false )
109981 : {
109982 0 : std::cout << "SgLongLongIntVal :: ";
109983 0 : std::cout << " p_parent is not in memory pool of ";
109984 0 : std::cout << p_parent->class_name() << std::endl;
109985 : }
109986 : }
109987 : else
109988 : {
109989 0 : std::cout << "SgLongLongIntVal :: " << std::flush;
109990 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
109991 0 : std::cout << " not valid " << std::endl;
109992 : }
109993 : }
109994 :
109995 :
109996 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
109997 :
109998 0 : }
109999 :
110000 :
110001 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
110002 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
110003 : bool
110004 0 : SgLongLongIntVal::isInMemoryPool ()
110005 : {
110006 0 : typedef unsigned char* TestType;
110007 :
110008 0 : bool found = false;
110009 :
110010 0 : ROSE_ASSERT(this != NULL);
110011 :
110012 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
110013 :
110014 0 : TestType tested = (TestType) ( this ) ;
110015 :
110016 0 : std::vector < unsigned char* > :: const_iterator block = SgLongLongIntVal::pools.begin();
110017 :
110018 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
110019 : // while (found == false && block < Memory_Block_List.end())
110020 0 : while ( (found == false) && (block != SgLongLongIntVal::pools.end()) )
110021 : {
110022 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLongLongIntVal::pool_size * sizeof(SgLongLongIntVal) ) ) ;
110023 0 : ++block;
110024 : }
110025 :
110026 : // Special handling for static data
110027 :
110028 :
110029 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
110030 0 : ROSE_ASSERT(found == true);
110031 :
110032 0 : return found;
110033 : }
110034 : /* #line 110035 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
110035 :
110036 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
110037 :
110038 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110039 :
110040 : /* #line 110041 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
110041 :
110042 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110043 :
110044 : void
110045 0 : SgUnsignedLongLongIntVal::checkDataMemberPointersIfInMemoryPool()
110046 : {
110047 : // ------------ checking pointers of SgUnsignedLongLongIntVal -------------------
110048 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
110049 :
110050 0 : if ( p_originalExpressionTree != NULL )
110051 : {
110052 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110053 : {
110054 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
110055 : {
110056 0 : std::cout << "SgUnsignedLongLongIntVal :: ";
110057 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
110058 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
110059 : }
110060 : }
110061 : else
110062 : {
110063 0 : std::cout << "SgUnsignedLongLongIntVal :: " << std::flush;
110064 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
110065 0 : std::cout << " not valid " << std::endl;
110066 : }
110067 : }
110068 :
110069 0 : if ( p_operatorPosition != NULL )
110070 : {
110071 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110072 : {
110073 0 : if ( p_operatorPosition->isInMemoryPool() == false )
110074 : {
110075 0 : std::cout << "SgUnsignedLongLongIntVal :: ";
110076 0 : std::cout << " p_operatorPosition is not in memory pool of ";
110077 0 : std::cout << p_operatorPosition->class_name() << std::endl;
110078 : }
110079 : }
110080 : else
110081 : {
110082 0 : std::cout << "SgUnsignedLongLongIntVal :: " << std::flush;
110083 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
110084 0 : std::cout << " not valid " << std::endl;
110085 : }
110086 : }
110087 :
110088 0 : if ( p_startOfConstruct != NULL )
110089 : {
110090 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110091 : {
110092 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
110093 : {
110094 0 : std::cout << "SgUnsignedLongLongIntVal :: ";
110095 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
110096 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
110097 : }
110098 : }
110099 : else
110100 : {
110101 0 : std::cout << "SgUnsignedLongLongIntVal :: " << std::flush;
110102 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
110103 0 : std::cout << " not valid " << std::endl;
110104 : }
110105 : }
110106 :
110107 0 : if ( p_endOfConstruct != NULL )
110108 : {
110109 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110110 : {
110111 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
110112 : {
110113 0 : std::cout << "SgUnsignedLongLongIntVal :: ";
110114 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
110115 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
110116 : }
110117 : }
110118 : else
110119 : {
110120 0 : std::cout << "SgUnsignedLongLongIntVal :: " << std::flush;
110121 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
110122 0 : std::cout << " not valid " << std::endl;
110123 : }
110124 : }
110125 :
110126 0 : if ( p_parent != NULL )
110127 : {
110128 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110129 : {
110130 0 : if ( p_parent->isInMemoryPool() == false )
110131 : {
110132 0 : std::cout << "SgUnsignedLongLongIntVal :: ";
110133 0 : std::cout << " p_parent is not in memory pool of ";
110134 0 : std::cout << p_parent->class_name() << std::endl;
110135 : }
110136 : }
110137 : else
110138 : {
110139 0 : std::cout << "SgUnsignedLongLongIntVal :: " << std::flush;
110140 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
110141 0 : std::cout << " not valid " << std::endl;
110142 : }
110143 : }
110144 :
110145 :
110146 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110147 :
110148 0 : }
110149 :
110150 :
110151 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
110152 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
110153 : bool
110154 0 : SgUnsignedLongLongIntVal::isInMemoryPool ()
110155 : {
110156 0 : typedef unsigned char* TestType;
110157 :
110158 0 : bool found = false;
110159 :
110160 0 : ROSE_ASSERT(this != NULL);
110161 :
110162 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
110163 :
110164 0 : TestType tested = (TestType) ( this ) ;
110165 :
110166 0 : std::vector < unsigned char* > :: const_iterator block = SgUnsignedLongLongIntVal::pools.begin();
110167 :
110168 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
110169 : // while (found == false && block < Memory_Block_List.end())
110170 0 : while ( (found == false) && (block != SgUnsignedLongLongIntVal::pools.end()) )
110171 : {
110172 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUnsignedLongLongIntVal::pool_size * sizeof(SgUnsignedLongLongIntVal) ) ) ;
110173 0 : ++block;
110174 : }
110175 :
110176 : // Special handling for static data
110177 :
110178 :
110179 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
110180 0 : ROSE_ASSERT(found == true);
110181 :
110182 0 : return found;
110183 : }
110184 : /* #line 110185 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
110185 :
110186 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
110187 :
110188 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110189 :
110190 : /* #line 110191 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
110191 :
110192 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110193 :
110194 : void
110195 0 : SgUnsignedLongVal::checkDataMemberPointersIfInMemoryPool()
110196 : {
110197 : // ------------ checking pointers of SgUnsignedLongVal -------------------
110198 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
110199 :
110200 0 : if ( p_originalExpressionTree != NULL )
110201 : {
110202 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110203 : {
110204 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
110205 : {
110206 0 : std::cout << "SgUnsignedLongVal :: ";
110207 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
110208 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
110209 : }
110210 : }
110211 : else
110212 : {
110213 0 : std::cout << "SgUnsignedLongVal :: " << std::flush;
110214 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
110215 0 : std::cout << " not valid " << std::endl;
110216 : }
110217 : }
110218 :
110219 0 : if ( p_operatorPosition != NULL )
110220 : {
110221 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110222 : {
110223 0 : if ( p_operatorPosition->isInMemoryPool() == false )
110224 : {
110225 0 : std::cout << "SgUnsignedLongVal :: ";
110226 0 : std::cout << " p_operatorPosition is not in memory pool of ";
110227 0 : std::cout << p_operatorPosition->class_name() << std::endl;
110228 : }
110229 : }
110230 : else
110231 : {
110232 0 : std::cout << "SgUnsignedLongVal :: " << std::flush;
110233 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
110234 0 : std::cout << " not valid " << std::endl;
110235 : }
110236 : }
110237 :
110238 0 : if ( p_startOfConstruct != NULL )
110239 : {
110240 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110241 : {
110242 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
110243 : {
110244 0 : std::cout << "SgUnsignedLongVal :: ";
110245 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
110246 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
110247 : }
110248 : }
110249 : else
110250 : {
110251 0 : std::cout << "SgUnsignedLongVal :: " << std::flush;
110252 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
110253 0 : std::cout << " not valid " << std::endl;
110254 : }
110255 : }
110256 :
110257 0 : if ( p_endOfConstruct != NULL )
110258 : {
110259 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110260 : {
110261 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
110262 : {
110263 0 : std::cout << "SgUnsignedLongVal :: ";
110264 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
110265 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
110266 : }
110267 : }
110268 : else
110269 : {
110270 0 : std::cout << "SgUnsignedLongVal :: " << std::flush;
110271 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
110272 0 : std::cout << " not valid " << std::endl;
110273 : }
110274 : }
110275 :
110276 0 : if ( p_parent != NULL )
110277 : {
110278 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110279 : {
110280 0 : if ( p_parent->isInMemoryPool() == false )
110281 : {
110282 0 : std::cout << "SgUnsignedLongVal :: ";
110283 0 : std::cout << " p_parent is not in memory pool of ";
110284 0 : std::cout << p_parent->class_name() << std::endl;
110285 : }
110286 : }
110287 : else
110288 : {
110289 0 : std::cout << "SgUnsignedLongVal :: " << std::flush;
110290 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
110291 0 : std::cout << " not valid " << std::endl;
110292 : }
110293 : }
110294 :
110295 :
110296 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110297 :
110298 0 : }
110299 :
110300 :
110301 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
110302 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
110303 : bool
110304 0 : SgUnsignedLongVal::isInMemoryPool ()
110305 : {
110306 0 : typedef unsigned char* TestType;
110307 :
110308 0 : bool found = false;
110309 :
110310 0 : ROSE_ASSERT(this != NULL);
110311 :
110312 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
110313 :
110314 0 : TestType tested = (TestType) ( this ) ;
110315 :
110316 0 : std::vector < unsigned char* > :: const_iterator block = SgUnsignedLongVal::pools.begin();
110317 :
110318 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
110319 : // while (found == false && block < Memory_Block_List.end())
110320 0 : while ( (found == false) && (block != SgUnsignedLongVal::pools.end()) )
110321 : {
110322 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUnsignedLongVal::pool_size * sizeof(SgUnsignedLongVal) ) ) ;
110323 0 : ++block;
110324 : }
110325 :
110326 : // Special handling for static data
110327 :
110328 :
110329 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
110330 0 : ROSE_ASSERT(found == true);
110331 :
110332 0 : return found;
110333 : }
110334 : /* #line 110335 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
110335 :
110336 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
110337 :
110338 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110339 :
110340 : /* #line 110341 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
110341 :
110342 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110343 :
110344 : void
110345 0 : SgFloatVal::checkDataMemberPointersIfInMemoryPool()
110346 : {
110347 : // ------------ checking pointers of SgFloatVal -------------------
110348 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
110349 :
110350 0 : if ( p_originalExpressionTree != NULL )
110351 : {
110352 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110353 : {
110354 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
110355 : {
110356 0 : std::cout << "SgFloatVal :: ";
110357 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
110358 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
110359 : }
110360 : }
110361 : else
110362 : {
110363 0 : std::cout << "SgFloatVal :: " << std::flush;
110364 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
110365 0 : std::cout << " not valid " << std::endl;
110366 : }
110367 : }
110368 :
110369 0 : if ( p_operatorPosition != NULL )
110370 : {
110371 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110372 : {
110373 0 : if ( p_operatorPosition->isInMemoryPool() == false )
110374 : {
110375 0 : std::cout << "SgFloatVal :: ";
110376 0 : std::cout << " p_operatorPosition is not in memory pool of ";
110377 0 : std::cout << p_operatorPosition->class_name() << std::endl;
110378 : }
110379 : }
110380 : else
110381 : {
110382 0 : std::cout << "SgFloatVal :: " << std::flush;
110383 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
110384 0 : std::cout << " not valid " << std::endl;
110385 : }
110386 : }
110387 :
110388 0 : if ( p_startOfConstruct != NULL )
110389 : {
110390 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110391 : {
110392 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
110393 : {
110394 0 : std::cout << "SgFloatVal :: ";
110395 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
110396 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
110397 : }
110398 : }
110399 : else
110400 : {
110401 0 : std::cout << "SgFloatVal :: " << std::flush;
110402 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
110403 0 : std::cout << " not valid " << std::endl;
110404 : }
110405 : }
110406 :
110407 0 : if ( p_endOfConstruct != NULL )
110408 : {
110409 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110410 : {
110411 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
110412 : {
110413 0 : std::cout << "SgFloatVal :: ";
110414 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
110415 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
110416 : }
110417 : }
110418 : else
110419 : {
110420 0 : std::cout << "SgFloatVal :: " << std::flush;
110421 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
110422 0 : std::cout << " not valid " << std::endl;
110423 : }
110424 : }
110425 :
110426 0 : if ( p_parent != NULL )
110427 : {
110428 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110429 : {
110430 0 : if ( p_parent->isInMemoryPool() == false )
110431 : {
110432 0 : std::cout << "SgFloatVal :: ";
110433 0 : std::cout << " p_parent is not in memory pool of ";
110434 0 : std::cout << p_parent->class_name() << std::endl;
110435 : }
110436 : }
110437 : else
110438 : {
110439 0 : std::cout << "SgFloatVal :: " << std::flush;
110440 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
110441 0 : std::cout << " not valid " << std::endl;
110442 : }
110443 : }
110444 :
110445 :
110446 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110447 :
110448 0 : }
110449 :
110450 :
110451 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
110452 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
110453 : bool
110454 0 : SgFloatVal::isInMemoryPool ()
110455 : {
110456 0 : typedef unsigned char* TestType;
110457 :
110458 0 : bool found = false;
110459 :
110460 0 : ROSE_ASSERT(this != NULL);
110461 :
110462 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
110463 :
110464 0 : TestType tested = (TestType) ( this ) ;
110465 :
110466 0 : std::vector < unsigned char* > :: const_iterator block = SgFloatVal::pools.begin();
110467 :
110468 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
110469 : // while (found == false && block < Memory_Block_List.end())
110470 0 : while ( (found == false) && (block != SgFloatVal::pools.end()) )
110471 : {
110472 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFloatVal::pool_size * sizeof(SgFloatVal) ) ) ;
110473 0 : ++block;
110474 : }
110475 :
110476 : // Special handling for static data
110477 :
110478 :
110479 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
110480 0 : ROSE_ASSERT(found == true);
110481 :
110482 0 : return found;
110483 : }
110484 : /* #line 110485 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
110485 :
110486 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
110487 :
110488 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110489 :
110490 : /* #line 110491 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
110491 :
110492 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110493 :
110494 : void
110495 0 : SgDoubleVal::checkDataMemberPointersIfInMemoryPool()
110496 : {
110497 : // ------------ checking pointers of SgDoubleVal -------------------
110498 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
110499 :
110500 0 : if ( p_originalExpressionTree != NULL )
110501 : {
110502 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110503 : {
110504 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
110505 : {
110506 0 : std::cout << "SgDoubleVal :: ";
110507 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
110508 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
110509 : }
110510 : }
110511 : else
110512 : {
110513 0 : std::cout << "SgDoubleVal :: " << std::flush;
110514 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
110515 0 : std::cout << " not valid " << std::endl;
110516 : }
110517 : }
110518 :
110519 0 : if ( p_operatorPosition != NULL )
110520 : {
110521 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110522 : {
110523 0 : if ( p_operatorPosition->isInMemoryPool() == false )
110524 : {
110525 0 : std::cout << "SgDoubleVal :: ";
110526 0 : std::cout << " p_operatorPosition is not in memory pool of ";
110527 0 : std::cout << p_operatorPosition->class_name() << std::endl;
110528 : }
110529 : }
110530 : else
110531 : {
110532 0 : std::cout << "SgDoubleVal :: " << std::flush;
110533 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
110534 0 : std::cout << " not valid " << std::endl;
110535 : }
110536 : }
110537 :
110538 0 : if ( p_startOfConstruct != NULL )
110539 : {
110540 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110541 : {
110542 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
110543 : {
110544 0 : std::cout << "SgDoubleVal :: ";
110545 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
110546 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
110547 : }
110548 : }
110549 : else
110550 : {
110551 0 : std::cout << "SgDoubleVal :: " << std::flush;
110552 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
110553 0 : std::cout << " not valid " << std::endl;
110554 : }
110555 : }
110556 :
110557 0 : if ( p_endOfConstruct != NULL )
110558 : {
110559 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110560 : {
110561 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
110562 : {
110563 0 : std::cout << "SgDoubleVal :: ";
110564 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
110565 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
110566 : }
110567 : }
110568 : else
110569 : {
110570 0 : std::cout << "SgDoubleVal :: " << std::flush;
110571 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
110572 0 : std::cout << " not valid " << std::endl;
110573 : }
110574 : }
110575 :
110576 0 : if ( p_parent != NULL )
110577 : {
110578 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110579 : {
110580 0 : if ( p_parent->isInMemoryPool() == false )
110581 : {
110582 0 : std::cout << "SgDoubleVal :: ";
110583 0 : std::cout << " p_parent is not in memory pool of ";
110584 0 : std::cout << p_parent->class_name() << std::endl;
110585 : }
110586 : }
110587 : else
110588 : {
110589 0 : std::cout << "SgDoubleVal :: " << std::flush;
110590 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
110591 0 : std::cout << " not valid " << std::endl;
110592 : }
110593 : }
110594 :
110595 :
110596 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110597 :
110598 0 : }
110599 :
110600 :
110601 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
110602 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
110603 : bool
110604 0 : SgDoubleVal::isInMemoryPool ()
110605 : {
110606 0 : typedef unsigned char* TestType;
110607 :
110608 0 : bool found = false;
110609 :
110610 0 : ROSE_ASSERT(this != NULL);
110611 :
110612 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
110613 :
110614 0 : TestType tested = (TestType) ( this ) ;
110615 :
110616 0 : std::vector < unsigned char* > :: const_iterator block = SgDoubleVal::pools.begin();
110617 :
110618 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
110619 : // while (found == false && block < Memory_Block_List.end())
110620 0 : while ( (found == false) && (block != SgDoubleVal::pools.end()) )
110621 : {
110622 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDoubleVal::pool_size * sizeof(SgDoubleVal) ) ) ;
110623 0 : ++block;
110624 : }
110625 :
110626 : // Special handling for static data
110627 :
110628 :
110629 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
110630 0 : ROSE_ASSERT(found == true);
110631 :
110632 0 : return found;
110633 : }
110634 : /* #line 110635 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
110635 :
110636 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
110637 :
110638 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110639 :
110640 : /* #line 110641 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
110641 :
110642 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110643 :
110644 : void
110645 0 : SgLongDoubleVal::checkDataMemberPointersIfInMemoryPool()
110646 : {
110647 : // ------------ checking pointers of SgLongDoubleVal -------------------
110648 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
110649 :
110650 0 : if ( p_originalExpressionTree != NULL )
110651 : {
110652 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110653 : {
110654 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
110655 : {
110656 0 : std::cout << "SgLongDoubleVal :: ";
110657 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
110658 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
110659 : }
110660 : }
110661 : else
110662 : {
110663 0 : std::cout << "SgLongDoubleVal :: " << std::flush;
110664 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
110665 0 : std::cout << " not valid " << std::endl;
110666 : }
110667 : }
110668 :
110669 0 : if ( p_operatorPosition != NULL )
110670 : {
110671 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110672 : {
110673 0 : if ( p_operatorPosition->isInMemoryPool() == false )
110674 : {
110675 0 : std::cout << "SgLongDoubleVal :: ";
110676 0 : std::cout << " p_operatorPosition is not in memory pool of ";
110677 0 : std::cout << p_operatorPosition->class_name() << std::endl;
110678 : }
110679 : }
110680 : else
110681 : {
110682 0 : std::cout << "SgLongDoubleVal :: " << std::flush;
110683 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
110684 0 : std::cout << " not valid " << std::endl;
110685 : }
110686 : }
110687 :
110688 0 : if ( p_startOfConstruct != NULL )
110689 : {
110690 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110691 : {
110692 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
110693 : {
110694 0 : std::cout << "SgLongDoubleVal :: ";
110695 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
110696 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
110697 : }
110698 : }
110699 : else
110700 : {
110701 0 : std::cout << "SgLongDoubleVal :: " << std::flush;
110702 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
110703 0 : std::cout << " not valid " << std::endl;
110704 : }
110705 : }
110706 :
110707 0 : if ( p_endOfConstruct != NULL )
110708 : {
110709 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110710 : {
110711 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
110712 : {
110713 0 : std::cout << "SgLongDoubleVal :: ";
110714 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
110715 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
110716 : }
110717 : }
110718 : else
110719 : {
110720 0 : std::cout << "SgLongDoubleVal :: " << std::flush;
110721 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
110722 0 : std::cout << " not valid " << std::endl;
110723 : }
110724 : }
110725 :
110726 0 : if ( p_parent != NULL )
110727 : {
110728 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110729 : {
110730 0 : if ( p_parent->isInMemoryPool() == false )
110731 : {
110732 0 : std::cout << "SgLongDoubleVal :: ";
110733 0 : std::cout << " p_parent is not in memory pool of ";
110734 0 : std::cout << p_parent->class_name() << std::endl;
110735 : }
110736 : }
110737 : else
110738 : {
110739 0 : std::cout << "SgLongDoubleVal :: " << std::flush;
110740 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
110741 0 : std::cout << " not valid " << std::endl;
110742 : }
110743 : }
110744 :
110745 :
110746 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110747 :
110748 0 : }
110749 :
110750 :
110751 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
110752 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
110753 : bool
110754 0 : SgLongDoubleVal::isInMemoryPool ()
110755 : {
110756 0 : typedef unsigned char* TestType;
110757 :
110758 0 : bool found = false;
110759 :
110760 0 : ROSE_ASSERT(this != NULL);
110761 :
110762 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
110763 :
110764 0 : TestType tested = (TestType) ( this ) ;
110765 :
110766 0 : std::vector < unsigned char* > :: const_iterator block = SgLongDoubleVal::pools.begin();
110767 :
110768 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
110769 : // while (found == false && block < Memory_Block_List.end())
110770 0 : while ( (found == false) && (block != SgLongDoubleVal::pools.end()) )
110771 : {
110772 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLongDoubleVal::pool_size * sizeof(SgLongDoubleVal) ) ) ;
110773 0 : ++block;
110774 : }
110775 :
110776 : // Special handling for static data
110777 :
110778 :
110779 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
110780 0 : ROSE_ASSERT(found == true);
110781 :
110782 0 : return found;
110783 : }
110784 : /* #line 110785 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
110785 :
110786 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
110787 :
110788 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110789 :
110790 : /* #line 110791 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
110791 :
110792 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110793 :
110794 : void
110795 0 : SgComplexVal::checkDataMemberPointersIfInMemoryPool()
110796 : {
110797 : // ------------ checking pointers of SgComplexVal -------------------
110798 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
110799 :
110800 0 : if ( p_real_value != NULL )
110801 : {
110802 0 : if ( p_real_value->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110803 : {
110804 0 : if ( p_real_value->isInMemoryPool() == false )
110805 : {
110806 0 : std::cout << "SgComplexVal :: ";
110807 0 : std::cout << " p_real_value is not in memory pool of ";
110808 0 : std::cout << p_real_value->class_name() << std::endl;
110809 : }
110810 : }
110811 : else
110812 : {
110813 0 : std::cout << "SgComplexVal :: " << std::flush;
110814 0 : std::cout << "SgValueExp* p_real_value = " << p_real_value << " --> " << std::flush;
110815 0 : std::cout << " not valid " << std::endl;
110816 : }
110817 : }
110818 :
110819 0 : if ( p_imaginary_value != NULL )
110820 : {
110821 0 : if ( p_imaginary_value->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110822 : {
110823 0 : if ( p_imaginary_value->isInMemoryPool() == false )
110824 : {
110825 0 : std::cout << "SgComplexVal :: ";
110826 0 : std::cout << " p_imaginary_value is not in memory pool of ";
110827 0 : std::cout << p_imaginary_value->class_name() << std::endl;
110828 : }
110829 : }
110830 : else
110831 : {
110832 0 : std::cout << "SgComplexVal :: " << std::flush;
110833 0 : std::cout << "SgValueExp* p_imaginary_value = " << p_imaginary_value << " --> " << std::flush;
110834 0 : std::cout << " not valid " << std::endl;
110835 : }
110836 : }
110837 :
110838 0 : if ( p_precisionType != NULL )
110839 : {
110840 0 : if ( p_precisionType->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110841 : {
110842 0 : if ( p_precisionType->isInMemoryPool() == false )
110843 : {
110844 0 : std::cout << "SgComplexVal :: ";
110845 0 : std::cout << " p_precisionType is not in memory pool of ";
110846 0 : std::cout << p_precisionType->class_name() << std::endl;
110847 : }
110848 : }
110849 : else
110850 : {
110851 0 : std::cout << "SgComplexVal :: " << std::flush;
110852 0 : std::cout << "SgType* p_precisionType = " << p_precisionType << " --> " << std::flush;
110853 0 : std::cout << " not valid " << std::endl;
110854 : }
110855 : }
110856 :
110857 0 : if ( p_originalExpressionTree != NULL )
110858 : {
110859 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110860 : {
110861 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
110862 : {
110863 0 : std::cout << "SgComplexVal :: ";
110864 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
110865 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
110866 : }
110867 : }
110868 : else
110869 : {
110870 0 : std::cout << "SgComplexVal :: " << std::flush;
110871 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
110872 0 : std::cout << " not valid " << std::endl;
110873 : }
110874 : }
110875 :
110876 0 : if ( p_operatorPosition != NULL )
110877 : {
110878 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110879 : {
110880 0 : if ( p_operatorPosition->isInMemoryPool() == false )
110881 : {
110882 0 : std::cout << "SgComplexVal :: ";
110883 0 : std::cout << " p_operatorPosition is not in memory pool of ";
110884 0 : std::cout << p_operatorPosition->class_name() << std::endl;
110885 : }
110886 : }
110887 : else
110888 : {
110889 0 : std::cout << "SgComplexVal :: " << std::flush;
110890 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
110891 0 : std::cout << " not valid " << std::endl;
110892 : }
110893 : }
110894 :
110895 0 : if ( p_startOfConstruct != NULL )
110896 : {
110897 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110898 : {
110899 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
110900 : {
110901 0 : std::cout << "SgComplexVal :: ";
110902 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
110903 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
110904 : }
110905 : }
110906 : else
110907 : {
110908 0 : std::cout << "SgComplexVal :: " << std::flush;
110909 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
110910 0 : std::cout << " not valid " << std::endl;
110911 : }
110912 : }
110913 :
110914 0 : if ( p_endOfConstruct != NULL )
110915 : {
110916 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110917 : {
110918 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
110919 : {
110920 0 : std::cout << "SgComplexVal :: ";
110921 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
110922 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
110923 : }
110924 : }
110925 : else
110926 : {
110927 0 : std::cout << "SgComplexVal :: " << std::flush;
110928 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
110929 0 : std::cout << " not valid " << std::endl;
110930 : }
110931 : }
110932 :
110933 0 : if ( p_parent != NULL )
110934 : {
110935 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
110936 : {
110937 0 : if ( p_parent->isInMemoryPool() == false )
110938 : {
110939 0 : std::cout << "SgComplexVal :: ";
110940 0 : std::cout << " p_parent is not in memory pool of ";
110941 0 : std::cout << p_parent->class_name() << std::endl;
110942 : }
110943 : }
110944 : else
110945 : {
110946 0 : std::cout << "SgComplexVal :: " << std::flush;
110947 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
110948 0 : std::cout << " not valid " << std::endl;
110949 : }
110950 : }
110951 :
110952 :
110953 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110954 :
110955 0 : }
110956 :
110957 :
110958 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
110959 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
110960 : bool
110961 0 : SgComplexVal::isInMemoryPool ()
110962 : {
110963 0 : typedef unsigned char* TestType;
110964 :
110965 0 : bool found = false;
110966 :
110967 0 : ROSE_ASSERT(this != NULL);
110968 :
110969 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
110970 :
110971 0 : TestType tested = (TestType) ( this ) ;
110972 :
110973 0 : std::vector < unsigned char* > :: const_iterator block = SgComplexVal::pools.begin();
110974 :
110975 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
110976 : // while (found == false && block < Memory_Block_List.end())
110977 0 : while ( (found == false) && (block != SgComplexVal::pools.end()) )
110978 : {
110979 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgComplexVal::pool_size * sizeof(SgComplexVal) ) ) ;
110980 0 : ++block;
110981 : }
110982 :
110983 : // Special handling for static data
110984 :
110985 :
110986 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
110987 0 : ROSE_ASSERT(found == true);
110988 :
110989 0 : return found;
110990 : }
110991 : /* #line 110992 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
110992 :
110993 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
110994 :
110995 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
110996 :
110997 : /* #line 110998 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
110998 :
110999 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111000 :
111001 : void
111002 0 : SgUpcThreads::checkDataMemberPointersIfInMemoryPool()
111003 : {
111004 : // ------------ checking pointers of SgUpcThreads -------------------
111005 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
111006 :
111007 0 : if ( p_originalExpressionTree != NULL )
111008 : {
111009 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111010 : {
111011 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
111012 : {
111013 0 : std::cout << "SgUpcThreads :: ";
111014 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
111015 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
111016 : }
111017 : }
111018 : else
111019 : {
111020 0 : std::cout << "SgUpcThreads :: " << std::flush;
111021 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
111022 0 : std::cout << " not valid " << std::endl;
111023 : }
111024 : }
111025 :
111026 0 : if ( p_operatorPosition != NULL )
111027 : {
111028 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111029 : {
111030 0 : if ( p_operatorPosition->isInMemoryPool() == false )
111031 : {
111032 0 : std::cout << "SgUpcThreads :: ";
111033 0 : std::cout << " p_operatorPosition is not in memory pool of ";
111034 0 : std::cout << p_operatorPosition->class_name() << std::endl;
111035 : }
111036 : }
111037 : else
111038 : {
111039 0 : std::cout << "SgUpcThreads :: " << std::flush;
111040 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
111041 0 : std::cout << " not valid " << std::endl;
111042 : }
111043 : }
111044 :
111045 0 : if ( p_startOfConstruct != NULL )
111046 : {
111047 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111048 : {
111049 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
111050 : {
111051 0 : std::cout << "SgUpcThreads :: ";
111052 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
111053 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
111054 : }
111055 : }
111056 : else
111057 : {
111058 0 : std::cout << "SgUpcThreads :: " << std::flush;
111059 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
111060 0 : std::cout << " not valid " << std::endl;
111061 : }
111062 : }
111063 :
111064 0 : if ( p_endOfConstruct != NULL )
111065 : {
111066 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111067 : {
111068 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
111069 : {
111070 0 : std::cout << "SgUpcThreads :: ";
111071 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
111072 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
111073 : }
111074 : }
111075 : else
111076 : {
111077 0 : std::cout << "SgUpcThreads :: " << std::flush;
111078 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
111079 0 : std::cout << " not valid " << std::endl;
111080 : }
111081 : }
111082 :
111083 0 : if ( p_parent != NULL )
111084 : {
111085 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111086 : {
111087 0 : if ( p_parent->isInMemoryPool() == false )
111088 : {
111089 0 : std::cout << "SgUpcThreads :: ";
111090 0 : std::cout << " p_parent is not in memory pool of ";
111091 0 : std::cout << p_parent->class_name() << std::endl;
111092 : }
111093 : }
111094 : else
111095 : {
111096 0 : std::cout << "SgUpcThreads :: " << std::flush;
111097 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
111098 0 : std::cout << " not valid " << std::endl;
111099 : }
111100 : }
111101 :
111102 :
111103 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111104 :
111105 0 : }
111106 :
111107 :
111108 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
111109 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
111110 : bool
111111 0 : SgUpcThreads::isInMemoryPool ()
111112 : {
111113 0 : typedef unsigned char* TestType;
111114 :
111115 0 : bool found = false;
111116 :
111117 0 : ROSE_ASSERT(this != NULL);
111118 :
111119 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
111120 :
111121 0 : TestType tested = (TestType) ( this ) ;
111122 :
111123 0 : std::vector < unsigned char* > :: const_iterator block = SgUpcThreads::pools.begin();
111124 :
111125 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
111126 : // while (found == false && block < Memory_Block_List.end())
111127 0 : while ( (found == false) && (block != SgUpcThreads::pools.end()) )
111128 : {
111129 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpcThreads::pool_size * sizeof(SgUpcThreads) ) ) ;
111130 0 : ++block;
111131 : }
111132 :
111133 : // Special handling for static data
111134 :
111135 :
111136 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
111137 0 : ROSE_ASSERT(found == true);
111138 :
111139 0 : return found;
111140 : }
111141 : /* #line 111142 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
111142 :
111143 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
111144 :
111145 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111146 :
111147 : /* #line 111148 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
111148 :
111149 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111150 :
111151 : void
111152 0 : SgUpcMythread::checkDataMemberPointersIfInMemoryPool()
111153 : {
111154 : // ------------ checking pointers of SgUpcMythread -------------------
111155 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
111156 :
111157 0 : if ( p_originalExpressionTree != NULL )
111158 : {
111159 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111160 : {
111161 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
111162 : {
111163 0 : std::cout << "SgUpcMythread :: ";
111164 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
111165 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
111166 : }
111167 : }
111168 : else
111169 : {
111170 0 : std::cout << "SgUpcMythread :: " << std::flush;
111171 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
111172 0 : std::cout << " not valid " << std::endl;
111173 : }
111174 : }
111175 :
111176 0 : if ( p_operatorPosition != NULL )
111177 : {
111178 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111179 : {
111180 0 : if ( p_operatorPosition->isInMemoryPool() == false )
111181 : {
111182 0 : std::cout << "SgUpcMythread :: ";
111183 0 : std::cout << " p_operatorPosition is not in memory pool of ";
111184 0 : std::cout << p_operatorPosition->class_name() << std::endl;
111185 : }
111186 : }
111187 : else
111188 : {
111189 0 : std::cout << "SgUpcMythread :: " << std::flush;
111190 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
111191 0 : std::cout << " not valid " << std::endl;
111192 : }
111193 : }
111194 :
111195 0 : if ( p_startOfConstruct != NULL )
111196 : {
111197 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111198 : {
111199 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
111200 : {
111201 0 : std::cout << "SgUpcMythread :: ";
111202 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
111203 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
111204 : }
111205 : }
111206 : else
111207 : {
111208 0 : std::cout << "SgUpcMythread :: " << std::flush;
111209 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
111210 0 : std::cout << " not valid " << std::endl;
111211 : }
111212 : }
111213 :
111214 0 : if ( p_endOfConstruct != NULL )
111215 : {
111216 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111217 : {
111218 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
111219 : {
111220 0 : std::cout << "SgUpcMythread :: ";
111221 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
111222 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
111223 : }
111224 : }
111225 : else
111226 : {
111227 0 : std::cout << "SgUpcMythread :: " << std::flush;
111228 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
111229 0 : std::cout << " not valid " << std::endl;
111230 : }
111231 : }
111232 :
111233 0 : if ( p_parent != NULL )
111234 : {
111235 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111236 : {
111237 0 : if ( p_parent->isInMemoryPool() == false )
111238 : {
111239 0 : std::cout << "SgUpcMythread :: ";
111240 0 : std::cout << " p_parent is not in memory pool of ";
111241 0 : std::cout << p_parent->class_name() << std::endl;
111242 : }
111243 : }
111244 : else
111245 : {
111246 0 : std::cout << "SgUpcMythread :: " << std::flush;
111247 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
111248 0 : std::cout << " not valid " << std::endl;
111249 : }
111250 : }
111251 :
111252 :
111253 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111254 :
111255 0 : }
111256 :
111257 :
111258 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
111259 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
111260 : bool
111261 0 : SgUpcMythread::isInMemoryPool ()
111262 : {
111263 0 : typedef unsigned char* TestType;
111264 :
111265 0 : bool found = false;
111266 :
111267 0 : ROSE_ASSERT(this != NULL);
111268 :
111269 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
111270 :
111271 0 : TestType tested = (TestType) ( this ) ;
111272 :
111273 0 : std::vector < unsigned char* > :: const_iterator block = SgUpcMythread::pools.begin();
111274 :
111275 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
111276 : // while (found == false && block < Memory_Block_List.end())
111277 0 : while ( (found == false) && (block != SgUpcMythread::pools.end()) )
111278 : {
111279 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpcMythread::pool_size * sizeof(SgUpcMythread) ) ) ;
111280 0 : ++block;
111281 : }
111282 :
111283 : // Special handling for static data
111284 :
111285 :
111286 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
111287 0 : ROSE_ASSERT(found == true);
111288 :
111289 0 : return found;
111290 : }
111291 : /* #line 111292 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
111292 :
111293 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
111294 :
111295 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111296 :
111297 : /* #line 111298 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
111298 :
111299 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111300 :
111301 : void
111302 0 : SgTemplateParameterVal::checkDataMemberPointersIfInMemoryPool()
111303 : {
111304 : // ------------ checking pointers of SgTemplateParameterVal -------------------
111305 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
111306 :
111307 0 : if ( p_valueType != NULL )
111308 : {
111309 0 : if ( p_valueType->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111310 : {
111311 0 : if ( p_valueType->isInMemoryPool() == false )
111312 : {
111313 0 : std::cout << "SgTemplateParameterVal :: ";
111314 0 : std::cout << " p_valueType is not in memory pool of ";
111315 0 : std::cout << p_valueType->class_name() << std::endl;
111316 : }
111317 : }
111318 : else
111319 : {
111320 0 : std::cout << "SgTemplateParameterVal :: " << std::flush;
111321 0 : std::cout << "SgType* p_valueType = " << p_valueType << " --> " << std::flush;
111322 0 : std::cout << " not valid " << std::endl;
111323 : }
111324 : }
111325 :
111326 0 : if ( p_originalExpressionTree != NULL )
111327 : {
111328 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111329 : {
111330 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
111331 : {
111332 0 : std::cout << "SgTemplateParameterVal :: ";
111333 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
111334 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
111335 : }
111336 : }
111337 : else
111338 : {
111339 0 : std::cout << "SgTemplateParameterVal :: " << std::flush;
111340 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
111341 0 : std::cout << " not valid " << std::endl;
111342 : }
111343 : }
111344 :
111345 0 : if ( p_operatorPosition != NULL )
111346 : {
111347 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111348 : {
111349 0 : if ( p_operatorPosition->isInMemoryPool() == false )
111350 : {
111351 0 : std::cout << "SgTemplateParameterVal :: ";
111352 0 : std::cout << " p_operatorPosition is not in memory pool of ";
111353 0 : std::cout << p_operatorPosition->class_name() << std::endl;
111354 : }
111355 : }
111356 : else
111357 : {
111358 0 : std::cout << "SgTemplateParameterVal :: " << std::flush;
111359 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
111360 0 : std::cout << " not valid " << std::endl;
111361 : }
111362 : }
111363 :
111364 0 : if ( p_startOfConstruct != NULL )
111365 : {
111366 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111367 : {
111368 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
111369 : {
111370 0 : std::cout << "SgTemplateParameterVal :: ";
111371 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
111372 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
111373 : }
111374 : }
111375 : else
111376 : {
111377 0 : std::cout << "SgTemplateParameterVal :: " << std::flush;
111378 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
111379 0 : std::cout << " not valid " << std::endl;
111380 : }
111381 : }
111382 :
111383 0 : if ( p_endOfConstruct != NULL )
111384 : {
111385 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111386 : {
111387 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
111388 : {
111389 0 : std::cout << "SgTemplateParameterVal :: ";
111390 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
111391 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
111392 : }
111393 : }
111394 : else
111395 : {
111396 0 : std::cout << "SgTemplateParameterVal :: " << std::flush;
111397 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
111398 0 : std::cout << " not valid " << std::endl;
111399 : }
111400 : }
111401 :
111402 0 : if ( p_parent != NULL )
111403 : {
111404 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111405 : {
111406 0 : if ( p_parent->isInMemoryPool() == false )
111407 : {
111408 0 : std::cout << "SgTemplateParameterVal :: ";
111409 0 : std::cout << " p_parent is not in memory pool of ";
111410 0 : std::cout << p_parent->class_name() << std::endl;
111411 : }
111412 : }
111413 : else
111414 : {
111415 0 : std::cout << "SgTemplateParameterVal :: " << std::flush;
111416 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
111417 0 : std::cout << " not valid " << std::endl;
111418 : }
111419 : }
111420 :
111421 :
111422 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111423 :
111424 0 : }
111425 :
111426 :
111427 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
111428 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
111429 : bool
111430 0 : SgTemplateParameterVal::isInMemoryPool ()
111431 : {
111432 0 : typedef unsigned char* TestType;
111433 :
111434 0 : bool found = false;
111435 :
111436 0 : ROSE_ASSERT(this != NULL);
111437 :
111438 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
111439 :
111440 0 : TestType tested = (TestType) ( this ) ;
111441 :
111442 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateParameterVal::pools.begin();
111443 :
111444 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
111445 : // while (found == false && block < Memory_Block_List.end())
111446 0 : while ( (found == false) && (block != SgTemplateParameterVal::pools.end()) )
111447 : {
111448 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateParameterVal::pool_size * sizeof(SgTemplateParameterVal) ) ) ;
111449 0 : ++block;
111450 : }
111451 :
111452 : // Special handling for static data
111453 :
111454 :
111455 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
111456 0 : ROSE_ASSERT(found == true);
111457 :
111458 0 : return found;
111459 : }
111460 : /* #line 111461 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
111461 :
111462 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
111463 :
111464 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111465 :
111466 : /* #line 111467 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
111467 :
111468 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111469 :
111470 : void
111471 0 : SgNullptrValExp::checkDataMemberPointersIfInMemoryPool()
111472 : {
111473 : // ------------ checking pointers of SgNullptrValExp -------------------
111474 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
111475 :
111476 0 : if ( p_originalExpressionTree != NULL )
111477 : {
111478 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111479 : {
111480 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
111481 : {
111482 0 : std::cout << "SgNullptrValExp :: ";
111483 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
111484 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
111485 : }
111486 : }
111487 : else
111488 : {
111489 0 : std::cout << "SgNullptrValExp :: " << std::flush;
111490 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
111491 0 : std::cout << " not valid " << std::endl;
111492 : }
111493 : }
111494 :
111495 0 : if ( p_operatorPosition != NULL )
111496 : {
111497 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111498 : {
111499 0 : if ( p_operatorPosition->isInMemoryPool() == false )
111500 : {
111501 0 : std::cout << "SgNullptrValExp :: ";
111502 0 : std::cout << " p_operatorPosition is not in memory pool of ";
111503 0 : std::cout << p_operatorPosition->class_name() << std::endl;
111504 : }
111505 : }
111506 : else
111507 : {
111508 0 : std::cout << "SgNullptrValExp :: " << std::flush;
111509 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
111510 0 : std::cout << " not valid " << std::endl;
111511 : }
111512 : }
111513 :
111514 0 : if ( p_startOfConstruct != NULL )
111515 : {
111516 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111517 : {
111518 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
111519 : {
111520 0 : std::cout << "SgNullptrValExp :: ";
111521 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
111522 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
111523 : }
111524 : }
111525 : else
111526 : {
111527 0 : std::cout << "SgNullptrValExp :: " << std::flush;
111528 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
111529 0 : std::cout << " not valid " << std::endl;
111530 : }
111531 : }
111532 :
111533 0 : if ( p_endOfConstruct != NULL )
111534 : {
111535 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111536 : {
111537 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
111538 : {
111539 0 : std::cout << "SgNullptrValExp :: ";
111540 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
111541 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
111542 : }
111543 : }
111544 : else
111545 : {
111546 0 : std::cout << "SgNullptrValExp :: " << std::flush;
111547 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
111548 0 : std::cout << " not valid " << std::endl;
111549 : }
111550 : }
111551 :
111552 0 : if ( p_parent != NULL )
111553 : {
111554 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111555 : {
111556 0 : if ( p_parent->isInMemoryPool() == false )
111557 : {
111558 0 : std::cout << "SgNullptrValExp :: ";
111559 0 : std::cout << " p_parent is not in memory pool of ";
111560 0 : std::cout << p_parent->class_name() << std::endl;
111561 : }
111562 : }
111563 : else
111564 : {
111565 0 : std::cout << "SgNullptrValExp :: " << std::flush;
111566 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
111567 0 : std::cout << " not valid " << std::endl;
111568 : }
111569 : }
111570 :
111571 :
111572 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111573 :
111574 0 : }
111575 :
111576 :
111577 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
111578 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
111579 : bool
111580 0 : SgNullptrValExp::isInMemoryPool ()
111581 : {
111582 0 : typedef unsigned char* TestType;
111583 :
111584 0 : bool found = false;
111585 :
111586 0 : ROSE_ASSERT(this != NULL);
111587 :
111588 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
111589 :
111590 0 : TestType tested = (TestType) ( this ) ;
111591 :
111592 0 : std::vector < unsigned char* > :: const_iterator block = SgNullptrValExp::pools.begin();
111593 :
111594 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
111595 : // while (found == false && block < Memory_Block_List.end())
111596 0 : while ( (found == false) && (block != SgNullptrValExp::pools.end()) )
111597 : {
111598 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNullptrValExp::pool_size * sizeof(SgNullptrValExp) ) ) ;
111599 0 : ++block;
111600 : }
111601 :
111602 : // Special handling for static data
111603 :
111604 :
111605 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
111606 0 : ROSE_ASSERT(found == true);
111607 :
111608 0 : return found;
111609 : }
111610 : /* #line 111611 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
111611 :
111612 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
111613 :
111614 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111615 :
111616 : /* #line 111617 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
111617 :
111618 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111619 :
111620 : void
111621 0 : SgChar16Val::checkDataMemberPointersIfInMemoryPool()
111622 : {
111623 : // ------------ checking pointers of SgChar16Val -------------------
111624 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
111625 :
111626 0 : if ( p_originalExpressionTree != NULL )
111627 : {
111628 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111629 : {
111630 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
111631 : {
111632 0 : std::cout << "SgChar16Val :: ";
111633 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
111634 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
111635 : }
111636 : }
111637 : else
111638 : {
111639 0 : std::cout << "SgChar16Val :: " << std::flush;
111640 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
111641 0 : std::cout << " not valid " << std::endl;
111642 : }
111643 : }
111644 :
111645 0 : if ( p_operatorPosition != NULL )
111646 : {
111647 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111648 : {
111649 0 : if ( p_operatorPosition->isInMemoryPool() == false )
111650 : {
111651 0 : std::cout << "SgChar16Val :: ";
111652 0 : std::cout << " p_operatorPosition is not in memory pool of ";
111653 0 : std::cout << p_operatorPosition->class_name() << std::endl;
111654 : }
111655 : }
111656 : else
111657 : {
111658 0 : std::cout << "SgChar16Val :: " << std::flush;
111659 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
111660 0 : std::cout << " not valid " << std::endl;
111661 : }
111662 : }
111663 :
111664 0 : if ( p_startOfConstruct != NULL )
111665 : {
111666 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111667 : {
111668 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
111669 : {
111670 0 : std::cout << "SgChar16Val :: ";
111671 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
111672 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
111673 : }
111674 : }
111675 : else
111676 : {
111677 0 : std::cout << "SgChar16Val :: " << std::flush;
111678 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
111679 0 : std::cout << " not valid " << std::endl;
111680 : }
111681 : }
111682 :
111683 0 : if ( p_endOfConstruct != NULL )
111684 : {
111685 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111686 : {
111687 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
111688 : {
111689 0 : std::cout << "SgChar16Val :: ";
111690 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
111691 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
111692 : }
111693 : }
111694 : else
111695 : {
111696 0 : std::cout << "SgChar16Val :: " << std::flush;
111697 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
111698 0 : std::cout << " not valid " << std::endl;
111699 : }
111700 : }
111701 :
111702 0 : if ( p_parent != NULL )
111703 : {
111704 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111705 : {
111706 0 : if ( p_parent->isInMemoryPool() == false )
111707 : {
111708 0 : std::cout << "SgChar16Val :: ";
111709 0 : std::cout << " p_parent is not in memory pool of ";
111710 0 : std::cout << p_parent->class_name() << std::endl;
111711 : }
111712 : }
111713 : else
111714 : {
111715 0 : std::cout << "SgChar16Val :: " << std::flush;
111716 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
111717 0 : std::cout << " not valid " << std::endl;
111718 : }
111719 : }
111720 :
111721 :
111722 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111723 :
111724 0 : }
111725 :
111726 :
111727 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
111728 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
111729 : bool
111730 0 : SgChar16Val::isInMemoryPool ()
111731 : {
111732 0 : typedef unsigned char* TestType;
111733 :
111734 0 : bool found = false;
111735 :
111736 0 : ROSE_ASSERT(this != NULL);
111737 :
111738 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
111739 :
111740 0 : TestType tested = (TestType) ( this ) ;
111741 :
111742 0 : std::vector < unsigned char* > :: const_iterator block = SgChar16Val::pools.begin();
111743 :
111744 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
111745 : // while (found == false && block < Memory_Block_List.end())
111746 0 : while ( (found == false) && (block != SgChar16Val::pools.end()) )
111747 : {
111748 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgChar16Val::pool_size * sizeof(SgChar16Val) ) ) ;
111749 0 : ++block;
111750 : }
111751 :
111752 : // Special handling for static data
111753 :
111754 :
111755 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
111756 0 : ROSE_ASSERT(found == true);
111757 :
111758 0 : return found;
111759 : }
111760 : /* #line 111761 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
111761 :
111762 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
111763 :
111764 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111765 :
111766 : /* #line 111767 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
111767 :
111768 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111769 :
111770 : void
111771 0 : SgChar32Val::checkDataMemberPointersIfInMemoryPool()
111772 : {
111773 : // ------------ checking pointers of SgChar32Val -------------------
111774 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
111775 :
111776 0 : if ( p_originalExpressionTree != NULL )
111777 : {
111778 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111779 : {
111780 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
111781 : {
111782 0 : std::cout << "SgChar32Val :: ";
111783 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
111784 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
111785 : }
111786 : }
111787 : else
111788 : {
111789 0 : std::cout << "SgChar32Val :: " << std::flush;
111790 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
111791 0 : std::cout << " not valid " << std::endl;
111792 : }
111793 : }
111794 :
111795 0 : if ( p_operatorPosition != NULL )
111796 : {
111797 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111798 : {
111799 0 : if ( p_operatorPosition->isInMemoryPool() == false )
111800 : {
111801 0 : std::cout << "SgChar32Val :: ";
111802 0 : std::cout << " p_operatorPosition is not in memory pool of ";
111803 0 : std::cout << p_operatorPosition->class_name() << std::endl;
111804 : }
111805 : }
111806 : else
111807 : {
111808 0 : std::cout << "SgChar32Val :: " << std::flush;
111809 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
111810 0 : std::cout << " not valid " << std::endl;
111811 : }
111812 : }
111813 :
111814 0 : if ( p_startOfConstruct != NULL )
111815 : {
111816 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111817 : {
111818 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
111819 : {
111820 0 : std::cout << "SgChar32Val :: ";
111821 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
111822 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
111823 : }
111824 : }
111825 : else
111826 : {
111827 0 : std::cout << "SgChar32Val :: " << std::flush;
111828 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
111829 0 : std::cout << " not valid " << std::endl;
111830 : }
111831 : }
111832 :
111833 0 : if ( p_endOfConstruct != NULL )
111834 : {
111835 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111836 : {
111837 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
111838 : {
111839 0 : std::cout << "SgChar32Val :: ";
111840 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
111841 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
111842 : }
111843 : }
111844 : else
111845 : {
111846 0 : std::cout << "SgChar32Val :: " << std::flush;
111847 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
111848 0 : std::cout << " not valid " << std::endl;
111849 : }
111850 : }
111851 :
111852 0 : if ( p_parent != NULL )
111853 : {
111854 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111855 : {
111856 0 : if ( p_parent->isInMemoryPool() == false )
111857 : {
111858 0 : std::cout << "SgChar32Val :: ";
111859 0 : std::cout << " p_parent is not in memory pool of ";
111860 0 : std::cout << p_parent->class_name() << std::endl;
111861 : }
111862 : }
111863 : else
111864 : {
111865 0 : std::cout << "SgChar32Val :: " << std::flush;
111866 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
111867 0 : std::cout << " not valid " << std::endl;
111868 : }
111869 : }
111870 :
111871 :
111872 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111873 :
111874 0 : }
111875 :
111876 :
111877 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
111878 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
111879 : bool
111880 0 : SgChar32Val::isInMemoryPool ()
111881 : {
111882 0 : typedef unsigned char* TestType;
111883 :
111884 0 : bool found = false;
111885 :
111886 0 : ROSE_ASSERT(this != NULL);
111887 :
111888 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
111889 :
111890 0 : TestType tested = (TestType) ( this ) ;
111891 :
111892 0 : std::vector < unsigned char* > :: const_iterator block = SgChar32Val::pools.begin();
111893 :
111894 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
111895 : // while (found == false && block < Memory_Block_List.end())
111896 0 : while ( (found == false) && (block != SgChar32Val::pools.end()) )
111897 : {
111898 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgChar32Val::pool_size * sizeof(SgChar32Val) ) ) ;
111899 0 : ++block;
111900 : }
111901 :
111902 : // Special handling for static data
111903 :
111904 :
111905 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
111906 0 : ROSE_ASSERT(found == true);
111907 :
111908 0 : return found;
111909 : }
111910 : /* #line 111911 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
111911 :
111912 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
111913 :
111914 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111915 :
111916 : /* #line 111917 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
111917 :
111918 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
111919 :
111920 : void
111921 0 : SgFloat80Val::checkDataMemberPointersIfInMemoryPool()
111922 : {
111923 : // ------------ checking pointers of SgFloat80Val -------------------
111924 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
111925 :
111926 0 : if ( p_originalExpressionTree != NULL )
111927 : {
111928 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111929 : {
111930 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
111931 : {
111932 0 : std::cout << "SgFloat80Val :: ";
111933 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
111934 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
111935 : }
111936 : }
111937 : else
111938 : {
111939 0 : std::cout << "SgFloat80Val :: " << std::flush;
111940 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
111941 0 : std::cout << " not valid " << std::endl;
111942 : }
111943 : }
111944 :
111945 0 : if ( p_operatorPosition != NULL )
111946 : {
111947 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111948 : {
111949 0 : if ( p_operatorPosition->isInMemoryPool() == false )
111950 : {
111951 0 : std::cout << "SgFloat80Val :: ";
111952 0 : std::cout << " p_operatorPosition is not in memory pool of ";
111953 0 : std::cout << p_operatorPosition->class_name() << std::endl;
111954 : }
111955 : }
111956 : else
111957 : {
111958 0 : std::cout << "SgFloat80Val :: " << std::flush;
111959 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
111960 0 : std::cout << " not valid " << std::endl;
111961 : }
111962 : }
111963 :
111964 0 : if ( p_startOfConstruct != NULL )
111965 : {
111966 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111967 : {
111968 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
111969 : {
111970 0 : std::cout << "SgFloat80Val :: ";
111971 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
111972 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
111973 : }
111974 : }
111975 : else
111976 : {
111977 0 : std::cout << "SgFloat80Val :: " << std::flush;
111978 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
111979 0 : std::cout << " not valid " << std::endl;
111980 : }
111981 : }
111982 :
111983 0 : if ( p_endOfConstruct != NULL )
111984 : {
111985 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
111986 : {
111987 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
111988 : {
111989 0 : std::cout << "SgFloat80Val :: ";
111990 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
111991 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
111992 : }
111993 : }
111994 : else
111995 : {
111996 0 : std::cout << "SgFloat80Val :: " << std::flush;
111997 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
111998 0 : std::cout << " not valid " << std::endl;
111999 : }
112000 : }
112001 :
112002 0 : if ( p_parent != NULL )
112003 : {
112004 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112005 : {
112006 0 : if ( p_parent->isInMemoryPool() == false )
112007 : {
112008 0 : std::cout << "SgFloat80Val :: ";
112009 0 : std::cout << " p_parent is not in memory pool of ";
112010 0 : std::cout << p_parent->class_name() << std::endl;
112011 : }
112012 : }
112013 : else
112014 : {
112015 0 : std::cout << "SgFloat80Val :: " << std::flush;
112016 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
112017 0 : std::cout << " not valid " << std::endl;
112018 : }
112019 : }
112020 :
112021 :
112022 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112023 :
112024 0 : }
112025 :
112026 :
112027 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
112028 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
112029 : bool
112030 0 : SgFloat80Val::isInMemoryPool ()
112031 : {
112032 0 : typedef unsigned char* TestType;
112033 :
112034 0 : bool found = false;
112035 :
112036 0 : ROSE_ASSERT(this != NULL);
112037 :
112038 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
112039 :
112040 0 : TestType tested = (TestType) ( this ) ;
112041 :
112042 0 : std::vector < unsigned char* > :: const_iterator block = SgFloat80Val::pools.begin();
112043 :
112044 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
112045 : // while (found == false && block < Memory_Block_List.end())
112046 0 : while ( (found == false) && (block != SgFloat80Val::pools.end()) )
112047 : {
112048 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFloat80Val::pool_size * sizeof(SgFloat80Val) ) ) ;
112049 0 : ++block;
112050 : }
112051 :
112052 : // Special handling for static data
112053 :
112054 :
112055 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
112056 0 : ROSE_ASSERT(found == true);
112057 :
112058 0 : return found;
112059 : }
112060 : /* #line 112061 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
112061 :
112062 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
112063 :
112064 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112065 :
112066 : /* #line 112067 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
112067 :
112068 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112069 :
112070 : void
112071 0 : SgFloat128Val::checkDataMemberPointersIfInMemoryPool()
112072 : {
112073 : // ------------ checking pointers of SgFloat128Val -------------------
112074 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
112075 :
112076 0 : if ( p_originalExpressionTree != NULL )
112077 : {
112078 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112079 : {
112080 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
112081 : {
112082 0 : std::cout << "SgFloat128Val :: ";
112083 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
112084 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
112085 : }
112086 : }
112087 : else
112088 : {
112089 0 : std::cout << "SgFloat128Val :: " << std::flush;
112090 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
112091 0 : std::cout << " not valid " << std::endl;
112092 : }
112093 : }
112094 :
112095 0 : if ( p_operatorPosition != NULL )
112096 : {
112097 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112098 : {
112099 0 : if ( p_operatorPosition->isInMemoryPool() == false )
112100 : {
112101 0 : std::cout << "SgFloat128Val :: ";
112102 0 : std::cout << " p_operatorPosition is not in memory pool of ";
112103 0 : std::cout << p_operatorPosition->class_name() << std::endl;
112104 : }
112105 : }
112106 : else
112107 : {
112108 0 : std::cout << "SgFloat128Val :: " << std::flush;
112109 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
112110 0 : std::cout << " not valid " << std::endl;
112111 : }
112112 : }
112113 :
112114 0 : if ( p_startOfConstruct != NULL )
112115 : {
112116 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112117 : {
112118 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
112119 : {
112120 0 : std::cout << "SgFloat128Val :: ";
112121 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
112122 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
112123 : }
112124 : }
112125 : else
112126 : {
112127 0 : std::cout << "SgFloat128Val :: " << std::flush;
112128 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
112129 0 : std::cout << " not valid " << std::endl;
112130 : }
112131 : }
112132 :
112133 0 : if ( p_endOfConstruct != NULL )
112134 : {
112135 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112136 : {
112137 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
112138 : {
112139 0 : std::cout << "SgFloat128Val :: ";
112140 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
112141 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
112142 : }
112143 : }
112144 : else
112145 : {
112146 0 : std::cout << "SgFloat128Val :: " << std::flush;
112147 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
112148 0 : std::cout << " not valid " << std::endl;
112149 : }
112150 : }
112151 :
112152 0 : if ( p_parent != NULL )
112153 : {
112154 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112155 : {
112156 0 : if ( p_parent->isInMemoryPool() == false )
112157 : {
112158 0 : std::cout << "SgFloat128Val :: ";
112159 0 : std::cout << " p_parent is not in memory pool of ";
112160 0 : std::cout << p_parent->class_name() << std::endl;
112161 : }
112162 : }
112163 : else
112164 : {
112165 0 : std::cout << "SgFloat128Val :: " << std::flush;
112166 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
112167 0 : std::cout << " not valid " << std::endl;
112168 : }
112169 : }
112170 :
112171 :
112172 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112173 :
112174 0 : }
112175 :
112176 :
112177 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
112178 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
112179 : bool
112180 0 : SgFloat128Val::isInMemoryPool ()
112181 : {
112182 0 : typedef unsigned char* TestType;
112183 :
112184 0 : bool found = false;
112185 :
112186 0 : ROSE_ASSERT(this != NULL);
112187 :
112188 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
112189 :
112190 0 : TestType tested = (TestType) ( this ) ;
112191 :
112192 0 : std::vector < unsigned char* > :: const_iterator block = SgFloat128Val::pools.begin();
112193 :
112194 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
112195 : // while (found == false && block < Memory_Block_List.end())
112196 0 : while ( (found == false) && (block != SgFloat128Val::pools.end()) )
112197 : {
112198 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFloat128Val::pool_size * sizeof(SgFloat128Val) ) ) ;
112199 0 : ++block;
112200 : }
112201 :
112202 : // Special handling for static data
112203 :
112204 :
112205 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
112206 0 : ROSE_ASSERT(found == true);
112207 :
112208 0 : return found;
112209 : }
112210 : /* #line 112211 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
112211 :
112212 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
112213 :
112214 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112215 :
112216 : /* #line 112217 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
112217 :
112218 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112219 :
112220 : void
112221 0 : SgVoidVal::checkDataMemberPointersIfInMemoryPool()
112222 : {
112223 : // ------------ checking pointers of SgVoidVal -------------------
112224 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
112225 :
112226 0 : if ( p_originalExpressionTree != NULL )
112227 : {
112228 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112229 : {
112230 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
112231 : {
112232 0 : std::cout << "SgVoidVal :: ";
112233 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
112234 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
112235 : }
112236 : }
112237 : else
112238 : {
112239 0 : std::cout << "SgVoidVal :: " << std::flush;
112240 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
112241 0 : std::cout << " not valid " << std::endl;
112242 : }
112243 : }
112244 :
112245 0 : if ( p_operatorPosition != NULL )
112246 : {
112247 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112248 : {
112249 0 : if ( p_operatorPosition->isInMemoryPool() == false )
112250 : {
112251 0 : std::cout << "SgVoidVal :: ";
112252 0 : std::cout << " p_operatorPosition is not in memory pool of ";
112253 0 : std::cout << p_operatorPosition->class_name() << std::endl;
112254 : }
112255 : }
112256 : else
112257 : {
112258 0 : std::cout << "SgVoidVal :: " << std::flush;
112259 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
112260 0 : std::cout << " not valid " << std::endl;
112261 : }
112262 : }
112263 :
112264 0 : if ( p_startOfConstruct != NULL )
112265 : {
112266 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112267 : {
112268 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
112269 : {
112270 0 : std::cout << "SgVoidVal :: ";
112271 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
112272 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
112273 : }
112274 : }
112275 : else
112276 : {
112277 0 : std::cout << "SgVoidVal :: " << std::flush;
112278 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
112279 0 : std::cout << " not valid " << std::endl;
112280 : }
112281 : }
112282 :
112283 0 : if ( p_endOfConstruct != NULL )
112284 : {
112285 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112286 : {
112287 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
112288 : {
112289 0 : std::cout << "SgVoidVal :: ";
112290 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
112291 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
112292 : }
112293 : }
112294 : else
112295 : {
112296 0 : std::cout << "SgVoidVal :: " << std::flush;
112297 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
112298 0 : std::cout << " not valid " << std::endl;
112299 : }
112300 : }
112301 :
112302 0 : if ( p_parent != NULL )
112303 : {
112304 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112305 : {
112306 0 : if ( p_parent->isInMemoryPool() == false )
112307 : {
112308 0 : std::cout << "SgVoidVal :: ";
112309 0 : std::cout << " p_parent is not in memory pool of ";
112310 0 : std::cout << p_parent->class_name() << std::endl;
112311 : }
112312 : }
112313 : else
112314 : {
112315 0 : std::cout << "SgVoidVal :: " << std::flush;
112316 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
112317 0 : std::cout << " not valid " << std::endl;
112318 : }
112319 : }
112320 :
112321 :
112322 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112323 :
112324 0 : }
112325 :
112326 :
112327 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
112328 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
112329 : bool
112330 0 : SgVoidVal::isInMemoryPool ()
112331 : {
112332 0 : typedef unsigned char* TestType;
112333 :
112334 0 : bool found = false;
112335 :
112336 0 : ROSE_ASSERT(this != NULL);
112337 :
112338 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
112339 :
112340 0 : TestType tested = (TestType) ( this ) ;
112341 :
112342 0 : std::vector < unsigned char* > :: const_iterator block = SgVoidVal::pools.begin();
112343 :
112344 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
112345 : // while (found == false && block < Memory_Block_List.end())
112346 0 : while ( (found == false) && (block != SgVoidVal::pools.end()) )
112347 : {
112348 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgVoidVal::pool_size * sizeof(SgVoidVal) ) ) ;
112349 0 : ++block;
112350 : }
112351 :
112352 : // Special handling for static data
112353 :
112354 :
112355 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
112356 0 : ROSE_ASSERT(found == true);
112357 :
112358 0 : return found;
112359 : }
112360 : /* #line 112361 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
112361 :
112362 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
112363 :
112364 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112365 :
112366 : /* #line 112367 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
112367 :
112368 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112369 :
112370 : void
112371 0 : SgCallExpression::checkDataMemberPointersIfInMemoryPool()
112372 : {
112373 : // ------------ checking pointers of SgCallExpression -------------------
112374 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
112375 :
112376 0 : if ( p_function != NULL )
112377 : {
112378 0 : if ( p_function->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112379 : {
112380 0 : if ( p_function->isInMemoryPool() == false )
112381 : {
112382 0 : std::cout << "SgCallExpression :: ";
112383 0 : std::cout << " p_function is not in memory pool of ";
112384 0 : std::cout << p_function->class_name() << std::endl;
112385 : }
112386 : }
112387 : else
112388 : {
112389 0 : std::cout << "SgCallExpression :: " << std::flush;
112390 0 : std::cout << "SgExpression* p_function = " << p_function << " --> " << std::flush;
112391 0 : std::cout << " not valid " << std::endl;
112392 : }
112393 : }
112394 :
112395 0 : if ( p_args != NULL )
112396 : {
112397 0 : if ( p_args->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112398 : {
112399 0 : if ( p_args->isInMemoryPool() == false )
112400 : {
112401 0 : std::cout << "SgCallExpression :: ";
112402 0 : std::cout << " p_args is not in memory pool of ";
112403 0 : std::cout << p_args->class_name() << std::endl;
112404 : }
112405 : }
112406 : else
112407 : {
112408 0 : std::cout << "SgCallExpression :: " << std::flush;
112409 0 : std::cout << "SgExprListExp* p_args = " << p_args << " --> " << std::flush;
112410 0 : std::cout << " not valid " << std::endl;
112411 : }
112412 : }
112413 :
112414 0 : if ( p_expression_type != NULL )
112415 : {
112416 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112417 : {
112418 0 : if ( p_expression_type->isInMemoryPool() == false )
112419 : {
112420 0 : std::cout << "SgCallExpression :: ";
112421 0 : std::cout << " p_expression_type is not in memory pool of ";
112422 0 : std::cout << p_expression_type->class_name() << std::endl;
112423 : }
112424 : }
112425 : else
112426 : {
112427 0 : std::cout << "SgCallExpression :: " << std::flush;
112428 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
112429 0 : std::cout << " not valid " << std::endl;
112430 : }
112431 : }
112432 :
112433 0 : if ( p_operatorPosition != NULL )
112434 : {
112435 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112436 : {
112437 0 : if ( p_operatorPosition->isInMemoryPool() == false )
112438 : {
112439 0 : std::cout << "SgCallExpression :: ";
112440 0 : std::cout << " p_operatorPosition is not in memory pool of ";
112441 0 : std::cout << p_operatorPosition->class_name() << std::endl;
112442 : }
112443 : }
112444 : else
112445 : {
112446 0 : std::cout << "SgCallExpression :: " << std::flush;
112447 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
112448 0 : std::cout << " not valid " << std::endl;
112449 : }
112450 : }
112451 :
112452 0 : if ( p_startOfConstruct != NULL )
112453 : {
112454 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112455 : {
112456 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
112457 : {
112458 0 : std::cout << "SgCallExpression :: ";
112459 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
112460 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
112461 : }
112462 : }
112463 : else
112464 : {
112465 0 : std::cout << "SgCallExpression :: " << std::flush;
112466 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
112467 0 : std::cout << " not valid " << std::endl;
112468 : }
112469 : }
112470 :
112471 0 : if ( p_endOfConstruct != NULL )
112472 : {
112473 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112474 : {
112475 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
112476 : {
112477 0 : std::cout << "SgCallExpression :: ";
112478 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
112479 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
112480 : }
112481 : }
112482 : else
112483 : {
112484 0 : std::cout << "SgCallExpression :: " << std::flush;
112485 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
112486 0 : std::cout << " not valid " << std::endl;
112487 : }
112488 : }
112489 :
112490 0 : if ( p_parent != NULL )
112491 : {
112492 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112493 : {
112494 0 : if ( p_parent->isInMemoryPool() == false )
112495 : {
112496 0 : std::cout << "SgCallExpression :: ";
112497 0 : std::cout << " p_parent is not in memory pool of ";
112498 0 : std::cout << p_parent->class_name() << std::endl;
112499 : }
112500 : }
112501 : else
112502 : {
112503 0 : std::cout << "SgCallExpression :: " << std::flush;
112504 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
112505 0 : std::cout << " not valid " << std::endl;
112506 : }
112507 : }
112508 :
112509 :
112510 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112511 :
112512 0 : }
112513 :
112514 :
112515 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
112516 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
112517 : bool
112518 0 : SgCallExpression::isInMemoryPool ()
112519 : {
112520 0 : typedef unsigned char* TestType;
112521 :
112522 0 : bool found = false;
112523 :
112524 0 : ROSE_ASSERT(this != NULL);
112525 :
112526 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
112527 :
112528 0 : TestType tested = (TestType) ( this ) ;
112529 :
112530 0 : std::vector < unsigned char* > :: const_iterator block = SgCallExpression::pools.begin();
112531 :
112532 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
112533 : // while (found == false && block < Memory_Block_List.end())
112534 0 : while ( (found == false) && (block != SgCallExpression::pools.end()) )
112535 : {
112536 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCallExpression::pool_size * sizeof(SgCallExpression) ) ) ;
112537 0 : ++block;
112538 : }
112539 :
112540 : // Special handling for static data
112541 :
112542 :
112543 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
112544 0 : ROSE_ASSERT(found == true);
112545 :
112546 0 : return found;
112547 : }
112548 : /* #line 112549 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
112549 :
112550 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
112551 :
112552 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112553 :
112554 : /* #line 112555 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
112555 :
112556 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112557 :
112558 : void
112559 0 : SgFunctionCallExp::checkDataMemberPointersIfInMemoryPool()
112560 : {
112561 : // ------------ checking pointers of SgFunctionCallExp -------------------
112562 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
112563 :
112564 0 : if ( p_function != NULL )
112565 : {
112566 0 : if ( p_function->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112567 : {
112568 0 : if ( p_function->isInMemoryPool() == false )
112569 : {
112570 0 : std::cout << "SgFunctionCallExp :: ";
112571 0 : std::cout << " p_function is not in memory pool of ";
112572 0 : std::cout << p_function->class_name() << std::endl;
112573 : }
112574 : }
112575 : else
112576 : {
112577 0 : std::cout << "SgFunctionCallExp :: " << std::flush;
112578 0 : std::cout << "SgExpression* p_function = " << p_function << " --> " << std::flush;
112579 0 : std::cout << " not valid " << std::endl;
112580 : }
112581 : }
112582 :
112583 0 : if ( p_args != NULL )
112584 : {
112585 0 : if ( p_args->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112586 : {
112587 0 : if ( p_args->isInMemoryPool() == false )
112588 : {
112589 0 : std::cout << "SgFunctionCallExp :: ";
112590 0 : std::cout << " p_args is not in memory pool of ";
112591 0 : std::cout << p_args->class_name() << std::endl;
112592 : }
112593 : }
112594 : else
112595 : {
112596 0 : std::cout << "SgFunctionCallExp :: " << std::flush;
112597 0 : std::cout << "SgExprListExp* p_args = " << p_args << " --> " << std::flush;
112598 0 : std::cout << " not valid " << std::endl;
112599 : }
112600 : }
112601 :
112602 0 : if ( p_expression_type != NULL )
112603 : {
112604 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112605 : {
112606 0 : if ( p_expression_type->isInMemoryPool() == false )
112607 : {
112608 0 : std::cout << "SgFunctionCallExp :: ";
112609 0 : std::cout << " p_expression_type is not in memory pool of ";
112610 0 : std::cout << p_expression_type->class_name() << std::endl;
112611 : }
112612 : }
112613 : else
112614 : {
112615 0 : std::cout << "SgFunctionCallExp :: " << std::flush;
112616 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
112617 0 : std::cout << " not valid " << std::endl;
112618 : }
112619 : }
112620 :
112621 0 : if ( p_operatorPosition != NULL )
112622 : {
112623 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112624 : {
112625 0 : if ( p_operatorPosition->isInMemoryPool() == false )
112626 : {
112627 0 : std::cout << "SgFunctionCallExp :: ";
112628 0 : std::cout << " p_operatorPosition is not in memory pool of ";
112629 0 : std::cout << p_operatorPosition->class_name() << std::endl;
112630 : }
112631 : }
112632 : else
112633 : {
112634 0 : std::cout << "SgFunctionCallExp :: " << std::flush;
112635 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
112636 0 : std::cout << " not valid " << std::endl;
112637 : }
112638 : }
112639 :
112640 0 : if ( p_startOfConstruct != NULL )
112641 : {
112642 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112643 : {
112644 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
112645 : {
112646 0 : std::cout << "SgFunctionCallExp :: ";
112647 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
112648 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
112649 : }
112650 : }
112651 : else
112652 : {
112653 0 : std::cout << "SgFunctionCallExp :: " << std::flush;
112654 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
112655 0 : std::cout << " not valid " << std::endl;
112656 : }
112657 : }
112658 :
112659 0 : if ( p_endOfConstruct != NULL )
112660 : {
112661 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112662 : {
112663 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
112664 : {
112665 0 : std::cout << "SgFunctionCallExp :: ";
112666 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
112667 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
112668 : }
112669 : }
112670 : else
112671 : {
112672 0 : std::cout << "SgFunctionCallExp :: " << std::flush;
112673 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
112674 0 : std::cout << " not valid " << std::endl;
112675 : }
112676 : }
112677 :
112678 0 : if ( p_parent != NULL )
112679 : {
112680 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112681 : {
112682 0 : if ( p_parent->isInMemoryPool() == false )
112683 : {
112684 0 : std::cout << "SgFunctionCallExp :: ";
112685 0 : std::cout << " p_parent is not in memory pool of ";
112686 0 : std::cout << p_parent->class_name() << std::endl;
112687 : }
112688 : }
112689 : else
112690 : {
112691 0 : std::cout << "SgFunctionCallExp :: " << std::flush;
112692 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
112693 0 : std::cout << " not valid " << std::endl;
112694 : }
112695 : }
112696 :
112697 :
112698 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112699 :
112700 0 : }
112701 :
112702 :
112703 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
112704 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
112705 : bool
112706 0 : SgFunctionCallExp::isInMemoryPool ()
112707 : {
112708 0 : typedef unsigned char* TestType;
112709 :
112710 0 : bool found = false;
112711 :
112712 0 : ROSE_ASSERT(this != NULL);
112713 :
112714 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
112715 :
112716 0 : TestType tested = (TestType) ( this ) ;
112717 :
112718 0 : std::vector < unsigned char* > :: const_iterator block = SgFunctionCallExp::pools.begin();
112719 :
112720 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
112721 : // while (found == false && block < Memory_Block_List.end())
112722 0 : while ( (found == false) && (block != SgFunctionCallExp::pools.end()) )
112723 : {
112724 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFunctionCallExp::pool_size * sizeof(SgFunctionCallExp) ) ) ;
112725 0 : ++block;
112726 : }
112727 :
112728 : // Special handling for static data
112729 :
112730 :
112731 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
112732 0 : ROSE_ASSERT(found == true);
112733 :
112734 0 : return found;
112735 : }
112736 : /* #line 112737 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
112737 :
112738 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
112739 :
112740 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112741 :
112742 : /* #line 112743 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
112743 :
112744 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112745 :
112746 : void
112747 0 : SgCudaKernelCallExp::checkDataMemberPointersIfInMemoryPool()
112748 : {
112749 : // ------------ checking pointers of SgCudaKernelCallExp -------------------
112750 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
112751 :
112752 0 : if ( p_exec_config != NULL )
112753 : {
112754 0 : if ( p_exec_config->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112755 : {
112756 0 : if ( p_exec_config->isInMemoryPool() == false )
112757 : {
112758 0 : std::cout << "SgCudaKernelCallExp :: ";
112759 0 : std::cout << " p_exec_config is not in memory pool of ";
112760 0 : std::cout << p_exec_config->class_name() << std::endl;
112761 : }
112762 : }
112763 : else
112764 : {
112765 0 : std::cout << "SgCudaKernelCallExp :: " << std::flush;
112766 0 : std::cout << "SgCudaKernelExecConfig* p_exec_config = " << p_exec_config << " --> " << std::flush;
112767 0 : std::cout << " not valid " << std::endl;
112768 : }
112769 : }
112770 :
112771 0 : if ( p_function != NULL )
112772 : {
112773 0 : if ( p_function->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112774 : {
112775 0 : if ( p_function->isInMemoryPool() == false )
112776 : {
112777 0 : std::cout << "SgCudaKernelCallExp :: ";
112778 0 : std::cout << " p_function is not in memory pool of ";
112779 0 : std::cout << p_function->class_name() << std::endl;
112780 : }
112781 : }
112782 : else
112783 : {
112784 0 : std::cout << "SgCudaKernelCallExp :: " << std::flush;
112785 0 : std::cout << "SgExpression* p_function = " << p_function << " --> " << std::flush;
112786 0 : std::cout << " not valid " << std::endl;
112787 : }
112788 : }
112789 :
112790 0 : if ( p_args != NULL )
112791 : {
112792 0 : if ( p_args->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112793 : {
112794 0 : if ( p_args->isInMemoryPool() == false )
112795 : {
112796 0 : std::cout << "SgCudaKernelCallExp :: ";
112797 0 : std::cout << " p_args is not in memory pool of ";
112798 0 : std::cout << p_args->class_name() << std::endl;
112799 : }
112800 : }
112801 : else
112802 : {
112803 0 : std::cout << "SgCudaKernelCallExp :: " << std::flush;
112804 0 : std::cout << "SgExprListExp* p_args = " << p_args << " --> " << std::flush;
112805 0 : std::cout << " not valid " << std::endl;
112806 : }
112807 : }
112808 :
112809 0 : if ( p_expression_type != NULL )
112810 : {
112811 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112812 : {
112813 0 : if ( p_expression_type->isInMemoryPool() == false )
112814 : {
112815 0 : std::cout << "SgCudaKernelCallExp :: ";
112816 0 : std::cout << " p_expression_type is not in memory pool of ";
112817 0 : std::cout << p_expression_type->class_name() << std::endl;
112818 : }
112819 : }
112820 : else
112821 : {
112822 0 : std::cout << "SgCudaKernelCallExp :: " << std::flush;
112823 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
112824 0 : std::cout << " not valid " << std::endl;
112825 : }
112826 : }
112827 :
112828 0 : if ( p_operatorPosition != NULL )
112829 : {
112830 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112831 : {
112832 0 : if ( p_operatorPosition->isInMemoryPool() == false )
112833 : {
112834 0 : std::cout << "SgCudaKernelCallExp :: ";
112835 0 : std::cout << " p_operatorPosition is not in memory pool of ";
112836 0 : std::cout << p_operatorPosition->class_name() << std::endl;
112837 : }
112838 : }
112839 : else
112840 : {
112841 0 : std::cout << "SgCudaKernelCallExp :: " << std::flush;
112842 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
112843 0 : std::cout << " not valid " << std::endl;
112844 : }
112845 : }
112846 :
112847 0 : if ( p_startOfConstruct != NULL )
112848 : {
112849 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112850 : {
112851 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
112852 : {
112853 0 : std::cout << "SgCudaKernelCallExp :: ";
112854 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
112855 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
112856 : }
112857 : }
112858 : else
112859 : {
112860 0 : std::cout << "SgCudaKernelCallExp :: " << std::flush;
112861 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
112862 0 : std::cout << " not valid " << std::endl;
112863 : }
112864 : }
112865 :
112866 0 : if ( p_endOfConstruct != NULL )
112867 : {
112868 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112869 : {
112870 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
112871 : {
112872 0 : std::cout << "SgCudaKernelCallExp :: ";
112873 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
112874 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
112875 : }
112876 : }
112877 : else
112878 : {
112879 0 : std::cout << "SgCudaKernelCallExp :: " << std::flush;
112880 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
112881 0 : std::cout << " not valid " << std::endl;
112882 : }
112883 : }
112884 :
112885 0 : if ( p_parent != NULL )
112886 : {
112887 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112888 : {
112889 0 : if ( p_parent->isInMemoryPool() == false )
112890 : {
112891 0 : std::cout << "SgCudaKernelCallExp :: ";
112892 0 : std::cout << " p_parent is not in memory pool of ";
112893 0 : std::cout << p_parent->class_name() << std::endl;
112894 : }
112895 : }
112896 : else
112897 : {
112898 0 : std::cout << "SgCudaKernelCallExp :: " << std::flush;
112899 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
112900 0 : std::cout << " not valid " << std::endl;
112901 : }
112902 : }
112903 :
112904 :
112905 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112906 :
112907 0 : }
112908 :
112909 :
112910 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
112911 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
112912 : bool
112913 0 : SgCudaKernelCallExp::isInMemoryPool ()
112914 : {
112915 0 : typedef unsigned char* TestType;
112916 :
112917 0 : bool found = false;
112918 :
112919 0 : ROSE_ASSERT(this != NULL);
112920 :
112921 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
112922 :
112923 0 : TestType tested = (TestType) ( this ) ;
112924 :
112925 0 : std::vector < unsigned char* > :: const_iterator block = SgCudaKernelCallExp::pools.begin();
112926 :
112927 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
112928 : // while (found == false && block < Memory_Block_List.end())
112929 0 : while ( (found == false) && (block != SgCudaKernelCallExp::pools.end()) )
112930 : {
112931 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCudaKernelCallExp::pool_size * sizeof(SgCudaKernelCallExp) ) ) ;
112932 0 : ++block;
112933 : }
112934 :
112935 : // Special handling for static data
112936 :
112937 :
112938 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
112939 0 : ROSE_ASSERT(found == true);
112940 :
112941 0 : return found;
112942 : }
112943 : /* #line 112944 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
112944 :
112945 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
112946 :
112947 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112948 :
112949 : /* #line 112950 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
112950 :
112951 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
112952 :
112953 : void
112954 0 : SgSizeOfOp::checkDataMemberPointersIfInMemoryPool()
112955 : {
112956 : // ------------ checking pointers of SgSizeOfOp -------------------
112957 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
112958 :
112959 0 : if ( p_operand_expr != NULL )
112960 : {
112961 0 : if ( p_operand_expr->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112962 : {
112963 0 : if ( p_operand_expr->isInMemoryPool() == false )
112964 : {
112965 0 : std::cout << "SgSizeOfOp :: ";
112966 0 : std::cout << " p_operand_expr is not in memory pool of ";
112967 0 : std::cout << p_operand_expr->class_name() << std::endl;
112968 : }
112969 : }
112970 : else
112971 : {
112972 0 : std::cout << "SgSizeOfOp :: " << std::flush;
112973 0 : std::cout << "SgExpression* p_operand_expr = " << p_operand_expr << " --> " << std::flush;
112974 0 : std::cout << " not valid " << std::endl;
112975 : }
112976 : }
112977 :
112978 0 : if ( p_operand_type != NULL )
112979 : {
112980 0 : if ( p_operand_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
112981 : {
112982 0 : if ( p_operand_type->isInMemoryPool() == false )
112983 : {
112984 0 : std::cout << "SgSizeOfOp :: ";
112985 0 : std::cout << " p_operand_type is not in memory pool of ";
112986 0 : std::cout << p_operand_type->class_name() << std::endl;
112987 : }
112988 : }
112989 : else
112990 : {
112991 0 : std::cout << "SgSizeOfOp :: " << std::flush;
112992 0 : std::cout << "SgType* p_operand_type = " << p_operand_type << " --> " << std::flush;
112993 0 : std::cout << " not valid " << std::endl;
112994 : }
112995 : }
112996 :
112997 0 : if ( p_expression_type != NULL )
112998 : {
112999 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113000 : {
113001 0 : if ( p_expression_type->isInMemoryPool() == false )
113002 : {
113003 0 : std::cout << "SgSizeOfOp :: ";
113004 0 : std::cout << " p_expression_type is not in memory pool of ";
113005 0 : std::cout << p_expression_type->class_name() << std::endl;
113006 : }
113007 : }
113008 : else
113009 : {
113010 0 : std::cout << "SgSizeOfOp :: " << std::flush;
113011 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
113012 0 : std::cout << " not valid " << std::endl;
113013 : }
113014 : }
113015 :
113016 0 : if ( p_operatorPosition != NULL )
113017 : {
113018 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113019 : {
113020 0 : if ( p_operatorPosition->isInMemoryPool() == false )
113021 : {
113022 0 : std::cout << "SgSizeOfOp :: ";
113023 0 : std::cout << " p_operatorPosition is not in memory pool of ";
113024 0 : std::cout << p_operatorPosition->class_name() << std::endl;
113025 : }
113026 : }
113027 : else
113028 : {
113029 0 : std::cout << "SgSizeOfOp :: " << std::flush;
113030 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
113031 0 : std::cout << " not valid " << std::endl;
113032 : }
113033 : }
113034 :
113035 0 : if ( p_startOfConstruct != NULL )
113036 : {
113037 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113038 : {
113039 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
113040 : {
113041 0 : std::cout << "SgSizeOfOp :: ";
113042 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
113043 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
113044 : }
113045 : }
113046 : else
113047 : {
113048 0 : std::cout << "SgSizeOfOp :: " << std::flush;
113049 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
113050 0 : std::cout << " not valid " << std::endl;
113051 : }
113052 : }
113053 :
113054 0 : if ( p_endOfConstruct != NULL )
113055 : {
113056 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113057 : {
113058 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
113059 : {
113060 0 : std::cout << "SgSizeOfOp :: ";
113061 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
113062 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
113063 : }
113064 : }
113065 : else
113066 : {
113067 0 : std::cout << "SgSizeOfOp :: " << std::flush;
113068 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
113069 0 : std::cout << " not valid " << std::endl;
113070 : }
113071 : }
113072 :
113073 0 : if ( p_parent != NULL )
113074 : {
113075 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113076 : {
113077 0 : if ( p_parent->isInMemoryPool() == false )
113078 : {
113079 0 : std::cout << "SgSizeOfOp :: ";
113080 0 : std::cout << " p_parent is not in memory pool of ";
113081 0 : std::cout << p_parent->class_name() << std::endl;
113082 : }
113083 : }
113084 : else
113085 : {
113086 0 : std::cout << "SgSizeOfOp :: " << std::flush;
113087 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
113088 0 : std::cout << " not valid " << std::endl;
113089 : }
113090 : }
113091 :
113092 :
113093 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
113094 :
113095 0 : }
113096 :
113097 :
113098 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
113099 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
113100 : bool
113101 0 : SgSizeOfOp::isInMemoryPool ()
113102 : {
113103 0 : typedef unsigned char* TestType;
113104 :
113105 0 : bool found = false;
113106 :
113107 0 : ROSE_ASSERT(this != NULL);
113108 :
113109 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
113110 :
113111 0 : TestType tested = (TestType) ( this ) ;
113112 :
113113 0 : std::vector < unsigned char* > :: const_iterator block = SgSizeOfOp::pools.begin();
113114 :
113115 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
113116 : // while (found == false && block < Memory_Block_List.end())
113117 0 : while ( (found == false) && (block != SgSizeOfOp::pools.end()) )
113118 : {
113119 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSizeOfOp::pool_size * sizeof(SgSizeOfOp) ) ) ;
113120 0 : ++block;
113121 : }
113122 :
113123 : // Special handling for static data
113124 :
113125 :
113126 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
113127 0 : ROSE_ASSERT(found == true);
113128 :
113129 0 : return found;
113130 : }
113131 : /* #line 113132 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
113132 :
113133 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
113134 :
113135 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
113136 :
113137 : /* #line 113138 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
113138 :
113139 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
113140 :
113141 : void
113142 0 : SgUpcLocalsizeofExpression::checkDataMemberPointersIfInMemoryPool()
113143 : {
113144 : // ------------ checking pointers of SgUpcLocalsizeofExpression -------------------
113145 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
113146 :
113147 0 : if ( p_expression != NULL )
113148 : {
113149 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113150 : {
113151 0 : if ( p_expression->isInMemoryPool() == false )
113152 : {
113153 0 : std::cout << "SgUpcLocalsizeofExpression :: ";
113154 0 : std::cout << " p_expression is not in memory pool of ";
113155 0 : std::cout << p_expression->class_name() << std::endl;
113156 : }
113157 : }
113158 : else
113159 : {
113160 0 : std::cout << "SgUpcLocalsizeofExpression :: " << std::flush;
113161 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
113162 0 : std::cout << " not valid " << std::endl;
113163 : }
113164 : }
113165 :
113166 0 : if ( p_operand_type != NULL )
113167 : {
113168 0 : if ( p_operand_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113169 : {
113170 0 : if ( p_operand_type->isInMemoryPool() == false )
113171 : {
113172 0 : std::cout << "SgUpcLocalsizeofExpression :: ";
113173 0 : std::cout << " p_operand_type is not in memory pool of ";
113174 0 : std::cout << p_operand_type->class_name() << std::endl;
113175 : }
113176 : }
113177 : else
113178 : {
113179 0 : std::cout << "SgUpcLocalsizeofExpression :: " << std::flush;
113180 0 : std::cout << "SgType* p_operand_type = " << p_operand_type << " --> " << std::flush;
113181 0 : std::cout << " not valid " << std::endl;
113182 : }
113183 : }
113184 :
113185 0 : if ( p_expression_type != NULL )
113186 : {
113187 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113188 : {
113189 0 : if ( p_expression_type->isInMemoryPool() == false )
113190 : {
113191 0 : std::cout << "SgUpcLocalsizeofExpression :: ";
113192 0 : std::cout << " p_expression_type is not in memory pool of ";
113193 0 : std::cout << p_expression_type->class_name() << std::endl;
113194 : }
113195 : }
113196 : else
113197 : {
113198 0 : std::cout << "SgUpcLocalsizeofExpression :: " << std::flush;
113199 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
113200 0 : std::cout << " not valid " << std::endl;
113201 : }
113202 : }
113203 :
113204 0 : if ( p_operatorPosition != NULL )
113205 : {
113206 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113207 : {
113208 0 : if ( p_operatorPosition->isInMemoryPool() == false )
113209 : {
113210 0 : std::cout << "SgUpcLocalsizeofExpression :: ";
113211 0 : std::cout << " p_operatorPosition is not in memory pool of ";
113212 0 : std::cout << p_operatorPosition->class_name() << std::endl;
113213 : }
113214 : }
113215 : else
113216 : {
113217 0 : std::cout << "SgUpcLocalsizeofExpression :: " << std::flush;
113218 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
113219 0 : std::cout << " not valid " << std::endl;
113220 : }
113221 : }
113222 :
113223 0 : if ( p_startOfConstruct != NULL )
113224 : {
113225 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113226 : {
113227 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
113228 : {
113229 0 : std::cout << "SgUpcLocalsizeofExpression :: ";
113230 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
113231 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
113232 : }
113233 : }
113234 : else
113235 : {
113236 0 : std::cout << "SgUpcLocalsizeofExpression :: " << std::flush;
113237 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
113238 0 : std::cout << " not valid " << std::endl;
113239 : }
113240 : }
113241 :
113242 0 : if ( p_endOfConstruct != NULL )
113243 : {
113244 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113245 : {
113246 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
113247 : {
113248 0 : std::cout << "SgUpcLocalsizeofExpression :: ";
113249 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
113250 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
113251 : }
113252 : }
113253 : else
113254 : {
113255 0 : std::cout << "SgUpcLocalsizeofExpression :: " << std::flush;
113256 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
113257 0 : std::cout << " not valid " << std::endl;
113258 : }
113259 : }
113260 :
113261 0 : if ( p_parent != NULL )
113262 : {
113263 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113264 : {
113265 0 : if ( p_parent->isInMemoryPool() == false )
113266 : {
113267 0 : std::cout << "SgUpcLocalsizeofExpression :: ";
113268 0 : std::cout << " p_parent is not in memory pool of ";
113269 0 : std::cout << p_parent->class_name() << std::endl;
113270 : }
113271 : }
113272 : else
113273 : {
113274 0 : std::cout << "SgUpcLocalsizeofExpression :: " << std::flush;
113275 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
113276 0 : std::cout << " not valid " << std::endl;
113277 : }
113278 : }
113279 :
113280 :
113281 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
113282 :
113283 0 : }
113284 :
113285 :
113286 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
113287 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
113288 : bool
113289 0 : SgUpcLocalsizeofExpression::isInMemoryPool ()
113290 : {
113291 0 : typedef unsigned char* TestType;
113292 :
113293 0 : bool found = false;
113294 :
113295 0 : ROSE_ASSERT(this != NULL);
113296 :
113297 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
113298 :
113299 0 : TestType tested = (TestType) ( this ) ;
113300 :
113301 0 : std::vector < unsigned char* > :: const_iterator block = SgUpcLocalsizeofExpression::pools.begin();
113302 :
113303 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
113304 : // while (found == false && block < Memory_Block_List.end())
113305 0 : while ( (found == false) && (block != SgUpcLocalsizeofExpression::pools.end()) )
113306 : {
113307 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpcLocalsizeofExpression::pool_size * sizeof(SgUpcLocalsizeofExpression) ) ) ;
113308 0 : ++block;
113309 : }
113310 :
113311 : // Special handling for static data
113312 :
113313 :
113314 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
113315 0 : ROSE_ASSERT(found == true);
113316 :
113317 0 : return found;
113318 : }
113319 : /* #line 113320 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
113320 :
113321 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
113322 :
113323 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
113324 :
113325 : /* #line 113326 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
113326 :
113327 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
113328 :
113329 : void
113330 0 : SgUpcBlocksizeofExpression::checkDataMemberPointersIfInMemoryPool()
113331 : {
113332 : // ------------ checking pointers of SgUpcBlocksizeofExpression -------------------
113333 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
113334 :
113335 0 : if ( p_expression != NULL )
113336 : {
113337 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113338 : {
113339 0 : if ( p_expression->isInMemoryPool() == false )
113340 : {
113341 0 : std::cout << "SgUpcBlocksizeofExpression :: ";
113342 0 : std::cout << " p_expression is not in memory pool of ";
113343 0 : std::cout << p_expression->class_name() << std::endl;
113344 : }
113345 : }
113346 : else
113347 : {
113348 0 : std::cout << "SgUpcBlocksizeofExpression :: " << std::flush;
113349 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
113350 0 : std::cout << " not valid " << std::endl;
113351 : }
113352 : }
113353 :
113354 0 : if ( p_operand_type != NULL )
113355 : {
113356 0 : if ( p_operand_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113357 : {
113358 0 : if ( p_operand_type->isInMemoryPool() == false )
113359 : {
113360 0 : std::cout << "SgUpcBlocksizeofExpression :: ";
113361 0 : std::cout << " p_operand_type is not in memory pool of ";
113362 0 : std::cout << p_operand_type->class_name() << std::endl;
113363 : }
113364 : }
113365 : else
113366 : {
113367 0 : std::cout << "SgUpcBlocksizeofExpression :: " << std::flush;
113368 0 : std::cout << "SgType* p_operand_type = " << p_operand_type << " --> " << std::flush;
113369 0 : std::cout << " not valid " << std::endl;
113370 : }
113371 : }
113372 :
113373 0 : if ( p_expression_type != NULL )
113374 : {
113375 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113376 : {
113377 0 : if ( p_expression_type->isInMemoryPool() == false )
113378 : {
113379 0 : std::cout << "SgUpcBlocksizeofExpression :: ";
113380 0 : std::cout << " p_expression_type is not in memory pool of ";
113381 0 : std::cout << p_expression_type->class_name() << std::endl;
113382 : }
113383 : }
113384 : else
113385 : {
113386 0 : std::cout << "SgUpcBlocksizeofExpression :: " << std::flush;
113387 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
113388 0 : std::cout << " not valid " << std::endl;
113389 : }
113390 : }
113391 :
113392 0 : if ( p_operatorPosition != NULL )
113393 : {
113394 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113395 : {
113396 0 : if ( p_operatorPosition->isInMemoryPool() == false )
113397 : {
113398 0 : std::cout << "SgUpcBlocksizeofExpression :: ";
113399 0 : std::cout << " p_operatorPosition is not in memory pool of ";
113400 0 : std::cout << p_operatorPosition->class_name() << std::endl;
113401 : }
113402 : }
113403 : else
113404 : {
113405 0 : std::cout << "SgUpcBlocksizeofExpression :: " << std::flush;
113406 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
113407 0 : std::cout << " not valid " << std::endl;
113408 : }
113409 : }
113410 :
113411 0 : if ( p_startOfConstruct != NULL )
113412 : {
113413 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113414 : {
113415 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
113416 : {
113417 0 : std::cout << "SgUpcBlocksizeofExpression :: ";
113418 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
113419 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
113420 : }
113421 : }
113422 : else
113423 : {
113424 0 : std::cout << "SgUpcBlocksizeofExpression :: " << std::flush;
113425 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
113426 0 : std::cout << " not valid " << std::endl;
113427 : }
113428 : }
113429 :
113430 0 : if ( p_endOfConstruct != NULL )
113431 : {
113432 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113433 : {
113434 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
113435 : {
113436 0 : std::cout << "SgUpcBlocksizeofExpression :: ";
113437 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
113438 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
113439 : }
113440 : }
113441 : else
113442 : {
113443 0 : std::cout << "SgUpcBlocksizeofExpression :: " << std::flush;
113444 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
113445 0 : std::cout << " not valid " << std::endl;
113446 : }
113447 : }
113448 :
113449 0 : if ( p_parent != NULL )
113450 : {
113451 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113452 : {
113453 0 : if ( p_parent->isInMemoryPool() == false )
113454 : {
113455 0 : std::cout << "SgUpcBlocksizeofExpression :: ";
113456 0 : std::cout << " p_parent is not in memory pool of ";
113457 0 : std::cout << p_parent->class_name() << std::endl;
113458 : }
113459 : }
113460 : else
113461 : {
113462 0 : std::cout << "SgUpcBlocksizeofExpression :: " << std::flush;
113463 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
113464 0 : std::cout << " not valid " << std::endl;
113465 : }
113466 : }
113467 :
113468 :
113469 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
113470 :
113471 0 : }
113472 :
113473 :
113474 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
113475 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
113476 : bool
113477 0 : SgUpcBlocksizeofExpression::isInMemoryPool ()
113478 : {
113479 0 : typedef unsigned char* TestType;
113480 :
113481 0 : bool found = false;
113482 :
113483 0 : ROSE_ASSERT(this != NULL);
113484 :
113485 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
113486 :
113487 0 : TestType tested = (TestType) ( this ) ;
113488 :
113489 0 : std::vector < unsigned char* > :: const_iterator block = SgUpcBlocksizeofExpression::pools.begin();
113490 :
113491 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
113492 : // while (found == false && block < Memory_Block_List.end())
113493 0 : while ( (found == false) && (block != SgUpcBlocksizeofExpression::pools.end()) )
113494 : {
113495 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpcBlocksizeofExpression::pool_size * sizeof(SgUpcBlocksizeofExpression) ) ) ;
113496 0 : ++block;
113497 : }
113498 :
113499 : // Special handling for static data
113500 :
113501 :
113502 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
113503 0 : ROSE_ASSERT(found == true);
113504 :
113505 0 : return found;
113506 : }
113507 : /* #line 113508 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
113508 :
113509 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
113510 :
113511 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
113512 :
113513 : /* #line 113514 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
113514 :
113515 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
113516 :
113517 : void
113518 0 : SgUpcElemsizeofExpression::checkDataMemberPointersIfInMemoryPool()
113519 : {
113520 : // ------------ checking pointers of SgUpcElemsizeofExpression -------------------
113521 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
113522 :
113523 0 : if ( p_expression != NULL )
113524 : {
113525 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113526 : {
113527 0 : if ( p_expression->isInMemoryPool() == false )
113528 : {
113529 0 : std::cout << "SgUpcElemsizeofExpression :: ";
113530 0 : std::cout << " p_expression is not in memory pool of ";
113531 0 : std::cout << p_expression->class_name() << std::endl;
113532 : }
113533 : }
113534 : else
113535 : {
113536 0 : std::cout << "SgUpcElemsizeofExpression :: " << std::flush;
113537 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
113538 0 : std::cout << " not valid " << std::endl;
113539 : }
113540 : }
113541 :
113542 0 : if ( p_operand_type != NULL )
113543 : {
113544 0 : if ( p_operand_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113545 : {
113546 0 : if ( p_operand_type->isInMemoryPool() == false )
113547 : {
113548 0 : std::cout << "SgUpcElemsizeofExpression :: ";
113549 0 : std::cout << " p_operand_type is not in memory pool of ";
113550 0 : std::cout << p_operand_type->class_name() << std::endl;
113551 : }
113552 : }
113553 : else
113554 : {
113555 0 : std::cout << "SgUpcElemsizeofExpression :: " << std::flush;
113556 0 : std::cout << "SgType* p_operand_type = " << p_operand_type << " --> " << std::flush;
113557 0 : std::cout << " not valid " << std::endl;
113558 : }
113559 : }
113560 :
113561 0 : if ( p_expression_type != NULL )
113562 : {
113563 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113564 : {
113565 0 : if ( p_expression_type->isInMemoryPool() == false )
113566 : {
113567 0 : std::cout << "SgUpcElemsizeofExpression :: ";
113568 0 : std::cout << " p_expression_type is not in memory pool of ";
113569 0 : std::cout << p_expression_type->class_name() << std::endl;
113570 : }
113571 : }
113572 : else
113573 : {
113574 0 : std::cout << "SgUpcElemsizeofExpression :: " << std::flush;
113575 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
113576 0 : std::cout << " not valid " << std::endl;
113577 : }
113578 : }
113579 :
113580 0 : if ( p_operatorPosition != NULL )
113581 : {
113582 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113583 : {
113584 0 : if ( p_operatorPosition->isInMemoryPool() == false )
113585 : {
113586 0 : std::cout << "SgUpcElemsizeofExpression :: ";
113587 0 : std::cout << " p_operatorPosition is not in memory pool of ";
113588 0 : std::cout << p_operatorPosition->class_name() << std::endl;
113589 : }
113590 : }
113591 : else
113592 : {
113593 0 : std::cout << "SgUpcElemsizeofExpression :: " << std::flush;
113594 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
113595 0 : std::cout << " not valid " << std::endl;
113596 : }
113597 : }
113598 :
113599 0 : if ( p_startOfConstruct != NULL )
113600 : {
113601 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113602 : {
113603 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
113604 : {
113605 0 : std::cout << "SgUpcElemsizeofExpression :: ";
113606 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
113607 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
113608 : }
113609 : }
113610 : else
113611 : {
113612 0 : std::cout << "SgUpcElemsizeofExpression :: " << std::flush;
113613 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
113614 0 : std::cout << " not valid " << std::endl;
113615 : }
113616 : }
113617 :
113618 0 : if ( p_endOfConstruct != NULL )
113619 : {
113620 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113621 : {
113622 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
113623 : {
113624 0 : std::cout << "SgUpcElemsizeofExpression :: ";
113625 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
113626 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
113627 : }
113628 : }
113629 : else
113630 : {
113631 0 : std::cout << "SgUpcElemsizeofExpression :: " << std::flush;
113632 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
113633 0 : std::cout << " not valid " << std::endl;
113634 : }
113635 : }
113636 :
113637 0 : if ( p_parent != NULL )
113638 : {
113639 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113640 : {
113641 0 : if ( p_parent->isInMemoryPool() == false )
113642 : {
113643 0 : std::cout << "SgUpcElemsizeofExpression :: ";
113644 0 : std::cout << " p_parent is not in memory pool of ";
113645 0 : std::cout << p_parent->class_name() << std::endl;
113646 : }
113647 : }
113648 : else
113649 : {
113650 0 : std::cout << "SgUpcElemsizeofExpression :: " << std::flush;
113651 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
113652 0 : std::cout << " not valid " << std::endl;
113653 : }
113654 : }
113655 :
113656 :
113657 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
113658 :
113659 0 : }
113660 :
113661 :
113662 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
113663 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
113664 : bool
113665 0 : SgUpcElemsizeofExpression::isInMemoryPool ()
113666 : {
113667 0 : typedef unsigned char* TestType;
113668 :
113669 0 : bool found = false;
113670 :
113671 0 : ROSE_ASSERT(this != NULL);
113672 :
113673 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
113674 :
113675 0 : TestType tested = (TestType) ( this ) ;
113676 :
113677 0 : std::vector < unsigned char* > :: const_iterator block = SgUpcElemsizeofExpression::pools.begin();
113678 :
113679 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
113680 : // while (found == false && block < Memory_Block_List.end())
113681 0 : while ( (found == false) && (block != SgUpcElemsizeofExpression::pools.end()) )
113682 : {
113683 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUpcElemsizeofExpression::pool_size * sizeof(SgUpcElemsizeofExpression) ) ) ;
113684 0 : ++block;
113685 : }
113686 :
113687 : // Special handling for static data
113688 :
113689 :
113690 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
113691 0 : ROSE_ASSERT(found == true);
113692 :
113693 0 : return found;
113694 : }
113695 : /* #line 113696 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
113696 :
113697 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
113698 :
113699 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
113700 :
113701 : /* #line 113702 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
113702 :
113703 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
113704 :
113705 : void
113706 0 : SgSuperExp::checkDataMemberPointersIfInMemoryPool()
113707 : {
113708 : // ------------ checking pointers of SgSuperExp -------------------
113709 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
113710 :
113711 0 : if ( p_class_symbol != NULL )
113712 : {
113713 0 : if ( p_class_symbol->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113714 : {
113715 0 : if ( p_class_symbol->isInMemoryPool() == false )
113716 : {
113717 0 : std::cout << "SgSuperExp :: ";
113718 0 : std::cout << " p_class_symbol is not in memory pool of ";
113719 0 : std::cout << p_class_symbol->class_name() << std::endl;
113720 : }
113721 : }
113722 : else
113723 : {
113724 0 : std::cout << "SgSuperExp :: " << std::flush;
113725 0 : std::cout << "SgClassSymbol* p_class_symbol = " << p_class_symbol << " --> " << std::flush;
113726 0 : std::cout << " not valid " << std::endl;
113727 : }
113728 : }
113729 :
113730 0 : if ( p_operatorPosition != NULL )
113731 : {
113732 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113733 : {
113734 0 : if ( p_operatorPosition->isInMemoryPool() == false )
113735 : {
113736 0 : std::cout << "SgSuperExp :: ";
113737 0 : std::cout << " p_operatorPosition is not in memory pool of ";
113738 0 : std::cout << p_operatorPosition->class_name() << std::endl;
113739 : }
113740 : }
113741 : else
113742 : {
113743 0 : std::cout << "SgSuperExp :: " << std::flush;
113744 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
113745 0 : std::cout << " not valid " << std::endl;
113746 : }
113747 : }
113748 :
113749 0 : if ( p_startOfConstruct != NULL )
113750 : {
113751 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113752 : {
113753 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
113754 : {
113755 0 : std::cout << "SgSuperExp :: ";
113756 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
113757 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
113758 : }
113759 : }
113760 : else
113761 : {
113762 0 : std::cout << "SgSuperExp :: " << std::flush;
113763 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
113764 0 : std::cout << " not valid " << std::endl;
113765 : }
113766 : }
113767 :
113768 0 : if ( p_endOfConstruct != NULL )
113769 : {
113770 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113771 : {
113772 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
113773 : {
113774 0 : std::cout << "SgSuperExp :: ";
113775 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
113776 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
113777 : }
113778 : }
113779 : else
113780 : {
113781 0 : std::cout << "SgSuperExp :: " << std::flush;
113782 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
113783 0 : std::cout << " not valid " << std::endl;
113784 : }
113785 : }
113786 :
113787 0 : if ( p_parent != NULL )
113788 : {
113789 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113790 : {
113791 0 : if ( p_parent->isInMemoryPool() == false )
113792 : {
113793 0 : std::cout << "SgSuperExp :: ";
113794 0 : std::cout << " p_parent is not in memory pool of ";
113795 0 : std::cout << p_parent->class_name() << std::endl;
113796 : }
113797 : }
113798 : else
113799 : {
113800 0 : std::cout << "SgSuperExp :: " << std::flush;
113801 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
113802 0 : std::cout << " not valid " << std::endl;
113803 : }
113804 : }
113805 :
113806 :
113807 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
113808 :
113809 0 : }
113810 :
113811 :
113812 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
113813 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
113814 : bool
113815 0 : SgSuperExp::isInMemoryPool ()
113816 : {
113817 0 : typedef unsigned char* TestType;
113818 :
113819 0 : bool found = false;
113820 :
113821 0 : ROSE_ASSERT(this != NULL);
113822 :
113823 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
113824 :
113825 0 : TestType tested = (TestType) ( this ) ;
113826 :
113827 0 : std::vector < unsigned char* > :: const_iterator block = SgSuperExp::pools.begin();
113828 :
113829 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
113830 : // while (found == false && block < Memory_Block_List.end())
113831 0 : while ( (found == false) && (block != SgSuperExp::pools.end()) )
113832 : {
113833 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSuperExp::pool_size * sizeof(SgSuperExp) ) ) ;
113834 0 : ++block;
113835 : }
113836 :
113837 : // Special handling for static data
113838 :
113839 :
113840 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
113841 0 : ROSE_ASSERT(found == true);
113842 :
113843 0 : return found;
113844 : }
113845 : /* #line 113846 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
113846 :
113847 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
113848 :
113849 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
113850 :
113851 : /* #line 113852 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
113852 :
113853 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
113854 :
113855 : void
113856 0 : SgTypeIdOp::checkDataMemberPointersIfInMemoryPool()
113857 : {
113858 : // ------------ checking pointers of SgTypeIdOp -------------------
113859 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
113860 :
113861 0 : if ( p_operand_expr != NULL )
113862 : {
113863 0 : if ( p_operand_expr->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113864 : {
113865 0 : if ( p_operand_expr->isInMemoryPool() == false )
113866 : {
113867 0 : std::cout << "SgTypeIdOp :: ";
113868 0 : std::cout << " p_operand_expr is not in memory pool of ";
113869 0 : std::cout << p_operand_expr->class_name() << std::endl;
113870 : }
113871 : }
113872 : else
113873 : {
113874 0 : std::cout << "SgTypeIdOp :: " << std::flush;
113875 0 : std::cout << "SgExpression* p_operand_expr = " << p_operand_expr << " --> " << std::flush;
113876 0 : std::cout << " not valid " << std::endl;
113877 : }
113878 : }
113879 :
113880 0 : if ( p_operand_type != NULL )
113881 : {
113882 0 : if ( p_operand_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113883 : {
113884 0 : if ( p_operand_type->isInMemoryPool() == false )
113885 : {
113886 0 : std::cout << "SgTypeIdOp :: ";
113887 0 : std::cout << " p_operand_type is not in memory pool of ";
113888 0 : std::cout << p_operand_type->class_name() << std::endl;
113889 : }
113890 : }
113891 : else
113892 : {
113893 0 : std::cout << "SgTypeIdOp :: " << std::flush;
113894 0 : std::cout << "SgType* p_operand_type = " << p_operand_type << " --> " << std::flush;
113895 0 : std::cout << " not valid " << std::endl;
113896 : }
113897 : }
113898 :
113899 0 : if ( p_operatorPosition != NULL )
113900 : {
113901 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113902 : {
113903 0 : if ( p_operatorPosition->isInMemoryPool() == false )
113904 : {
113905 0 : std::cout << "SgTypeIdOp :: ";
113906 0 : std::cout << " p_operatorPosition is not in memory pool of ";
113907 0 : std::cout << p_operatorPosition->class_name() << std::endl;
113908 : }
113909 : }
113910 : else
113911 : {
113912 0 : std::cout << "SgTypeIdOp :: " << std::flush;
113913 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
113914 0 : std::cout << " not valid " << std::endl;
113915 : }
113916 : }
113917 :
113918 0 : if ( p_startOfConstruct != NULL )
113919 : {
113920 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113921 : {
113922 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
113923 : {
113924 0 : std::cout << "SgTypeIdOp :: ";
113925 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
113926 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
113927 : }
113928 : }
113929 : else
113930 : {
113931 0 : std::cout << "SgTypeIdOp :: " << std::flush;
113932 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
113933 0 : std::cout << " not valid " << std::endl;
113934 : }
113935 : }
113936 :
113937 0 : if ( p_endOfConstruct != NULL )
113938 : {
113939 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113940 : {
113941 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
113942 : {
113943 0 : std::cout << "SgTypeIdOp :: ";
113944 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
113945 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
113946 : }
113947 : }
113948 : else
113949 : {
113950 0 : std::cout << "SgTypeIdOp :: " << std::flush;
113951 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
113952 0 : std::cout << " not valid " << std::endl;
113953 : }
113954 : }
113955 :
113956 0 : if ( p_parent != NULL )
113957 : {
113958 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
113959 : {
113960 0 : if ( p_parent->isInMemoryPool() == false )
113961 : {
113962 0 : std::cout << "SgTypeIdOp :: ";
113963 0 : std::cout << " p_parent is not in memory pool of ";
113964 0 : std::cout << p_parent->class_name() << std::endl;
113965 : }
113966 : }
113967 : else
113968 : {
113969 0 : std::cout << "SgTypeIdOp :: " << std::flush;
113970 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
113971 0 : std::cout << " not valid " << std::endl;
113972 : }
113973 : }
113974 :
113975 :
113976 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
113977 :
113978 0 : }
113979 :
113980 :
113981 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
113982 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
113983 : bool
113984 0 : SgTypeIdOp::isInMemoryPool ()
113985 : {
113986 0 : typedef unsigned char* TestType;
113987 :
113988 0 : bool found = false;
113989 :
113990 0 : ROSE_ASSERT(this != NULL);
113991 :
113992 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
113993 :
113994 0 : TestType tested = (TestType) ( this ) ;
113995 :
113996 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeIdOp::pools.begin();
113997 :
113998 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
113999 : // while (found == false && block < Memory_Block_List.end())
114000 0 : while ( (found == false) && (block != SgTypeIdOp::pools.end()) )
114001 : {
114002 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeIdOp::pool_size * sizeof(SgTypeIdOp) ) ) ;
114003 0 : ++block;
114004 : }
114005 :
114006 : // Special handling for static data
114007 :
114008 :
114009 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
114010 0 : ROSE_ASSERT(found == true);
114011 :
114012 0 : return found;
114013 : }
114014 : /* #line 114015 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
114015 :
114016 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
114017 :
114018 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114019 :
114020 : /* #line 114021 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
114021 :
114022 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114023 :
114024 : void
114025 0 : SgConditionalExp::checkDataMemberPointersIfInMemoryPool()
114026 : {
114027 : // ------------ checking pointers of SgConditionalExp -------------------
114028 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
114029 :
114030 0 : if ( p_conditional_exp != NULL )
114031 : {
114032 0 : if ( p_conditional_exp->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114033 : {
114034 0 : if ( p_conditional_exp->isInMemoryPool() == false )
114035 : {
114036 0 : std::cout << "SgConditionalExp :: ";
114037 0 : std::cout << " p_conditional_exp is not in memory pool of ";
114038 0 : std::cout << p_conditional_exp->class_name() << std::endl;
114039 : }
114040 : }
114041 : else
114042 : {
114043 0 : std::cout << "SgConditionalExp :: " << std::flush;
114044 0 : std::cout << "SgExpression* p_conditional_exp = " << p_conditional_exp << " --> " << std::flush;
114045 0 : std::cout << " not valid " << std::endl;
114046 : }
114047 : }
114048 :
114049 0 : if ( p_true_exp != NULL )
114050 : {
114051 0 : if ( p_true_exp->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114052 : {
114053 0 : if ( p_true_exp->isInMemoryPool() == false )
114054 : {
114055 0 : std::cout << "SgConditionalExp :: ";
114056 0 : std::cout << " p_true_exp is not in memory pool of ";
114057 0 : std::cout << p_true_exp->class_name() << std::endl;
114058 : }
114059 : }
114060 : else
114061 : {
114062 0 : std::cout << "SgConditionalExp :: " << std::flush;
114063 0 : std::cout << "SgExpression* p_true_exp = " << p_true_exp << " --> " << std::flush;
114064 0 : std::cout << " not valid " << std::endl;
114065 : }
114066 : }
114067 :
114068 0 : if ( p_false_exp != NULL )
114069 : {
114070 0 : if ( p_false_exp->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114071 : {
114072 0 : if ( p_false_exp->isInMemoryPool() == false )
114073 : {
114074 0 : std::cout << "SgConditionalExp :: ";
114075 0 : std::cout << " p_false_exp is not in memory pool of ";
114076 0 : std::cout << p_false_exp->class_name() << std::endl;
114077 : }
114078 : }
114079 : else
114080 : {
114081 0 : std::cout << "SgConditionalExp :: " << std::flush;
114082 0 : std::cout << "SgExpression* p_false_exp = " << p_false_exp << " --> " << std::flush;
114083 0 : std::cout << " not valid " << std::endl;
114084 : }
114085 : }
114086 :
114087 0 : if ( p_expression_type != NULL )
114088 : {
114089 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114090 : {
114091 0 : if ( p_expression_type->isInMemoryPool() == false )
114092 : {
114093 0 : std::cout << "SgConditionalExp :: ";
114094 0 : std::cout << " p_expression_type is not in memory pool of ";
114095 0 : std::cout << p_expression_type->class_name() << std::endl;
114096 : }
114097 : }
114098 : else
114099 : {
114100 0 : std::cout << "SgConditionalExp :: " << std::flush;
114101 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
114102 0 : std::cout << " not valid " << std::endl;
114103 : }
114104 : }
114105 :
114106 0 : if ( p_operatorPosition != NULL )
114107 : {
114108 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114109 : {
114110 0 : if ( p_operatorPosition->isInMemoryPool() == false )
114111 : {
114112 0 : std::cout << "SgConditionalExp :: ";
114113 0 : std::cout << " p_operatorPosition is not in memory pool of ";
114114 0 : std::cout << p_operatorPosition->class_name() << std::endl;
114115 : }
114116 : }
114117 : else
114118 : {
114119 0 : std::cout << "SgConditionalExp :: " << std::flush;
114120 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
114121 0 : std::cout << " not valid " << std::endl;
114122 : }
114123 : }
114124 :
114125 0 : if ( p_startOfConstruct != NULL )
114126 : {
114127 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114128 : {
114129 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
114130 : {
114131 0 : std::cout << "SgConditionalExp :: ";
114132 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
114133 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
114134 : }
114135 : }
114136 : else
114137 : {
114138 0 : std::cout << "SgConditionalExp :: " << std::flush;
114139 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
114140 0 : std::cout << " not valid " << std::endl;
114141 : }
114142 : }
114143 :
114144 0 : if ( p_endOfConstruct != NULL )
114145 : {
114146 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114147 : {
114148 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
114149 : {
114150 0 : std::cout << "SgConditionalExp :: ";
114151 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
114152 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
114153 : }
114154 : }
114155 : else
114156 : {
114157 0 : std::cout << "SgConditionalExp :: " << std::flush;
114158 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
114159 0 : std::cout << " not valid " << std::endl;
114160 : }
114161 : }
114162 :
114163 0 : if ( p_parent != NULL )
114164 : {
114165 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114166 : {
114167 0 : if ( p_parent->isInMemoryPool() == false )
114168 : {
114169 0 : std::cout << "SgConditionalExp :: ";
114170 0 : std::cout << " p_parent is not in memory pool of ";
114171 0 : std::cout << p_parent->class_name() << std::endl;
114172 : }
114173 : }
114174 : else
114175 : {
114176 0 : std::cout << "SgConditionalExp :: " << std::flush;
114177 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
114178 0 : std::cout << " not valid " << std::endl;
114179 : }
114180 : }
114181 :
114182 :
114183 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114184 :
114185 0 : }
114186 :
114187 :
114188 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
114189 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
114190 : bool
114191 0 : SgConditionalExp::isInMemoryPool ()
114192 : {
114193 0 : typedef unsigned char* TestType;
114194 :
114195 0 : bool found = false;
114196 :
114197 0 : ROSE_ASSERT(this != NULL);
114198 :
114199 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
114200 :
114201 0 : TestType tested = (TestType) ( this ) ;
114202 :
114203 0 : std::vector < unsigned char* > :: const_iterator block = SgConditionalExp::pools.begin();
114204 :
114205 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
114206 : // while (found == false && block < Memory_Block_List.end())
114207 0 : while ( (found == false) && (block != SgConditionalExp::pools.end()) )
114208 : {
114209 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgConditionalExp::pool_size * sizeof(SgConditionalExp) ) ) ;
114210 0 : ++block;
114211 : }
114212 :
114213 : // Special handling for static data
114214 :
114215 :
114216 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
114217 0 : ROSE_ASSERT(found == true);
114218 :
114219 0 : return found;
114220 : }
114221 : /* #line 114222 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
114222 :
114223 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
114224 :
114225 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114226 :
114227 : /* #line 114228 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
114228 :
114229 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114230 :
114231 : void
114232 0 : SgNewExp::checkDataMemberPointersIfInMemoryPool()
114233 : {
114234 : // ------------ checking pointers of SgNewExp -------------------
114235 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
114236 :
114237 0 : if ( p_specified_type != NULL )
114238 : {
114239 0 : if ( p_specified_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114240 : {
114241 0 : if ( p_specified_type->isInMemoryPool() == false )
114242 : {
114243 0 : std::cout << "SgNewExp :: ";
114244 0 : std::cout << " p_specified_type is not in memory pool of ";
114245 0 : std::cout << p_specified_type->class_name() << std::endl;
114246 : }
114247 : }
114248 : else
114249 : {
114250 0 : std::cout << "SgNewExp :: " << std::flush;
114251 0 : std::cout << "SgType* p_specified_type = " << p_specified_type << " --> " << std::flush;
114252 0 : std::cout << " not valid " << std::endl;
114253 : }
114254 : }
114255 :
114256 0 : if ( p_placement_args != NULL )
114257 : {
114258 0 : if ( p_placement_args->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114259 : {
114260 0 : if ( p_placement_args->isInMemoryPool() == false )
114261 : {
114262 0 : std::cout << "SgNewExp :: ";
114263 0 : std::cout << " p_placement_args is not in memory pool of ";
114264 0 : std::cout << p_placement_args->class_name() << std::endl;
114265 : }
114266 : }
114267 : else
114268 : {
114269 0 : std::cout << "SgNewExp :: " << std::flush;
114270 0 : std::cout << "SgExprListExp* p_placement_args = " << p_placement_args << " --> " << std::flush;
114271 0 : std::cout << " not valid " << std::endl;
114272 : }
114273 : }
114274 :
114275 0 : if ( p_constructor_args != NULL )
114276 : {
114277 0 : if ( p_constructor_args->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114278 : {
114279 0 : if ( p_constructor_args->isInMemoryPool() == false )
114280 : {
114281 0 : std::cout << "SgNewExp :: ";
114282 0 : std::cout << " p_constructor_args is not in memory pool of ";
114283 0 : std::cout << p_constructor_args->class_name() << std::endl;
114284 : }
114285 : }
114286 : else
114287 : {
114288 0 : std::cout << "SgNewExp :: " << std::flush;
114289 0 : std::cout << "SgConstructorInitializer* p_constructor_args = " << p_constructor_args << " --> " << std::flush;
114290 0 : std::cout << " not valid " << std::endl;
114291 : }
114292 : }
114293 :
114294 0 : if ( p_builtin_args != NULL )
114295 : {
114296 0 : if ( p_builtin_args->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114297 : {
114298 0 : if ( p_builtin_args->isInMemoryPool() == false )
114299 : {
114300 0 : std::cout << "SgNewExp :: ";
114301 0 : std::cout << " p_builtin_args is not in memory pool of ";
114302 0 : std::cout << p_builtin_args->class_name() << std::endl;
114303 : }
114304 : }
114305 : else
114306 : {
114307 0 : std::cout << "SgNewExp :: " << std::flush;
114308 0 : std::cout << "SgExpression* p_builtin_args = " << p_builtin_args << " --> " << std::flush;
114309 0 : std::cout << " not valid " << std::endl;
114310 : }
114311 : }
114312 :
114313 0 : if ( p_newOperatorDeclaration != NULL )
114314 : {
114315 0 : if ( p_newOperatorDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114316 : {
114317 0 : if ( p_newOperatorDeclaration->isInMemoryPool() == false )
114318 : {
114319 0 : std::cout << "SgNewExp :: ";
114320 0 : std::cout << " p_newOperatorDeclaration is not in memory pool of ";
114321 0 : std::cout << p_newOperatorDeclaration->class_name() << std::endl;
114322 : }
114323 : }
114324 : else
114325 : {
114326 0 : std::cout << "SgNewExp :: " << std::flush;
114327 0 : std::cout << "SgFunctionDeclaration* p_newOperatorDeclaration = " << p_newOperatorDeclaration << " --> " << std::flush;
114328 0 : std::cout << " not valid " << std::endl;
114329 : }
114330 : }
114331 :
114332 0 : if ( p_operatorPosition != NULL )
114333 : {
114334 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114335 : {
114336 0 : if ( p_operatorPosition->isInMemoryPool() == false )
114337 : {
114338 0 : std::cout << "SgNewExp :: ";
114339 0 : std::cout << " p_operatorPosition is not in memory pool of ";
114340 0 : std::cout << p_operatorPosition->class_name() << std::endl;
114341 : }
114342 : }
114343 : else
114344 : {
114345 0 : std::cout << "SgNewExp :: " << std::flush;
114346 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
114347 0 : std::cout << " not valid " << std::endl;
114348 : }
114349 : }
114350 :
114351 0 : if ( p_startOfConstruct != NULL )
114352 : {
114353 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114354 : {
114355 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
114356 : {
114357 0 : std::cout << "SgNewExp :: ";
114358 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
114359 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
114360 : }
114361 : }
114362 : else
114363 : {
114364 0 : std::cout << "SgNewExp :: " << std::flush;
114365 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
114366 0 : std::cout << " not valid " << std::endl;
114367 : }
114368 : }
114369 :
114370 0 : if ( p_endOfConstruct != NULL )
114371 : {
114372 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114373 : {
114374 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
114375 : {
114376 0 : std::cout << "SgNewExp :: ";
114377 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
114378 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
114379 : }
114380 : }
114381 : else
114382 : {
114383 0 : std::cout << "SgNewExp :: " << std::flush;
114384 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
114385 0 : std::cout << " not valid " << std::endl;
114386 : }
114387 : }
114388 :
114389 0 : if ( p_parent != NULL )
114390 : {
114391 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114392 : {
114393 0 : if ( p_parent->isInMemoryPool() == false )
114394 : {
114395 0 : std::cout << "SgNewExp :: ";
114396 0 : std::cout << " p_parent is not in memory pool of ";
114397 0 : std::cout << p_parent->class_name() << std::endl;
114398 : }
114399 : }
114400 : else
114401 : {
114402 0 : std::cout << "SgNewExp :: " << std::flush;
114403 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
114404 0 : std::cout << " not valid " << std::endl;
114405 : }
114406 : }
114407 :
114408 :
114409 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114410 :
114411 0 : }
114412 :
114413 :
114414 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
114415 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
114416 : bool
114417 0 : SgNewExp::isInMemoryPool ()
114418 : {
114419 0 : typedef unsigned char* TestType;
114420 :
114421 0 : bool found = false;
114422 :
114423 0 : ROSE_ASSERT(this != NULL);
114424 :
114425 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
114426 :
114427 0 : TestType tested = (TestType) ( this ) ;
114428 :
114429 0 : std::vector < unsigned char* > :: const_iterator block = SgNewExp::pools.begin();
114430 :
114431 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
114432 : // while (found == false && block < Memory_Block_List.end())
114433 0 : while ( (found == false) && (block != SgNewExp::pools.end()) )
114434 : {
114435 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNewExp::pool_size * sizeof(SgNewExp) ) ) ;
114436 0 : ++block;
114437 : }
114438 :
114439 : // Special handling for static data
114440 :
114441 :
114442 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
114443 0 : ROSE_ASSERT(found == true);
114444 :
114445 0 : return found;
114446 : }
114447 : /* #line 114448 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
114448 :
114449 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
114450 :
114451 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114452 :
114453 : /* #line 114454 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
114454 :
114455 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114456 :
114457 : void
114458 0 : SgDeleteExp::checkDataMemberPointersIfInMemoryPool()
114459 : {
114460 : // ------------ checking pointers of SgDeleteExp -------------------
114461 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
114462 :
114463 0 : if ( p_variable != NULL )
114464 : {
114465 0 : if ( p_variable->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114466 : {
114467 0 : if ( p_variable->isInMemoryPool() == false )
114468 : {
114469 0 : std::cout << "SgDeleteExp :: ";
114470 0 : std::cout << " p_variable is not in memory pool of ";
114471 0 : std::cout << p_variable->class_name() << std::endl;
114472 : }
114473 : }
114474 : else
114475 : {
114476 0 : std::cout << "SgDeleteExp :: " << std::flush;
114477 0 : std::cout << "SgExpression* p_variable = " << p_variable << " --> " << std::flush;
114478 0 : std::cout << " not valid " << std::endl;
114479 : }
114480 : }
114481 :
114482 0 : if ( p_deleteOperatorDeclaration != NULL )
114483 : {
114484 0 : if ( p_deleteOperatorDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114485 : {
114486 0 : if ( p_deleteOperatorDeclaration->isInMemoryPool() == false )
114487 : {
114488 0 : std::cout << "SgDeleteExp :: ";
114489 0 : std::cout << " p_deleteOperatorDeclaration is not in memory pool of ";
114490 0 : std::cout << p_deleteOperatorDeclaration->class_name() << std::endl;
114491 : }
114492 : }
114493 : else
114494 : {
114495 0 : std::cout << "SgDeleteExp :: " << std::flush;
114496 0 : std::cout << "SgFunctionDeclaration* p_deleteOperatorDeclaration = " << p_deleteOperatorDeclaration << " --> " << std::flush;
114497 0 : std::cout << " not valid " << std::endl;
114498 : }
114499 : }
114500 :
114501 0 : if ( p_operatorPosition != NULL )
114502 : {
114503 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114504 : {
114505 0 : if ( p_operatorPosition->isInMemoryPool() == false )
114506 : {
114507 0 : std::cout << "SgDeleteExp :: ";
114508 0 : std::cout << " p_operatorPosition is not in memory pool of ";
114509 0 : std::cout << p_operatorPosition->class_name() << std::endl;
114510 : }
114511 : }
114512 : else
114513 : {
114514 0 : std::cout << "SgDeleteExp :: " << std::flush;
114515 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
114516 0 : std::cout << " not valid " << std::endl;
114517 : }
114518 : }
114519 :
114520 0 : if ( p_startOfConstruct != NULL )
114521 : {
114522 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114523 : {
114524 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
114525 : {
114526 0 : std::cout << "SgDeleteExp :: ";
114527 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
114528 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
114529 : }
114530 : }
114531 : else
114532 : {
114533 0 : std::cout << "SgDeleteExp :: " << std::flush;
114534 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
114535 0 : std::cout << " not valid " << std::endl;
114536 : }
114537 : }
114538 :
114539 0 : if ( p_endOfConstruct != NULL )
114540 : {
114541 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114542 : {
114543 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
114544 : {
114545 0 : std::cout << "SgDeleteExp :: ";
114546 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
114547 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
114548 : }
114549 : }
114550 : else
114551 : {
114552 0 : std::cout << "SgDeleteExp :: " << std::flush;
114553 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
114554 0 : std::cout << " not valid " << std::endl;
114555 : }
114556 : }
114557 :
114558 0 : if ( p_parent != NULL )
114559 : {
114560 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114561 : {
114562 0 : if ( p_parent->isInMemoryPool() == false )
114563 : {
114564 0 : std::cout << "SgDeleteExp :: ";
114565 0 : std::cout << " p_parent is not in memory pool of ";
114566 0 : std::cout << p_parent->class_name() << std::endl;
114567 : }
114568 : }
114569 : else
114570 : {
114571 0 : std::cout << "SgDeleteExp :: " << std::flush;
114572 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
114573 0 : std::cout << " not valid " << std::endl;
114574 : }
114575 : }
114576 :
114577 :
114578 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114579 :
114580 0 : }
114581 :
114582 :
114583 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
114584 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
114585 : bool
114586 0 : SgDeleteExp::isInMemoryPool ()
114587 : {
114588 0 : typedef unsigned char* TestType;
114589 :
114590 0 : bool found = false;
114591 :
114592 0 : ROSE_ASSERT(this != NULL);
114593 :
114594 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
114595 :
114596 0 : TestType tested = (TestType) ( this ) ;
114597 :
114598 0 : std::vector < unsigned char* > :: const_iterator block = SgDeleteExp::pools.begin();
114599 :
114600 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
114601 : // while (found == false && block < Memory_Block_List.end())
114602 0 : while ( (found == false) && (block != SgDeleteExp::pools.end()) )
114603 : {
114604 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDeleteExp::pool_size * sizeof(SgDeleteExp) ) ) ;
114605 0 : ++block;
114606 : }
114607 :
114608 : // Special handling for static data
114609 :
114610 :
114611 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
114612 0 : ROSE_ASSERT(found == true);
114613 :
114614 0 : return found;
114615 : }
114616 : /* #line 114617 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
114617 :
114618 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
114619 :
114620 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114621 :
114622 : /* #line 114623 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
114623 :
114624 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114625 :
114626 : void
114627 0 : SgThisExp::checkDataMemberPointersIfInMemoryPool()
114628 : {
114629 : // ------------ checking pointers of SgThisExp -------------------
114630 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
114631 :
114632 0 : if ( p_class_symbol != NULL )
114633 : {
114634 0 : if ( p_class_symbol->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114635 : {
114636 0 : if ( p_class_symbol->isInMemoryPool() == false )
114637 : {
114638 0 : std::cout << "SgThisExp :: ";
114639 0 : std::cout << " p_class_symbol is not in memory pool of ";
114640 0 : std::cout << p_class_symbol->class_name() << std::endl;
114641 : }
114642 : }
114643 : else
114644 : {
114645 0 : std::cout << "SgThisExp :: " << std::flush;
114646 0 : std::cout << "SgClassSymbol* p_class_symbol = " << p_class_symbol << " --> " << std::flush;
114647 0 : std::cout << " not valid " << std::endl;
114648 : }
114649 : }
114650 :
114651 0 : if ( p_nonreal_symbol != NULL )
114652 : {
114653 0 : if ( p_nonreal_symbol->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114654 : {
114655 0 : if ( p_nonreal_symbol->isInMemoryPool() == false )
114656 : {
114657 0 : std::cout << "SgThisExp :: ";
114658 0 : std::cout << " p_nonreal_symbol is not in memory pool of ";
114659 0 : std::cout << p_nonreal_symbol->class_name() << std::endl;
114660 : }
114661 : }
114662 : else
114663 : {
114664 0 : std::cout << "SgThisExp :: " << std::flush;
114665 0 : std::cout << "SgNonrealSymbol* p_nonreal_symbol = " << p_nonreal_symbol << " --> " << std::flush;
114666 0 : std::cout << " not valid " << std::endl;
114667 : }
114668 : }
114669 :
114670 0 : if ( p_operatorPosition != NULL )
114671 : {
114672 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114673 : {
114674 0 : if ( p_operatorPosition->isInMemoryPool() == false )
114675 : {
114676 0 : std::cout << "SgThisExp :: ";
114677 0 : std::cout << " p_operatorPosition is not in memory pool of ";
114678 0 : std::cout << p_operatorPosition->class_name() << std::endl;
114679 : }
114680 : }
114681 : else
114682 : {
114683 0 : std::cout << "SgThisExp :: " << std::flush;
114684 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
114685 0 : std::cout << " not valid " << std::endl;
114686 : }
114687 : }
114688 :
114689 0 : if ( p_startOfConstruct != NULL )
114690 : {
114691 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114692 : {
114693 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
114694 : {
114695 0 : std::cout << "SgThisExp :: ";
114696 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
114697 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
114698 : }
114699 : }
114700 : else
114701 : {
114702 0 : std::cout << "SgThisExp :: " << std::flush;
114703 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
114704 0 : std::cout << " not valid " << std::endl;
114705 : }
114706 : }
114707 :
114708 0 : if ( p_endOfConstruct != NULL )
114709 : {
114710 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114711 : {
114712 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
114713 : {
114714 0 : std::cout << "SgThisExp :: ";
114715 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
114716 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
114717 : }
114718 : }
114719 : else
114720 : {
114721 0 : std::cout << "SgThisExp :: " << std::flush;
114722 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
114723 0 : std::cout << " not valid " << std::endl;
114724 : }
114725 : }
114726 :
114727 0 : if ( p_parent != NULL )
114728 : {
114729 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114730 : {
114731 0 : if ( p_parent->isInMemoryPool() == false )
114732 : {
114733 0 : std::cout << "SgThisExp :: ";
114734 0 : std::cout << " p_parent is not in memory pool of ";
114735 0 : std::cout << p_parent->class_name() << std::endl;
114736 : }
114737 : }
114738 : else
114739 : {
114740 0 : std::cout << "SgThisExp :: " << std::flush;
114741 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
114742 0 : std::cout << " not valid " << std::endl;
114743 : }
114744 : }
114745 :
114746 :
114747 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114748 :
114749 0 : }
114750 :
114751 :
114752 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
114753 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
114754 : bool
114755 0 : SgThisExp::isInMemoryPool ()
114756 : {
114757 0 : typedef unsigned char* TestType;
114758 :
114759 0 : bool found = false;
114760 :
114761 0 : ROSE_ASSERT(this != NULL);
114762 :
114763 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
114764 :
114765 0 : TestType tested = (TestType) ( this ) ;
114766 :
114767 0 : std::vector < unsigned char* > :: const_iterator block = SgThisExp::pools.begin();
114768 :
114769 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
114770 : // while (found == false && block < Memory_Block_List.end())
114771 0 : while ( (found == false) && (block != SgThisExp::pools.end()) )
114772 : {
114773 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgThisExp::pool_size * sizeof(SgThisExp) ) ) ;
114774 0 : ++block;
114775 : }
114776 :
114777 : // Special handling for static data
114778 :
114779 :
114780 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
114781 0 : ROSE_ASSERT(found == true);
114782 :
114783 0 : return found;
114784 : }
114785 : /* #line 114786 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
114786 :
114787 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
114788 :
114789 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114790 :
114791 : /* #line 114792 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
114792 :
114793 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114794 :
114795 : void
114796 0 : SgRefExp::checkDataMemberPointersIfInMemoryPool()
114797 : {
114798 : // ------------ checking pointers of SgRefExp -------------------
114799 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
114800 :
114801 0 : if ( p_type_name != NULL )
114802 : {
114803 0 : if ( p_type_name->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114804 : {
114805 0 : if ( p_type_name->isInMemoryPool() == false )
114806 : {
114807 0 : std::cout << "SgRefExp :: ";
114808 0 : std::cout << " p_type_name is not in memory pool of ";
114809 0 : std::cout << p_type_name->class_name() << std::endl;
114810 : }
114811 : }
114812 : else
114813 : {
114814 0 : std::cout << "SgRefExp :: " << std::flush;
114815 0 : std::cout << "SgType* p_type_name = " << p_type_name << " --> " << std::flush;
114816 0 : std::cout << " not valid " << std::endl;
114817 : }
114818 : }
114819 :
114820 0 : if ( p_operatorPosition != NULL )
114821 : {
114822 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114823 : {
114824 0 : if ( p_operatorPosition->isInMemoryPool() == false )
114825 : {
114826 0 : std::cout << "SgRefExp :: ";
114827 0 : std::cout << " p_operatorPosition is not in memory pool of ";
114828 0 : std::cout << p_operatorPosition->class_name() << std::endl;
114829 : }
114830 : }
114831 : else
114832 : {
114833 0 : std::cout << "SgRefExp :: " << std::flush;
114834 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
114835 0 : std::cout << " not valid " << std::endl;
114836 : }
114837 : }
114838 :
114839 0 : if ( p_startOfConstruct != NULL )
114840 : {
114841 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114842 : {
114843 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
114844 : {
114845 0 : std::cout << "SgRefExp :: ";
114846 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
114847 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
114848 : }
114849 : }
114850 : else
114851 : {
114852 0 : std::cout << "SgRefExp :: " << std::flush;
114853 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
114854 0 : std::cout << " not valid " << std::endl;
114855 : }
114856 : }
114857 :
114858 0 : if ( p_endOfConstruct != NULL )
114859 : {
114860 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114861 : {
114862 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
114863 : {
114864 0 : std::cout << "SgRefExp :: ";
114865 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
114866 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
114867 : }
114868 : }
114869 : else
114870 : {
114871 0 : std::cout << "SgRefExp :: " << std::flush;
114872 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
114873 0 : std::cout << " not valid " << std::endl;
114874 : }
114875 : }
114876 :
114877 0 : if ( p_parent != NULL )
114878 : {
114879 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114880 : {
114881 0 : if ( p_parent->isInMemoryPool() == false )
114882 : {
114883 0 : std::cout << "SgRefExp :: ";
114884 0 : std::cout << " p_parent is not in memory pool of ";
114885 0 : std::cout << p_parent->class_name() << std::endl;
114886 : }
114887 : }
114888 : else
114889 : {
114890 0 : std::cout << "SgRefExp :: " << std::flush;
114891 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
114892 0 : std::cout << " not valid " << std::endl;
114893 : }
114894 : }
114895 :
114896 :
114897 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114898 :
114899 0 : }
114900 :
114901 :
114902 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
114903 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
114904 : bool
114905 0 : SgRefExp::isInMemoryPool ()
114906 : {
114907 0 : typedef unsigned char* TestType;
114908 :
114909 0 : bool found = false;
114910 :
114911 0 : ROSE_ASSERT(this != NULL);
114912 :
114913 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
114914 :
114915 0 : TestType tested = (TestType) ( this ) ;
114916 :
114917 0 : std::vector < unsigned char* > :: const_iterator block = SgRefExp::pools.begin();
114918 :
114919 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
114920 : // while (found == false && block < Memory_Block_List.end())
114921 0 : while ( (found == false) && (block != SgRefExp::pools.end()) )
114922 : {
114923 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgRefExp::pool_size * sizeof(SgRefExp) ) ) ;
114924 0 : ++block;
114925 : }
114926 :
114927 : // Special handling for static data
114928 :
114929 :
114930 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
114931 0 : ROSE_ASSERT(found == true);
114932 :
114933 0 : return found;
114934 : }
114935 : /* #line 114936 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
114936 :
114937 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
114938 :
114939 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114940 :
114941 : /* #line 114942 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
114942 :
114943 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
114944 :
114945 : void
114946 0 : SgInitializer::checkDataMemberPointersIfInMemoryPool()
114947 : {
114948 : // ------------ checking pointers of SgInitializer -------------------
114949 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
114950 :
114951 0 : if ( p_operatorPosition != NULL )
114952 : {
114953 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114954 : {
114955 0 : if ( p_operatorPosition->isInMemoryPool() == false )
114956 : {
114957 0 : std::cout << "SgInitializer :: ";
114958 0 : std::cout << " p_operatorPosition is not in memory pool of ";
114959 0 : std::cout << p_operatorPosition->class_name() << std::endl;
114960 : }
114961 : }
114962 : else
114963 : {
114964 0 : std::cout << "SgInitializer :: " << std::flush;
114965 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
114966 0 : std::cout << " not valid " << std::endl;
114967 : }
114968 : }
114969 :
114970 0 : if ( p_startOfConstruct != NULL )
114971 : {
114972 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114973 : {
114974 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
114975 : {
114976 0 : std::cout << "SgInitializer :: ";
114977 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
114978 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
114979 : }
114980 : }
114981 : else
114982 : {
114983 0 : std::cout << "SgInitializer :: " << std::flush;
114984 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
114985 0 : std::cout << " not valid " << std::endl;
114986 : }
114987 : }
114988 :
114989 0 : if ( p_endOfConstruct != NULL )
114990 : {
114991 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
114992 : {
114993 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
114994 : {
114995 0 : std::cout << "SgInitializer :: ";
114996 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
114997 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
114998 : }
114999 : }
115000 : else
115001 : {
115002 0 : std::cout << "SgInitializer :: " << std::flush;
115003 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
115004 0 : std::cout << " not valid " << std::endl;
115005 : }
115006 : }
115007 :
115008 0 : if ( p_parent != NULL )
115009 : {
115010 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115011 : {
115012 0 : if ( p_parent->isInMemoryPool() == false )
115013 : {
115014 0 : std::cout << "SgInitializer :: ";
115015 0 : std::cout << " p_parent is not in memory pool of ";
115016 0 : std::cout << p_parent->class_name() << std::endl;
115017 : }
115018 : }
115019 : else
115020 : {
115021 0 : std::cout << "SgInitializer :: " << std::flush;
115022 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
115023 0 : std::cout << " not valid " << std::endl;
115024 : }
115025 : }
115026 :
115027 :
115028 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115029 :
115030 0 : }
115031 :
115032 :
115033 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
115034 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
115035 : bool
115036 0 : SgInitializer::isInMemoryPool ()
115037 : {
115038 0 : typedef unsigned char* TestType;
115039 :
115040 0 : bool found = false;
115041 :
115042 0 : ROSE_ASSERT(this != NULL);
115043 :
115044 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
115045 :
115046 0 : TestType tested = (TestType) ( this ) ;
115047 :
115048 0 : std::vector < unsigned char* > :: const_iterator block = SgInitializer::pools.begin();
115049 :
115050 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
115051 : // while (found == false && block < Memory_Block_List.end())
115052 0 : while ( (found == false) && (block != SgInitializer::pools.end()) )
115053 : {
115054 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgInitializer::pool_size * sizeof(SgInitializer) ) ) ;
115055 0 : ++block;
115056 : }
115057 :
115058 : // Special handling for static data
115059 :
115060 :
115061 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
115062 0 : ROSE_ASSERT(found == true);
115063 :
115064 0 : return found;
115065 : }
115066 : /* #line 115067 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
115067 :
115068 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
115069 :
115070 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115071 :
115072 : /* #line 115073 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
115073 :
115074 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115075 :
115076 : void
115077 0 : SgAggregateInitializer::checkDataMemberPointersIfInMemoryPool()
115078 : {
115079 : // ------------ checking pointers of SgAggregateInitializer -------------------
115080 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
115081 :
115082 0 : if ( p_initializers != NULL )
115083 : {
115084 0 : if ( p_initializers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115085 : {
115086 0 : if ( p_initializers->isInMemoryPool() == false )
115087 : {
115088 0 : std::cout << "SgAggregateInitializer :: ";
115089 0 : std::cout << " p_initializers is not in memory pool of ";
115090 0 : std::cout << p_initializers->class_name() << std::endl;
115091 : }
115092 : }
115093 : else
115094 : {
115095 0 : std::cout << "SgAggregateInitializer :: " << std::flush;
115096 0 : std::cout << "SgExprListExp* p_initializers = " << p_initializers << " --> " << std::flush;
115097 0 : std::cout << " not valid " << std::endl;
115098 : }
115099 : }
115100 :
115101 0 : if ( p_expression_type != NULL )
115102 : {
115103 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115104 : {
115105 0 : if ( p_expression_type->isInMemoryPool() == false )
115106 : {
115107 0 : std::cout << "SgAggregateInitializer :: ";
115108 0 : std::cout << " p_expression_type is not in memory pool of ";
115109 0 : std::cout << p_expression_type->class_name() << std::endl;
115110 : }
115111 : }
115112 : else
115113 : {
115114 0 : std::cout << "SgAggregateInitializer :: " << std::flush;
115115 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
115116 0 : std::cout << " not valid " << std::endl;
115117 : }
115118 : }
115119 :
115120 0 : if ( p_originalExpressionTree != NULL )
115121 : {
115122 0 : if ( p_originalExpressionTree->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115123 : {
115124 0 : if ( p_originalExpressionTree->isInMemoryPool() == false )
115125 : {
115126 0 : std::cout << "SgAggregateInitializer :: ";
115127 0 : std::cout << " p_originalExpressionTree is not in memory pool of ";
115128 0 : std::cout << p_originalExpressionTree->class_name() << std::endl;
115129 : }
115130 : }
115131 : else
115132 : {
115133 0 : std::cout << "SgAggregateInitializer :: " << std::flush;
115134 0 : std::cout << "SgExpression* p_originalExpressionTree = " << p_originalExpressionTree << " --> " << std::flush;
115135 0 : std::cout << " not valid " << std::endl;
115136 : }
115137 : }
115138 :
115139 0 : if ( p_operatorPosition != NULL )
115140 : {
115141 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115142 : {
115143 0 : if ( p_operatorPosition->isInMemoryPool() == false )
115144 : {
115145 0 : std::cout << "SgAggregateInitializer :: ";
115146 0 : std::cout << " p_operatorPosition is not in memory pool of ";
115147 0 : std::cout << p_operatorPosition->class_name() << std::endl;
115148 : }
115149 : }
115150 : else
115151 : {
115152 0 : std::cout << "SgAggregateInitializer :: " << std::flush;
115153 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
115154 0 : std::cout << " not valid " << std::endl;
115155 : }
115156 : }
115157 :
115158 0 : if ( p_startOfConstruct != NULL )
115159 : {
115160 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115161 : {
115162 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
115163 : {
115164 0 : std::cout << "SgAggregateInitializer :: ";
115165 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
115166 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
115167 : }
115168 : }
115169 : else
115170 : {
115171 0 : std::cout << "SgAggregateInitializer :: " << std::flush;
115172 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
115173 0 : std::cout << " not valid " << std::endl;
115174 : }
115175 : }
115176 :
115177 0 : if ( p_endOfConstruct != NULL )
115178 : {
115179 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115180 : {
115181 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
115182 : {
115183 0 : std::cout << "SgAggregateInitializer :: ";
115184 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
115185 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
115186 : }
115187 : }
115188 : else
115189 : {
115190 0 : std::cout << "SgAggregateInitializer :: " << std::flush;
115191 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
115192 0 : std::cout << " not valid " << std::endl;
115193 : }
115194 : }
115195 :
115196 0 : if ( p_parent != NULL )
115197 : {
115198 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115199 : {
115200 0 : if ( p_parent->isInMemoryPool() == false )
115201 : {
115202 0 : std::cout << "SgAggregateInitializer :: ";
115203 0 : std::cout << " p_parent is not in memory pool of ";
115204 0 : std::cout << p_parent->class_name() << std::endl;
115205 : }
115206 : }
115207 : else
115208 : {
115209 0 : std::cout << "SgAggregateInitializer :: " << std::flush;
115210 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
115211 0 : std::cout << " not valid " << std::endl;
115212 : }
115213 : }
115214 :
115215 :
115216 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115217 :
115218 0 : }
115219 :
115220 :
115221 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
115222 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
115223 : bool
115224 0 : SgAggregateInitializer::isInMemoryPool ()
115225 : {
115226 0 : typedef unsigned char* TestType;
115227 :
115228 0 : bool found = false;
115229 :
115230 0 : ROSE_ASSERT(this != NULL);
115231 :
115232 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
115233 :
115234 0 : TestType tested = (TestType) ( this ) ;
115235 :
115236 0 : std::vector < unsigned char* > :: const_iterator block = SgAggregateInitializer::pools.begin();
115237 :
115238 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
115239 : // while (found == false && block < Memory_Block_List.end())
115240 0 : while ( (found == false) && (block != SgAggregateInitializer::pools.end()) )
115241 : {
115242 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAggregateInitializer::pool_size * sizeof(SgAggregateInitializer) ) ) ;
115243 0 : ++block;
115244 : }
115245 :
115246 : // Special handling for static data
115247 :
115248 :
115249 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
115250 0 : ROSE_ASSERT(found == true);
115251 :
115252 0 : return found;
115253 : }
115254 : /* #line 115255 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
115255 :
115256 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
115257 :
115258 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115259 :
115260 : /* #line 115261 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
115261 :
115262 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115263 :
115264 : void
115265 0 : SgCompoundInitializer::checkDataMemberPointersIfInMemoryPool()
115266 : {
115267 : // ------------ checking pointers of SgCompoundInitializer -------------------
115268 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
115269 :
115270 0 : if ( p_initializers != NULL )
115271 : {
115272 0 : if ( p_initializers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115273 : {
115274 0 : if ( p_initializers->isInMemoryPool() == false )
115275 : {
115276 0 : std::cout << "SgCompoundInitializer :: ";
115277 0 : std::cout << " p_initializers is not in memory pool of ";
115278 0 : std::cout << p_initializers->class_name() << std::endl;
115279 : }
115280 : }
115281 : else
115282 : {
115283 0 : std::cout << "SgCompoundInitializer :: " << std::flush;
115284 0 : std::cout << "SgExprListExp* p_initializers = " << p_initializers << " --> " << std::flush;
115285 0 : std::cout << " not valid " << std::endl;
115286 : }
115287 : }
115288 :
115289 0 : if ( p_expression_type != NULL )
115290 : {
115291 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115292 : {
115293 0 : if ( p_expression_type->isInMemoryPool() == false )
115294 : {
115295 0 : std::cout << "SgCompoundInitializer :: ";
115296 0 : std::cout << " p_expression_type is not in memory pool of ";
115297 0 : std::cout << p_expression_type->class_name() << std::endl;
115298 : }
115299 : }
115300 : else
115301 : {
115302 0 : std::cout << "SgCompoundInitializer :: " << std::flush;
115303 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
115304 0 : std::cout << " not valid " << std::endl;
115305 : }
115306 : }
115307 :
115308 0 : if ( p_operatorPosition != NULL )
115309 : {
115310 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115311 : {
115312 0 : if ( p_operatorPosition->isInMemoryPool() == false )
115313 : {
115314 0 : std::cout << "SgCompoundInitializer :: ";
115315 0 : std::cout << " p_operatorPosition is not in memory pool of ";
115316 0 : std::cout << p_operatorPosition->class_name() << std::endl;
115317 : }
115318 : }
115319 : else
115320 : {
115321 0 : std::cout << "SgCompoundInitializer :: " << std::flush;
115322 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
115323 0 : std::cout << " not valid " << std::endl;
115324 : }
115325 : }
115326 :
115327 0 : if ( p_startOfConstruct != NULL )
115328 : {
115329 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115330 : {
115331 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
115332 : {
115333 0 : std::cout << "SgCompoundInitializer :: ";
115334 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
115335 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
115336 : }
115337 : }
115338 : else
115339 : {
115340 0 : std::cout << "SgCompoundInitializer :: " << std::flush;
115341 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
115342 0 : std::cout << " not valid " << std::endl;
115343 : }
115344 : }
115345 :
115346 0 : if ( p_endOfConstruct != NULL )
115347 : {
115348 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115349 : {
115350 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
115351 : {
115352 0 : std::cout << "SgCompoundInitializer :: ";
115353 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
115354 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
115355 : }
115356 : }
115357 : else
115358 : {
115359 0 : std::cout << "SgCompoundInitializer :: " << std::flush;
115360 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
115361 0 : std::cout << " not valid " << std::endl;
115362 : }
115363 : }
115364 :
115365 0 : if ( p_parent != NULL )
115366 : {
115367 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115368 : {
115369 0 : if ( p_parent->isInMemoryPool() == false )
115370 : {
115371 0 : std::cout << "SgCompoundInitializer :: ";
115372 0 : std::cout << " p_parent is not in memory pool of ";
115373 0 : std::cout << p_parent->class_name() << std::endl;
115374 : }
115375 : }
115376 : else
115377 : {
115378 0 : std::cout << "SgCompoundInitializer :: " << std::flush;
115379 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
115380 0 : std::cout << " not valid " << std::endl;
115381 : }
115382 : }
115383 :
115384 :
115385 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115386 :
115387 0 : }
115388 :
115389 :
115390 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
115391 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
115392 : bool
115393 0 : SgCompoundInitializer::isInMemoryPool ()
115394 : {
115395 0 : typedef unsigned char* TestType;
115396 :
115397 0 : bool found = false;
115398 :
115399 0 : ROSE_ASSERT(this != NULL);
115400 :
115401 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
115402 :
115403 0 : TestType tested = (TestType) ( this ) ;
115404 :
115405 0 : std::vector < unsigned char* > :: const_iterator block = SgCompoundInitializer::pools.begin();
115406 :
115407 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
115408 : // while (found == false && block < Memory_Block_List.end())
115409 0 : while ( (found == false) && (block != SgCompoundInitializer::pools.end()) )
115410 : {
115411 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCompoundInitializer::pool_size * sizeof(SgCompoundInitializer) ) ) ;
115412 0 : ++block;
115413 : }
115414 :
115415 : // Special handling for static data
115416 :
115417 :
115418 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
115419 0 : ROSE_ASSERT(found == true);
115420 :
115421 0 : return found;
115422 : }
115423 : /* #line 115424 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
115424 :
115425 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
115426 :
115427 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115428 :
115429 : /* #line 115430 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
115430 :
115431 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115432 :
115433 : void
115434 0 : SgConstructorInitializer::checkDataMemberPointersIfInMemoryPool()
115435 : {
115436 : // ------------ checking pointers of SgConstructorInitializer -------------------
115437 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
115438 :
115439 0 : if ( p_declaration != NULL )
115440 : {
115441 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115442 : {
115443 0 : if ( p_declaration->isInMemoryPool() == false )
115444 : {
115445 0 : std::cout << "SgConstructorInitializer :: ";
115446 0 : std::cout << " p_declaration is not in memory pool of ";
115447 0 : std::cout << p_declaration->class_name() << std::endl;
115448 : }
115449 : }
115450 : else
115451 : {
115452 0 : std::cout << "SgConstructorInitializer :: " << std::flush;
115453 0 : std::cout << "SgMemberFunctionDeclaration* p_declaration = " << p_declaration << " --> " << std::flush;
115454 0 : std::cout << " not valid " << std::endl;
115455 : }
115456 : }
115457 :
115458 0 : if ( p_args != NULL )
115459 : {
115460 0 : if ( p_args->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115461 : {
115462 0 : if ( p_args->isInMemoryPool() == false )
115463 : {
115464 0 : std::cout << "SgConstructorInitializer :: ";
115465 0 : std::cout << " p_args is not in memory pool of ";
115466 0 : std::cout << p_args->class_name() << std::endl;
115467 : }
115468 : }
115469 : else
115470 : {
115471 0 : std::cout << "SgConstructorInitializer :: " << std::flush;
115472 0 : std::cout << "SgExprListExp* p_args = " << p_args << " --> " << std::flush;
115473 0 : std::cout << " not valid " << std::endl;
115474 : }
115475 : }
115476 :
115477 0 : if ( p_expression_type != NULL )
115478 : {
115479 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115480 : {
115481 0 : if ( p_expression_type->isInMemoryPool() == false )
115482 : {
115483 0 : std::cout << "SgConstructorInitializer :: ";
115484 0 : std::cout << " p_expression_type is not in memory pool of ";
115485 0 : std::cout << p_expression_type->class_name() << std::endl;
115486 : }
115487 : }
115488 : else
115489 : {
115490 0 : std::cout << "SgConstructorInitializer :: " << std::flush;
115491 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
115492 0 : std::cout << " not valid " << std::endl;
115493 : }
115494 : }
115495 :
115496 0 : if ( p_operatorPosition != NULL )
115497 : {
115498 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115499 : {
115500 0 : if ( p_operatorPosition->isInMemoryPool() == false )
115501 : {
115502 0 : std::cout << "SgConstructorInitializer :: ";
115503 0 : std::cout << " p_operatorPosition is not in memory pool of ";
115504 0 : std::cout << p_operatorPosition->class_name() << std::endl;
115505 : }
115506 : }
115507 : else
115508 : {
115509 0 : std::cout << "SgConstructorInitializer :: " << std::flush;
115510 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
115511 0 : std::cout << " not valid " << std::endl;
115512 : }
115513 : }
115514 :
115515 0 : if ( p_startOfConstruct != NULL )
115516 : {
115517 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115518 : {
115519 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
115520 : {
115521 0 : std::cout << "SgConstructorInitializer :: ";
115522 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
115523 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
115524 : }
115525 : }
115526 : else
115527 : {
115528 0 : std::cout << "SgConstructorInitializer :: " << std::flush;
115529 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
115530 0 : std::cout << " not valid " << std::endl;
115531 : }
115532 : }
115533 :
115534 0 : if ( p_endOfConstruct != NULL )
115535 : {
115536 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115537 : {
115538 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
115539 : {
115540 0 : std::cout << "SgConstructorInitializer :: ";
115541 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
115542 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
115543 : }
115544 : }
115545 : else
115546 : {
115547 0 : std::cout << "SgConstructorInitializer :: " << std::flush;
115548 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
115549 0 : std::cout << " not valid " << std::endl;
115550 : }
115551 : }
115552 :
115553 0 : if ( p_parent != NULL )
115554 : {
115555 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115556 : {
115557 0 : if ( p_parent->isInMemoryPool() == false )
115558 : {
115559 0 : std::cout << "SgConstructorInitializer :: ";
115560 0 : std::cout << " p_parent is not in memory pool of ";
115561 0 : std::cout << p_parent->class_name() << std::endl;
115562 : }
115563 : }
115564 : else
115565 : {
115566 0 : std::cout << "SgConstructorInitializer :: " << std::flush;
115567 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
115568 0 : std::cout << " not valid " << std::endl;
115569 : }
115570 : }
115571 :
115572 :
115573 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115574 :
115575 0 : }
115576 :
115577 :
115578 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
115579 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
115580 : bool
115581 0 : SgConstructorInitializer::isInMemoryPool ()
115582 : {
115583 0 : typedef unsigned char* TestType;
115584 :
115585 0 : bool found = false;
115586 :
115587 0 : ROSE_ASSERT(this != NULL);
115588 :
115589 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
115590 :
115591 0 : TestType tested = (TestType) ( this ) ;
115592 :
115593 0 : std::vector < unsigned char* > :: const_iterator block = SgConstructorInitializer::pools.begin();
115594 :
115595 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
115596 : // while (found == false && block < Memory_Block_List.end())
115597 0 : while ( (found == false) && (block != SgConstructorInitializer::pools.end()) )
115598 : {
115599 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgConstructorInitializer::pool_size * sizeof(SgConstructorInitializer) ) ) ;
115600 0 : ++block;
115601 : }
115602 :
115603 : // Special handling for static data
115604 :
115605 :
115606 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
115607 0 : ROSE_ASSERT(found == true);
115608 :
115609 0 : return found;
115610 : }
115611 : /* #line 115612 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
115612 :
115613 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
115614 :
115615 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115616 :
115617 : /* #line 115618 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
115618 :
115619 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115620 :
115621 : void
115622 0 : SgAssignInitializer::checkDataMemberPointersIfInMemoryPool()
115623 : {
115624 : // ------------ checking pointers of SgAssignInitializer -------------------
115625 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
115626 :
115627 0 : if ( p_operand_i != NULL )
115628 : {
115629 0 : if ( p_operand_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115630 : {
115631 0 : if ( p_operand_i->isInMemoryPool() == false )
115632 : {
115633 0 : std::cout << "SgAssignInitializer :: ";
115634 0 : std::cout << " p_operand_i is not in memory pool of ";
115635 0 : std::cout << p_operand_i->class_name() << std::endl;
115636 : }
115637 : }
115638 : else
115639 : {
115640 0 : std::cout << "SgAssignInitializer :: " << std::flush;
115641 0 : std::cout << "SgExpression* p_operand_i = " << p_operand_i << " --> " << std::flush;
115642 0 : std::cout << " not valid " << std::endl;
115643 : }
115644 : }
115645 :
115646 0 : if ( p_expression_type != NULL )
115647 : {
115648 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115649 : {
115650 0 : if ( p_expression_type->isInMemoryPool() == false )
115651 : {
115652 0 : std::cout << "SgAssignInitializer :: ";
115653 0 : std::cout << " p_expression_type is not in memory pool of ";
115654 0 : std::cout << p_expression_type->class_name() << std::endl;
115655 : }
115656 : }
115657 : else
115658 : {
115659 0 : std::cout << "SgAssignInitializer :: " << std::flush;
115660 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
115661 0 : std::cout << " not valid " << std::endl;
115662 : }
115663 : }
115664 :
115665 0 : if ( p_operatorPosition != NULL )
115666 : {
115667 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115668 : {
115669 0 : if ( p_operatorPosition->isInMemoryPool() == false )
115670 : {
115671 0 : std::cout << "SgAssignInitializer :: ";
115672 0 : std::cout << " p_operatorPosition is not in memory pool of ";
115673 0 : std::cout << p_operatorPosition->class_name() << std::endl;
115674 : }
115675 : }
115676 : else
115677 : {
115678 0 : std::cout << "SgAssignInitializer :: " << std::flush;
115679 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
115680 0 : std::cout << " not valid " << std::endl;
115681 : }
115682 : }
115683 :
115684 0 : if ( p_startOfConstruct != NULL )
115685 : {
115686 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115687 : {
115688 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
115689 : {
115690 0 : std::cout << "SgAssignInitializer :: ";
115691 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
115692 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
115693 : }
115694 : }
115695 : else
115696 : {
115697 0 : std::cout << "SgAssignInitializer :: " << std::flush;
115698 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
115699 0 : std::cout << " not valid " << std::endl;
115700 : }
115701 : }
115702 :
115703 0 : if ( p_endOfConstruct != NULL )
115704 : {
115705 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115706 : {
115707 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
115708 : {
115709 0 : std::cout << "SgAssignInitializer :: ";
115710 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
115711 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
115712 : }
115713 : }
115714 : else
115715 : {
115716 0 : std::cout << "SgAssignInitializer :: " << std::flush;
115717 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
115718 0 : std::cout << " not valid " << std::endl;
115719 : }
115720 : }
115721 :
115722 0 : if ( p_parent != NULL )
115723 : {
115724 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115725 : {
115726 0 : if ( p_parent->isInMemoryPool() == false )
115727 : {
115728 0 : std::cout << "SgAssignInitializer :: ";
115729 0 : std::cout << " p_parent is not in memory pool of ";
115730 0 : std::cout << p_parent->class_name() << std::endl;
115731 : }
115732 : }
115733 : else
115734 : {
115735 0 : std::cout << "SgAssignInitializer :: " << std::flush;
115736 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
115737 0 : std::cout << " not valid " << std::endl;
115738 : }
115739 : }
115740 :
115741 :
115742 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115743 :
115744 0 : }
115745 :
115746 :
115747 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
115748 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
115749 : bool
115750 0 : SgAssignInitializer::isInMemoryPool ()
115751 : {
115752 0 : typedef unsigned char* TestType;
115753 :
115754 0 : bool found = false;
115755 :
115756 0 : ROSE_ASSERT(this != NULL);
115757 :
115758 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
115759 :
115760 0 : TestType tested = (TestType) ( this ) ;
115761 :
115762 0 : std::vector < unsigned char* > :: const_iterator block = SgAssignInitializer::pools.begin();
115763 :
115764 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
115765 : // while (found == false && block < Memory_Block_List.end())
115766 0 : while ( (found == false) && (block != SgAssignInitializer::pools.end()) )
115767 : {
115768 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAssignInitializer::pool_size * sizeof(SgAssignInitializer) ) ) ;
115769 0 : ++block;
115770 : }
115771 :
115772 : // Special handling for static data
115773 :
115774 :
115775 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
115776 0 : ROSE_ASSERT(found == true);
115777 :
115778 0 : return found;
115779 : }
115780 : /* #line 115781 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
115781 :
115782 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
115783 :
115784 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115785 :
115786 : /* #line 115787 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
115787 :
115788 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115789 :
115790 : void
115791 0 : SgDesignatedInitializer::checkDataMemberPointersIfInMemoryPool()
115792 : {
115793 : // ------------ checking pointers of SgDesignatedInitializer -------------------
115794 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
115795 :
115796 0 : if ( p_designatorList != NULL )
115797 : {
115798 0 : if ( p_designatorList->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115799 : {
115800 0 : if ( p_designatorList->isInMemoryPool() == false )
115801 : {
115802 0 : std::cout << "SgDesignatedInitializer :: ";
115803 0 : std::cout << " p_designatorList is not in memory pool of ";
115804 0 : std::cout << p_designatorList->class_name() << std::endl;
115805 : }
115806 : }
115807 : else
115808 : {
115809 0 : std::cout << "SgDesignatedInitializer :: " << std::flush;
115810 0 : std::cout << "SgExprListExp* p_designatorList = " << p_designatorList << " --> " << std::flush;
115811 0 : std::cout << " not valid " << std::endl;
115812 : }
115813 : }
115814 :
115815 0 : if ( p_memberInit != NULL )
115816 : {
115817 0 : if ( p_memberInit->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115818 : {
115819 0 : if ( p_memberInit->isInMemoryPool() == false )
115820 : {
115821 0 : std::cout << "SgDesignatedInitializer :: ";
115822 0 : std::cout << " p_memberInit is not in memory pool of ";
115823 0 : std::cout << p_memberInit->class_name() << std::endl;
115824 : }
115825 : }
115826 : else
115827 : {
115828 0 : std::cout << "SgDesignatedInitializer :: " << std::flush;
115829 0 : std::cout << "SgInitializer* p_memberInit = " << p_memberInit << " --> " << std::flush;
115830 0 : std::cout << " not valid " << std::endl;
115831 : }
115832 : }
115833 :
115834 0 : if ( p_operatorPosition != NULL )
115835 : {
115836 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115837 : {
115838 0 : if ( p_operatorPosition->isInMemoryPool() == false )
115839 : {
115840 0 : std::cout << "SgDesignatedInitializer :: ";
115841 0 : std::cout << " p_operatorPosition is not in memory pool of ";
115842 0 : std::cout << p_operatorPosition->class_name() << std::endl;
115843 : }
115844 : }
115845 : else
115846 : {
115847 0 : std::cout << "SgDesignatedInitializer :: " << std::flush;
115848 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
115849 0 : std::cout << " not valid " << std::endl;
115850 : }
115851 : }
115852 :
115853 0 : if ( p_startOfConstruct != NULL )
115854 : {
115855 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115856 : {
115857 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
115858 : {
115859 0 : std::cout << "SgDesignatedInitializer :: ";
115860 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
115861 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
115862 : }
115863 : }
115864 : else
115865 : {
115866 0 : std::cout << "SgDesignatedInitializer :: " << std::flush;
115867 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
115868 0 : std::cout << " not valid " << std::endl;
115869 : }
115870 : }
115871 :
115872 0 : if ( p_endOfConstruct != NULL )
115873 : {
115874 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115875 : {
115876 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
115877 : {
115878 0 : std::cout << "SgDesignatedInitializer :: ";
115879 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
115880 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
115881 : }
115882 : }
115883 : else
115884 : {
115885 0 : std::cout << "SgDesignatedInitializer :: " << std::flush;
115886 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
115887 0 : std::cout << " not valid " << std::endl;
115888 : }
115889 : }
115890 :
115891 0 : if ( p_parent != NULL )
115892 : {
115893 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115894 : {
115895 0 : if ( p_parent->isInMemoryPool() == false )
115896 : {
115897 0 : std::cout << "SgDesignatedInitializer :: ";
115898 0 : std::cout << " p_parent is not in memory pool of ";
115899 0 : std::cout << p_parent->class_name() << std::endl;
115900 : }
115901 : }
115902 : else
115903 : {
115904 0 : std::cout << "SgDesignatedInitializer :: " << std::flush;
115905 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
115906 0 : std::cout << " not valid " << std::endl;
115907 : }
115908 : }
115909 :
115910 :
115911 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115912 :
115913 0 : }
115914 :
115915 :
115916 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
115917 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
115918 : bool
115919 0 : SgDesignatedInitializer::isInMemoryPool ()
115920 : {
115921 0 : typedef unsigned char* TestType;
115922 :
115923 0 : bool found = false;
115924 :
115925 0 : ROSE_ASSERT(this != NULL);
115926 :
115927 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
115928 :
115929 0 : TestType tested = (TestType) ( this ) ;
115930 :
115931 0 : std::vector < unsigned char* > :: const_iterator block = SgDesignatedInitializer::pools.begin();
115932 :
115933 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
115934 : // while (found == false && block < Memory_Block_List.end())
115935 0 : while ( (found == false) && (block != SgDesignatedInitializer::pools.end()) )
115936 : {
115937 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDesignatedInitializer::pool_size * sizeof(SgDesignatedInitializer) ) ) ;
115938 0 : ++block;
115939 : }
115940 :
115941 : // Special handling for static data
115942 :
115943 :
115944 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
115945 0 : ROSE_ASSERT(found == true);
115946 :
115947 0 : return found;
115948 : }
115949 : /* #line 115950 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
115950 :
115951 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
115952 :
115953 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115954 :
115955 : /* #line 115956 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
115956 :
115957 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
115958 :
115959 : void
115960 0 : SgBracedInitializer::checkDataMemberPointersIfInMemoryPool()
115961 : {
115962 : // ------------ checking pointers of SgBracedInitializer -------------------
115963 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
115964 :
115965 0 : if ( p_initializers != NULL )
115966 : {
115967 0 : if ( p_initializers->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115968 : {
115969 0 : if ( p_initializers->isInMemoryPool() == false )
115970 : {
115971 0 : std::cout << "SgBracedInitializer :: ";
115972 0 : std::cout << " p_initializers is not in memory pool of ";
115973 0 : std::cout << p_initializers->class_name() << std::endl;
115974 : }
115975 : }
115976 : else
115977 : {
115978 0 : std::cout << "SgBracedInitializer :: " << std::flush;
115979 0 : std::cout << "SgExprListExp* p_initializers = " << p_initializers << " --> " << std::flush;
115980 0 : std::cout << " not valid " << std::endl;
115981 : }
115982 : }
115983 :
115984 0 : if ( p_expression_type != NULL )
115985 : {
115986 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
115987 : {
115988 0 : if ( p_expression_type->isInMemoryPool() == false )
115989 : {
115990 0 : std::cout << "SgBracedInitializer :: ";
115991 0 : std::cout << " p_expression_type is not in memory pool of ";
115992 0 : std::cout << p_expression_type->class_name() << std::endl;
115993 : }
115994 : }
115995 : else
115996 : {
115997 0 : std::cout << "SgBracedInitializer :: " << std::flush;
115998 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
115999 0 : std::cout << " not valid " << std::endl;
116000 : }
116001 : }
116002 :
116003 0 : if ( p_operatorPosition != NULL )
116004 : {
116005 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116006 : {
116007 0 : if ( p_operatorPosition->isInMemoryPool() == false )
116008 : {
116009 0 : std::cout << "SgBracedInitializer :: ";
116010 0 : std::cout << " p_operatorPosition is not in memory pool of ";
116011 0 : std::cout << p_operatorPosition->class_name() << std::endl;
116012 : }
116013 : }
116014 : else
116015 : {
116016 0 : std::cout << "SgBracedInitializer :: " << std::flush;
116017 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
116018 0 : std::cout << " not valid " << std::endl;
116019 : }
116020 : }
116021 :
116022 0 : if ( p_startOfConstruct != NULL )
116023 : {
116024 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116025 : {
116026 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
116027 : {
116028 0 : std::cout << "SgBracedInitializer :: ";
116029 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
116030 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
116031 : }
116032 : }
116033 : else
116034 : {
116035 0 : std::cout << "SgBracedInitializer :: " << std::flush;
116036 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
116037 0 : std::cout << " not valid " << std::endl;
116038 : }
116039 : }
116040 :
116041 0 : if ( p_endOfConstruct != NULL )
116042 : {
116043 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116044 : {
116045 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
116046 : {
116047 0 : std::cout << "SgBracedInitializer :: ";
116048 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
116049 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
116050 : }
116051 : }
116052 : else
116053 : {
116054 0 : std::cout << "SgBracedInitializer :: " << std::flush;
116055 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
116056 0 : std::cout << " not valid " << std::endl;
116057 : }
116058 : }
116059 :
116060 0 : if ( p_parent != NULL )
116061 : {
116062 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116063 : {
116064 0 : if ( p_parent->isInMemoryPool() == false )
116065 : {
116066 0 : std::cout << "SgBracedInitializer :: ";
116067 0 : std::cout << " p_parent is not in memory pool of ";
116068 0 : std::cout << p_parent->class_name() << std::endl;
116069 : }
116070 : }
116071 : else
116072 : {
116073 0 : std::cout << "SgBracedInitializer :: " << std::flush;
116074 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
116075 0 : std::cout << " not valid " << std::endl;
116076 : }
116077 : }
116078 :
116079 :
116080 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
116081 :
116082 0 : }
116083 :
116084 :
116085 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
116086 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
116087 : bool
116088 0 : SgBracedInitializer::isInMemoryPool ()
116089 : {
116090 0 : typedef unsigned char* TestType;
116091 :
116092 0 : bool found = false;
116093 :
116094 0 : ROSE_ASSERT(this != NULL);
116095 :
116096 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
116097 :
116098 0 : TestType tested = (TestType) ( this ) ;
116099 :
116100 0 : std::vector < unsigned char* > :: const_iterator block = SgBracedInitializer::pools.begin();
116101 :
116102 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
116103 : // while (found == false && block < Memory_Block_List.end())
116104 0 : while ( (found == false) && (block != SgBracedInitializer::pools.end()) )
116105 : {
116106 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgBracedInitializer::pool_size * sizeof(SgBracedInitializer) ) ) ;
116107 0 : ++block;
116108 : }
116109 :
116110 : // Special handling for static data
116111 :
116112 :
116113 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
116114 0 : ROSE_ASSERT(found == true);
116115 :
116116 0 : return found;
116117 : }
116118 : /* #line 116119 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
116119 :
116120 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
116121 :
116122 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
116123 :
116124 : /* #line 116125 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
116125 :
116126 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
116127 :
116128 : void
116129 0 : SgVarArgStartOp::checkDataMemberPointersIfInMemoryPool()
116130 : {
116131 : // ------------ checking pointers of SgVarArgStartOp -------------------
116132 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
116133 :
116134 0 : if ( p_lhs_operand != NULL )
116135 : {
116136 0 : if ( p_lhs_operand->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116137 : {
116138 0 : if ( p_lhs_operand->isInMemoryPool() == false )
116139 : {
116140 0 : std::cout << "SgVarArgStartOp :: ";
116141 0 : std::cout << " p_lhs_operand is not in memory pool of ";
116142 0 : std::cout << p_lhs_operand->class_name() << std::endl;
116143 : }
116144 : }
116145 : else
116146 : {
116147 0 : std::cout << "SgVarArgStartOp :: " << std::flush;
116148 0 : std::cout << "SgExpression* p_lhs_operand = " << p_lhs_operand << " --> " << std::flush;
116149 0 : std::cout << " not valid " << std::endl;
116150 : }
116151 : }
116152 :
116153 0 : if ( p_rhs_operand != NULL )
116154 : {
116155 0 : if ( p_rhs_operand->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116156 : {
116157 0 : if ( p_rhs_operand->isInMemoryPool() == false )
116158 : {
116159 0 : std::cout << "SgVarArgStartOp :: ";
116160 0 : std::cout << " p_rhs_operand is not in memory pool of ";
116161 0 : std::cout << p_rhs_operand->class_name() << std::endl;
116162 : }
116163 : }
116164 : else
116165 : {
116166 0 : std::cout << "SgVarArgStartOp :: " << std::flush;
116167 0 : std::cout << "SgExpression* p_rhs_operand = " << p_rhs_operand << " --> " << std::flush;
116168 0 : std::cout << " not valid " << std::endl;
116169 : }
116170 : }
116171 :
116172 0 : if ( p_expression_type != NULL )
116173 : {
116174 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116175 : {
116176 0 : if ( p_expression_type->isInMemoryPool() == false )
116177 : {
116178 0 : std::cout << "SgVarArgStartOp :: ";
116179 0 : std::cout << " p_expression_type is not in memory pool of ";
116180 0 : std::cout << p_expression_type->class_name() << std::endl;
116181 : }
116182 : }
116183 : else
116184 : {
116185 0 : std::cout << "SgVarArgStartOp :: " << std::flush;
116186 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
116187 0 : std::cout << " not valid " << std::endl;
116188 : }
116189 : }
116190 :
116191 0 : if ( p_operatorPosition != NULL )
116192 : {
116193 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116194 : {
116195 0 : if ( p_operatorPosition->isInMemoryPool() == false )
116196 : {
116197 0 : std::cout << "SgVarArgStartOp :: ";
116198 0 : std::cout << " p_operatorPosition is not in memory pool of ";
116199 0 : std::cout << p_operatorPosition->class_name() << std::endl;
116200 : }
116201 : }
116202 : else
116203 : {
116204 0 : std::cout << "SgVarArgStartOp :: " << std::flush;
116205 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
116206 0 : std::cout << " not valid " << std::endl;
116207 : }
116208 : }
116209 :
116210 0 : if ( p_startOfConstruct != NULL )
116211 : {
116212 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116213 : {
116214 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
116215 : {
116216 0 : std::cout << "SgVarArgStartOp :: ";
116217 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
116218 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
116219 : }
116220 : }
116221 : else
116222 : {
116223 0 : std::cout << "SgVarArgStartOp :: " << std::flush;
116224 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
116225 0 : std::cout << " not valid " << std::endl;
116226 : }
116227 : }
116228 :
116229 0 : if ( p_endOfConstruct != NULL )
116230 : {
116231 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116232 : {
116233 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
116234 : {
116235 0 : std::cout << "SgVarArgStartOp :: ";
116236 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
116237 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
116238 : }
116239 : }
116240 : else
116241 : {
116242 0 : std::cout << "SgVarArgStartOp :: " << std::flush;
116243 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
116244 0 : std::cout << " not valid " << std::endl;
116245 : }
116246 : }
116247 :
116248 0 : if ( p_parent != NULL )
116249 : {
116250 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116251 : {
116252 0 : if ( p_parent->isInMemoryPool() == false )
116253 : {
116254 0 : std::cout << "SgVarArgStartOp :: ";
116255 0 : std::cout << " p_parent is not in memory pool of ";
116256 0 : std::cout << p_parent->class_name() << std::endl;
116257 : }
116258 : }
116259 : else
116260 : {
116261 0 : std::cout << "SgVarArgStartOp :: " << std::flush;
116262 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
116263 0 : std::cout << " not valid " << std::endl;
116264 : }
116265 : }
116266 :
116267 :
116268 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
116269 :
116270 0 : }
116271 :
116272 :
116273 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
116274 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
116275 : bool
116276 0 : SgVarArgStartOp::isInMemoryPool ()
116277 : {
116278 0 : typedef unsigned char* TestType;
116279 :
116280 0 : bool found = false;
116281 :
116282 0 : ROSE_ASSERT(this != NULL);
116283 :
116284 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
116285 :
116286 0 : TestType tested = (TestType) ( this ) ;
116287 :
116288 0 : std::vector < unsigned char* > :: const_iterator block = SgVarArgStartOp::pools.begin();
116289 :
116290 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
116291 : // while (found == false && block < Memory_Block_List.end())
116292 0 : while ( (found == false) && (block != SgVarArgStartOp::pools.end()) )
116293 : {
116294 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgVarArgStartOp::pool_size * sizeof(SgVarArgStartOp) ) ) ;
116295 0 : ++block;
116296 : }
116297 :
116298 : // Special handling for static data
116299 :
116300 :
116301 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
116302 0 : ROSE_ASSERT(found == true);
116303 :
116304 0 : return found;
116305 : }
116306 : /* #line 116307 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
116307 :
116308 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
116309 :
116310 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
116311 :
116312 : /* #line 116313 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
116313 :
116314 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
116315 :
116316 : void
116317 0 : SgVarArgOp::checkDataMemberPointersIfInMemoryPool()
116318 : {
116319 : // ------------ checking pointers of SgVarArgOp -------------------
116320 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
116321 :
116322 0 : if ( p_operand_expr != NULL )
116323 : {
116324 0 : if ( p_operand_expr->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116325 : {
116326 0 : if ( p_operand_expr->isInMemoryPool() == false )
116327 : {
116328 0 : std::cout << "SgVarArgOp :: ";
116329 0 : std::cout << " p_operand_expr is not in memory pool of ";
116330 0 : std::cout << p_operand_expr->class_name() << std::endl;
116331 : }
116332 : }
116333 : else
116334 : {
116335 0 : std::cout << "SgVarArgOp :: " << std::flush;
116336 0 : std::cout << "SgExpression* p_operand_expr = " << p_operand_expr << " --> " << std::flush;
116337 0 : std::cout << " not valid " << std::endl;
116338 : }
116339 : }
116340 :
116341 0 : if ( p_expression_type != NULL )
116342 : {
116343 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116344 : {
116345 0 : if ( p_expression_type->isInMemoryPool() == false )
116346 : {
116347 0 : std::cout << "SgVarArgOp :: ";
116348 0 : std::cout << " p_expression_type is not in memory pool of ";
116349 0 : std::cout << p_expression_type->class_name() << std::endl;
116350 : }
116351 : }
116352 : else
116353 : {
116354 0 : std::cout << "SgVarArgOp :: " << std::flush;
116355 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
116356 0 : std::cout << " not valid " << std::endl;
116357 : }
116358 : }
116359 :
116360 0 : if ( p_operatorPosition != NULL )
116361 : {
116362 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116363 : {
116364 0 : if ( p_operatorPosition->isInMemoryPool() == false )
116365 : {
116366 0 : std::cout << "SgVarArgOp :: ";
116367 0 : std::cout << " p_operatorPosition is not in memory pool of ";
116368 0 : std::cout << p_operatorPosition->class_name() << std::endl;
116369 : }
116370 : }
116371 : else
116372 : {
116373 0 : std::cout << "SgVarArgOp :: " << std::flush;
116374 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
116375 0 : std::cout << " not valid " << std::endl;
116376 : }
116377 : }
116378 :
116379 0 : if ( p_startOfConstruct != NULL )
116380 : {
116381 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116382 : {
116383 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
116384 : {
116385 0 : std::cout << "SgVarArgOp :: ";
116386 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
116387 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
116388 : }
116389 : }
116390 : else
116391 : {
116392 0 : std::cout << "SgVarArgOp :: " << std::flush;
116393 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
116394 0 : std::cout << " not valid " << std::endl;
116395 : }
116396 : }
116397 :
116398 0 : if ( p_endOfConstruct != NULL )
116399 : {
116400 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116401 : {
116402 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
116403 : {
116404 0 : std::cout << "SgVarArgOp :: ";
116405 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
116406 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
116407 : }
116408 : }
116409 : else
116410 : {
116411 0 : std::cout << "SgVarArgOp :: " << std::flush;
116412 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
116413 0 : std::cout << " not valid " << std::endl;
116414 : }
116415 : }
116416 :
116417 0 : if ( p_parent != NULL )
116418 : {
116419 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116420 : {
116421 0 : if ( p_parent->isInMemoryPool() == false )
116422 : {
116423 0 : std::cout << "SgVarArgOp :: ";
116424 0 : std::cout << " p_parent is not in memory pool of ";
116425 0 : std::cout << p_parent->class_name() << std::endl;
116426 : }
116427 : }
116428 : else
116429 : {
116430 0 : std::cout << "SgVarArgOp :: " << std::flush;
116431 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
116432 0 : std::cout << " not valid " << std::endl;
116433 : }
116434 : }
116435 :
116436 :
116437 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
116438 :
116439 0 : }
116440 :
116441 :
116442 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
116443 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
116444 : bool
116445 0 : SgVarArgOp::isInMemoryPool ()
116446 : {
116447 0 : typedef unsigned char* TestType;
116448 :
116449 0 : bool found = false;
116450 :
116451 0 : ROSE_ASSERT(this != NULL);
116452 :
116453 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
116454 :
116455 0 : TestType tested = (TestType) ( this ) ;
116456 :
116457 0 : std::vector < unsigned char* > :: const_iterator block = SgVarArgOp::pools.begin();
116458 :
116459 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
116460 : // while (found == false && block < Memory_Block_List.end())
116461 0 : while ( (found == false) && (block != SgVarArgOp::pools.end()) )
116462 : {
116463 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgVarArgOp::pool_size * sizeof(SgVarArgOp) ) ) ;
116464 0 : ++block;
116465 : }
116466 :
116467 : // Special handling for static data
116468 :
116469 :
116470 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
116471 0 : ROSE_ASSERT(found == true);
116472 :
116473 0 : return found;
116474 : }
116475 : /* #line 116476 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
116476 :
116477 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
116478 :
116479 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
116480 :
116481 : /* #line 116482 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
116482 :
116483 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
116484 :
116485 : void
116486 0 : SgVarArgEndOp::checkDataMemberPointersIfInMemoryPool()
116487 : {
116488 : // ------------ checking pointers of SgVarArgEndOp -------------------
116489 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
116490 :
116491 0 : if ( p_operand_expr != NULL )
116492 : {
116493 0 : if ( p_operand_expr->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116494 : {
116495 0 : if ( p_operand_expr->isInMemoryPool() == false )
116496 : {
116497 0 : std::cout << "SgVarArgEndOp :: ";
116498 0 : std::cout << " p_operand_expr is not in memory pool of ";
116499 0 : std::cout << p_operand_expr->class_name() << std::endl;
116500 : }
116501 : }
116502 : else
116503 : {
116504 0 : std::cout << "SgVarArgEndOp :: " << std::flush;
116505 0 : std::cout << "SgExpression* p_operand_expr = " << p_operand_expr << " --> " << std::flush;
116506 0 : std::cout << " not valid " << std::endl;
116507 : }
116508 : }
116509 :
116510 0 : if ( p_expression_type != NULL )
116511 : {
116512 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116513 : {
116514 0 : if ( p_expression_type->isInMemoryPool() == false )
116515 : {
116516 0 : std::cout << "SgVarArgEndOp :: ";
116517 0 : std::cout << " p_expression_type is not in memory pool of ";
116518 0 : std::cout << p_expression_type->class_name() << std::endl;
116519 : }
116520 : }
116521 : else
116522 : {
116523 0 : std::cout << "SgVarArgEndOp :: " << std::flush;
116524 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
116525 0 : std::cout << " not valid " << std::endl;
116526 : }
116527 : }
116528 :
116529 0 : if ( p_operatorPosition != NULL )
116530 : {
116531 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116532 : {
116533 0 : if ( p_operatorPosition->isInMemoryPool() == false )
116534 : {
116535 0 : std::cout << "SgVarArgEndOp :: ";
116536 0 : std::cout << " p_operatorPosition is not in memory pool of ";
116537 0 : std::cout << p_operatorPosition->class_name() << std::endl;
116538 : }
116539 : }
116540 : else
116541 : {
116542 0 : std::cout << "SgVarArgEndOp :: " << std::flush;
116543 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
116544 0 : std::cout << " not valid " << std::endl;
116545 : }
116546 : }
116547 :
116548 0 : if ( p_startOfConstruct != NULL )
116549 : {
116550 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116551 : {
116552 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
116553 : {
116554 0 : std::cout << "SgVarArgEndOp :: ";
116555 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
116556 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
116557 : }
116558 : }
116559 : else
116560 : {
116561 0 : std::cout << "SgVarArgEndOp :: " << std::flush;
116562 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
116563 0 : std::cout << " not valid " << std::endl;
116564 : }
116565 : }
116566 :
116567 0 : if ( p_endOfConstruct != NULL )
116568 : {
116569 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116570 : {
116571 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
116572 : {
116573 0 : std::cout << "SgVarArgEndOp :: ";
116574 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
116575 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
116576 : }
116577 : }
116578 : else
116579 : {
116580 0 : std::cout << "SgVarArgEndOp :: " << std::flush;
116581 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
116582 0 : std::cout << " not valid " << std::endl;
116583 : }
116584 : }
116585 :
116586 0 : if ( p_parent != NULL )
116587 : {
116588 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116589 : {
116590 0 : if ( p_parent->isInMemoryPool() == false )
116591 : {
116592 0 : std::cout << "SgVarArgEndOp :: ";
116593 0 : std::cout << " p_parent is not in memory pool of ";
116594 0 : std::cout << p_parent->class_name() << std::endl;
116595 : }
116596 : }
116597 : else
116598 : {
116599 0 : std::cout << "SgVarArgEndOp :: " << std::flush;
116600 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
116601 0 : std::cout << " not valid " << std::endl;
116602 : }
116603 : }
116604 :
116605 :
116606 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
116607 :
116608 0 : }
116609 :
116610 :
116611 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
116612 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
116613 : bool
116614 0 : SgVarArgEndOp::isInMemoryPool ()
116615 : {
116616 0 : typedef unsigned char* TestType;
116617 :
116618 0 : bool found = false;
116619 :
116620 0 : ROSE_ASSERT(this != NULL);
116621 :
116622 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
116623 :
116624 0 : TestType tested = (TestType) ( this ) ;
116625 :
116626 0 : std::vector < unsigned char* > :: const_iterator block = SgVarArgEndOp::pools.begin();
116627 :
116628 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
116629 : // while (found == false && block < Memory_Block_List.end())
116630 0 : while ( (found == false) && (block != SgVarArgEndOp::pools.end()) )
116631 : {
116632 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgVarArgEndOp::pool_size * sizeof(SgVarArgEndOp) ) ) ;
116633 0 : ++block;
116634 : }
116635 :
116636 : // Special handling for static data
116637 :
116638 :
116639 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
116640 0 : ROSE_ASSERT(found == true);
116641 :
116642 0 : return found;
116643 : }
116644 : /* #line 116645 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
116645 :
116646 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
116647 :
116648 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
116649 :
116650 : /* #line 116651 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
116651 :
116652 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
116653 :
116654 : void
116655 0 : SgVarArgCopyOp::checkDataMemberPointersIfInMemoryPool()
116656 : {
116657 : // ------------ checking pointers of SgVarArgCopyOp -------------------
116658 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
116659 :
116660 0 : if ( p_lhs_operand != NULL )
116661 : {
116662 0 : if ( p_lhs_operand->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116663 : {
116664 0 : if ( p_lhs_operand->isInMemoryPool() == false )
116665 : {
116666 0 : std::cout << "SgVarArgCopyOp :: ";
116667 0 : std::cout << " p_lhs_operand is not in memory pool of ";
116668 0 : std::cout << p_lhs_operand->class_name() << std::endl;
116669 : }
116670 : }
116671 : else
116672 : {
116673 0 : std::cout << "SgVarArgCopyOp :: " << std::flush;
116674 0 : std::cout << "SgExpression* p_lhs_operand = " << p_lhs_operand << " --> " << std::flush;
116675 0 : std::cout << " not valid " << std::endl;
116676 : }
116677 : }
116678 :
116679 0 : if ( p_rhs_operand != NULL )
116680 : {
116681 0 : if ( p_rhs_operand->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116682 : {
116683 0 : if ( p_rhs_operand->isInMemoryPool() == false )
116684 : {
116685 0 : std::cout << "SgVarArgCopyOp :: ";
116686 0 : std::cout << " p_rhs_operand is not in memory pool of ";
116687 0 : std::cout << p_rhs_operand->class_name() << std::endl;
116688 : }
116689 : }
116690 : else
116691 : {
116692 0 : std::cout << "SgVarArgCopyOp :: " << std::flush;
116693 0 : std::cout << "SgExpression* p_rhs_operand = " << p_rhs_operand << " --> " << std::flush;
116694 0 : std::cout << " not valid " << std::endl;
116695 : }
116696 : }
116697 :
116698 0 : if ( p_expression_type != NULL )
116699 : {
116700 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116701 : {
116702 0 : if ( p_expression_type->isInMemoryPool() == false )
116703 : {
116704 0 : std::cout << "SgVarArgCopyOp :: ";
116705 0 : std::cout << " p_expression_type is not in memory pool of ";
116706 0 : std::cout << p_expression_type->class_name() << std::endl;
116707 : }
116708 : }
116709 : else
116710 : {
116711 0 : std::cout << "SgVarArgCopyOp :: " << std::flush;
116712 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
116713 0 : std::cout << " not valid " << std::endl;
116714 : }
116715 : }
116716 :
116717 0 : if ( p_operatorPosition != NULL )
116718 : {
116719 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116720 : {
116721 0 : if ( p_operatorPosition->isInMemoryPool() == false )
116722 : {
116723 0 : std::cout << "SgVarArgCopyOp :: ";
116724 0 : std::cout << " p_operatorPosition is not in memory pool of ";
116725 0 : std::cout << p_operatorPosition->class_name() << std::endl;
116726 : }
116727 : }
116728 : else
116729 : {
116730 0 : std::cout << "SgVarArgCopyOp :: " << std::flush;
116731 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
116732 0 : std::cout << " not valid " << std::endl;
116733 : }
116734 : }
116735 :
116736 0 : if ( p_startOfConstruct != NULL )
116737 : {
116738 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116739 : {
116740 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
116741 : {
116742 0 : std::cout << "SgVarArgCopyOp :: ";
116743 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
116744 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
116745 : }
116746 : }
116747 : else
116748 : {
116749 0 : std::cout << "SgVarArgCopyOp :: " << std::flush;
116750 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
116751 0 : std::cout << " not valid " << std::endl;
116752 : }
116753 : }
116754 :
116755 0 : if ( p_endOfConstruct != NULL )
116756 : {
116757 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116758 : {
116759 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
116760 : {
116761 0 : std::cout << "SgVarArgCopyOp :: ";
116762 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
116763 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
116764 : }
116765 : }
116766 : else
116767 : {
116768 0 : std::cout << "SgVarArgCopyOp :: " << std::flush;
116769 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
116770 0 : std::cout << " not valid " << std::endl;
116771 : }
116772 : }
116773 :
116774 0 : if ( p_parent != NULL )
116775 : {
116776 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116777 : {
116778 0 : if ( p_parent->isInMemoryPool() == false )
116779 : {
116780 0 : std::cout << "SgVarArgCopyOp :: ";
116781 0 : std::cout << " p_parent is not in memory pool of ";
116782 0 : std::cout << p_parent->class_name() << std::endl;
116783 : }
116784 : }
116785 : else
116786 : {
116787 0 : std::cout << "SgVarArgCopyOp :: " << std::flush;
116788 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
116789 0 : std::cout << " not valid " << std::endl;
116790 : }
116791 : }
116792 :
116793 :
116794 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
116795 :
116796 0 : }
116797 :
116798 :
116799 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
116800 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
116801 : bool
116802 0 : SgVarArgCopyOp::isInMemoryPool ()
116803 : {
116804 0 : typedef unsigned char* TestType;
116805 :
116806 0 : bool found = false;
116807 :
116808 0 : ROSE_ASSERT(this != NULL);
116809 :
116810 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
116811 :
116812 0 : TestType tested = (TestType) ( this ) ;
116813 :
116814 0 : std::vector < unsigned char* > :: const_iterator block = SgVarArgCopyOp::pools.begin();
116815 :
116816 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
116817 : // while (found == false && block < Memory_Block_List.end())
116818 0 : while ( (found == false) && (block != SgVarArgCopyOp::pools.end()) )
116819 : {
116820 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgVarArgCopyOp::pool_size * sizeof(SgVarArgCopyOp) ) ) ;
116821 0 : ++block;
116822 : }
116823 :
116824 : // Special handling for static data
116825 :
116826 :
116827 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
116828 0 : ROSE_ASSERT(found == true);
116829 :
116830 0 : return found;
116831 : }
116832 : /* #line 116833 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
116833 :
116834 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
116835 :
116836 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
116837 :
116838 : /* #line 116839 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
116839 :
116840 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
116841 :
116842 : void
116843 0 : SgVarArgStartOneOperandOp::checkDataMemberPointersIfInMemoryPool()
116844 : {
116845 : // ------------ checking pointers of SgVarArgStartOneOperandOp -------------------
116846 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
116847 :
116848 0 : if ( p_operand_expr != NULL )
116849 : {
116850 0 : if ( p_operand_expr->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116851 : {
116852 0 : if ( p_operand_expr->isInMemoryPool() == false )
116853 : {
116854 0 : std::cout << "SgVarArgStartOneOperandOp :: ";
116855 0 : std::cout << " p_operand_expr is not in memory pool of ";
116856 0 : std::cout << p_operand_expr->class_name() << std::endl;
116857 : }
116858 : }
116859 : else
116860 : {
116861 0 : std::cout << "SgVarArgStartOneOperandOp :: " << std::flush;
116862 0 : std::cout << "SgExpression* p_operand_expr = " << p_operand_expr << " --> " << std::flush;
116863 0 : std::cout << " not valid " << std::endl;
116864 : }
116865 : }
116866 :
116867 0 : if ( p_expression_type != NULL )
116868 : {
116869 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116870 : {
116871 0 : if ( p_expression_type->isInMemoryPool() == false )
116872 : {
116873 0 : std::cout << "SgVarArgStartOneOperandOp :: ";
116874 0 : std::cout << " p_expression_type is not in memory pool of ";
116875 0 : std::cout << p_expression_type->class_name() << std::endl;
116876 : }
116877 : }
116878 : else
116879 : {
116880 0 : std::cout << "SgVarArgStartOneOperandOp :: " << std::flush;
116881 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
116882 0 : std::cout << " not valid " << std::endl;
116883 : }
116884 : }
116885 :
116886 0 : if ( p_operatorPosition != NULL )
116887 : {
116888 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116889 : {
116890 0 : if ( p_operatorPosition->isInMemoryPool() == false )
116891 : {
116892 0 : std::cout << "SgVarArgStartOneOperandOp :: ";
116893 0 : std::cout << " p_operatorPosition is not in memory pool of ";
116894 0 : std::cout << p_operatorPosition->class_name() << std::endl;
116895 : }
116896 : }
116897 : else
116898 : {
116899 0 : std::cout << "SgVarArgStartOneOperandOp :: " << std::flush;
116900 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
116901 0 : std::cout << " not valid " << std::endl;
116902 : }
116903 : }
116904 :
116905 0 : if ( p_startOfConstruct != NULL )
116906 : {
116907 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116908 : {
116909 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
116910 : {
116911 0 : std::cout << "SgVarArgStartOneOperandOp :: ";
116912 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
116913 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
116914 : }
116915 : }
116916 : else
116917 : {
116918 0 : std::cout << "SgVarArgStartOneOperandOp :: " << std::flush;
116919 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
116920 0 : std::cout << " not valid " << std::endl;
116921 : }
116922 : }
116923 :
116924 0 : if ( p_endOfConstruct != NULL )
116925 : {
116926 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116927 : {
116928 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
116929 : {
116930 0 : std::cout << "SgVarArgStartOneOperandOp :: ";
116931 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
116932 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
116933 : }
116934 : }
116935 : else
116936 : {
116937 0 : std::cout << "SgVarArgStartOneOperandOp :: " << std::flush;
116938 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
116939 0 : std::cout << " not valid " << std::endl;
116940 : }
116941 : }
116942 :
116943 0 : if ( p_parent != NULL )
116944 : {
116945 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
116946 : {
116947 0 : if ( p_parent->isInMemoryPool() == false )
116948 : {
116949 0 : std::cout << "SgVarArgStartOneOperandOp :: ";
116950 0 : std::cout << " p_parent is not in memory pool of ";
116951 0 : std::cout << p_parent->class_name() << std::endl;
116952 : }
116953 : }
116954 : else
116955 : {
116956 0 : std::cout << "SgVarArgStartOneOperandOp :: " << std::flush;
116957 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
116958 0 : std::cout << " not valid " << std::endl;
116959 : }
116960 : }
116961 :
116962 :
116963 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
116964 :
116965 0 : }
116966 :
116967 :
116968 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
116969 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
116970 : bool
116971 0 : SgVarArgStartOneOperandOp::isInMemoryPool ()
116972 : {
116973 0 : typedef unsigned char* TestType;
116974 :
116975 0 : bool found = false;
116976 :
116977 0 : ROSE_ASSERT(this != NULL);
116978 :
116979 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
116980 :
116981 0 : TestType tested = (TestType) ( this ) ;
116982 :
116983 0 : std::vector < unsigned char* > :: const_iterator block = SgVarArgStartOneOperandOp::pools.begin();
116984 :
116985 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
116986 : // while (found == false && block < Memory_Block_List.end())
116987 0 : while ( (found == false) && (block != SgVarArgStartOneOperandOp::pools.end()) )
116988 : {
116989 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgVarArgStartOneOperandOp::pool_size * sizeof(SgVarArgStartOneOperandOp) ) ) ;
116990 0 : ++block;
116991 : }
116992 :
116993 : // Special handling for static data
116994 :
116995 :
116996 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
116997 0 : ROSE_ASSERT(found == true);
116998 :
116999 0 : return found;
117000 : }
117001 : /* #line 117002 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
117002 :
117003 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
117004 :
117005 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117006 :
117007 : /* #line 117008 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
117008 :
117009 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117010 :
117011 : void
117012 0 : SgNullExpression::checkDataMemberPointersIfInMemoryPool()
117013 : {
117014 : // ------------ checking pointers of SgNullExpression -------------------
117015 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
117016 :
117017 0 : if ( p_operatorPosition != NULL )
117018 : {
117019 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117020 : {
117021 0 : if ( p_operatorPosition->isInMemoryPool() == false )
117022 : {
117023 0 : std::cout << "SgNullExpression :: ";
117024 0 : std::cout << " p_operatorPosition is not in memory pool of ";
117025 0 : std::cout << p_operatorPosition->class_name() << std::endl;
117026 : }
117027 : }
117028 : else
117029 : {
117030 0 : std::cout << "SgNullExpression :: " << std::flush;
117031 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
117032 0 : std::cout << " not valid " << std::endl;
117033 : }
117034 : }
117035 :
117036 0 : if ( p_startOfConstruct != NULL )
117037 : {
117038 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117039 : {
117040 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
117041 : {
117042 0 : std::cout << "SgNullExpression :: ";
117043 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
117044 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
117045 : }
117046 : }
117047 : else
117048 : {
117049 0 : std::cout << "SgNullExpression :: " << std::flush;
117050 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
117051 0 : std::cout << " not valid " << std::endl;
117052 : }
117053 : }
117054 :
117055 0 : if ( p_endOfConstruct != NULL )
117056 : {
117057 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117058 : {
117059 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
117060 : {
117061 0 : std::cout << "SgNullExpression :: ";
117062 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
117063 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
117064 : }
117065 : }
117066 : else
117067 : {
117068 0 : std::cout << "SgNullExpression :: " << std::flush;
117069 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
117070 0 : std::cout << " not valid " << std::endl;
117071 : }
117072 : }
117073 :
117074 0 : if ( p_parent != NULL )
117075 : {
117076 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117077 : {
117078 0 : if ( p_parent->isInMemoryPool() == false )
117079 : {
117080 0 : std::cout << "SgNullExpression :: ";
117081 0 : std::cout << " p_parent is not in memory pool of ";
117082 0 : std::cout << p_parent->class_name() << std::endl;
117083 : }
117084 : }
117085 : else
117086 : {
117087 0 : std::cout << "SgNullExpression :: " << std::flush;
117088 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
117089 0 : std::cout << " not valid " << std::endl;
117090 : }
117091 : }
117092 :
117093 :
117094 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117095 :
117096 0 : }
117097 :
117098 :
117099 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
117100 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
117101 : bool
117102 0 : SgNullExpression::isInMemoryPool ()
117103 : {
117104 0 : typedef unsigned char* TestType;
117105 :
117106 0 : bool found = false;
117107 :
117108 0 : ROSE_ASSERT(this != NULL);
117109 :
117110 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
117111 :
117112 0 : TestType tested = (TestType) ( this ) ;
117113 :
117114 0 : std::vector < unsigned char* > :: const_iterator block = SgNullExpression::pools.begin();
117115 :
117116 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
117117 : // while (found == false && block < Memory_Block_List.end())
117118 0 : while ( (found == false) && (block != SgNullExpression::pools.end()) )
117119 : {
117120 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNullExpression::pool_size * sizeof(SgNullExpression) ) ) ;
117121 0 : ++block;
117122 : }
117123 :
117124 : // Special handling for static data
117125 :
117126 :
117127 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
117128 0 : ROSE_ASSERT(found == true);
117129 :
117130 0 : return found;
117131 : }
117132 : /* #line 117133 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
117133 :
117134 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
117135 :
117136 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117137 :
117138 : /* #line 117139 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
117139 :
117140 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117141 :
117142 : void
117143 0 : SgVariantExpression::checkDataMemberPointersIfInMemoryPool()
117144 : {
117145 : // ------------ checking pointers of SgVariantExpression -------------------
117146 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
117147 :
117148 0 : if ( p_operatorPosition != NULL )
117149 : {
117150 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117151 : {
117152 0 : if ( p_operatorPosition->isInMemoryPool() == false )
117153 : {
117154 0 : std::cout << "SgVariantExpression :: ";
117155 0 : std::cout << " p_operatorPosition is not in memory pool of ";
117156 0 : std::cout << p_operatorPosition->class_name() << std::endl;
117157 : }
117158 : }
117159 : else
117160 : {
117161 0 : std::cout << "SgVariantExpression :: " << std::flush;
117162 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
117163 0 : std::cout << " not valid " << std::endl;
117164 : }
117165 : }
117166 :
117167 0 : if ( p_startOfConstruct != NULL )
117168 : {
117169 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117170 : {
117171 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
117172 : {
117173 0 : std::cout << "SgVariantExpression :: ";
117174 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
117175 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
117176 : }
117177 : }
117178 : else
117179 : {
117180 0 : std::cout << "SgVariantExpression :: " << std::flush;
117181 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
117182 0 : std::cout << " not valid " << std::endl;
117183 : }
117184 : }
117185 :
117186 0 : if ( p_endOfConstruct != NULL )
117187 : {
117188 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117189 : {
117190 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
117191 : {
117192 0 : std::cout << "SgVariantExpression :: ";
117193 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
117194 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
117195 : }
117196 : }
117197 : else
117198 : {
117199 0 : std::cout << "SgVariantExpression :: " << std::flush;
117200 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
117201 0 : std::cout << " not valid " << std::endl;
117202 : }
117203 : }
117204 :
117205 0 : if ( p_parent != NULL )
117206 : {
117207 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117208 : {
117209 0 : if ( p_parent->isInMemoryPool() == false )
117210 : {
117211 0 : std::cout << "SgVariantExpression :: ";
117212 0 : std::cout << " p_parent is not in memory pool of ";
117213 0 : std::cout << p_parent->class_name() << std::endl;
117214 : }
117215 : }
117216 : else
117217 : {
117218 0 : std::cout << "SgVariantExpression :: " << std::flush;
117219 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
117220 0 : std::cout << " not valid " << std::endl;
117221 : }
117222 : }
117223 :
117224 :
117225 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117226 :
117227 0 : }
117228 :
117229 :
117230 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
117231 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
117232 : bool
117233 0 : SgVariantExpression::isInMemoryPool ()
117234 : {
117235 0 : typedef unsigned char* TestType;
117236 :
117237 0 : bool found = false;
117238 :
117239 0 : ROSE_ASSERT(this != NULL);
117240 :
117241 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
117242 :
117243 0 : TestType tested = (TestType) ( this ) ;
117244 :
117245 0 : std::vector < unsigned char* > :: const_iterator block = SgVariantExpression::pools.begin();
117246 :
117247 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
117248 : // while (found == false && block < Memory_Block_List.end())
117249 0 : while ( (found == false) && (block != SgVariantExpression::pools.end()) )
117250 : {
117251 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgVariantExpression::pool_size * sizeof(SgVariantExpression) ) ) ;
117252 0 : ++block;
117253 : }
117254 :
117255 : // Special handling for static data
117256 :
117257 :
117258 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
117259 0 : ROSE_ASSERT(found == true);
117260 :
117261 0 : return found;
117262 : }
117263 : /* #line 117264 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
117264 :
117265 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
117266 :
117267 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117268 :
117269 : /* #line 117270 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
117270 :
117271 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117272 :
117273 : void
117274 0 : SgSubscriptExpression::checkDataMemberPointersIfInMemoryPool()
117275 : {
117276 : // ------------ checking pointers of SgSubscriptExpression -------------------
117277 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
117278 :
117279 0 : if ( p_lowerBound != NULL )
117280 : {
117281 0 : if ( p_lowerBound->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117282 : {
117283 0 : if ( p_lowerBound->isInMemoryPool() == false )
117284 : {
117285 0 : std::cout << "SgSubscriptExpression :: ";
117286 0 : std::cout << " p_lowerBound is not in memory pool of ";
117287 0 : std::cout << p_lowerBound->class_name() << std::endl;
117288 : }
117289 : }
117290 : else
117291 : {
117292 0 : std::cout << "SgSubscriptExpression :: " << std::flush;
117293 0 : std::cout << "SgExpression* p_lowerBound = " << p_lowerBound << " --> " << std::flush;
117294 0 : std::cout << " not valid " << std::endl;
117295 : }
117296 : }
117297 :
117298 0 : if ( p_upperBound != NULL )
117299 : {
117300 0 : if ( p_upperBound->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117301 : {
117302 0 : if ( p_upperBound->isInMemoryPool() == false )
117303 : {
117304 0 : std::cout << "SgSubscriptExpression :: ";
117305 0 : std::cout << " p_upperBound is not in memory pool of ";
117306 0 : std::cout << p_upperBound->class_name() << std::endl;
117307 : }
117308 : }
117309 : else
117310 : {
117311 0 : std::cout << "SgSubscriptExpression :: " << std::flush;
117312 0 : std::cout << "SgExpression* p_upperBound = " << p_upperBound << " --> " << std::flush;
117313 0 : std::cout << " not valid " << std::endl;
117314 : }
117315 : }
117316 :
117317 0 : if ( p_stride != NULL )
117318 : {
117319 0 : if ( p_stride->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117320 : {
117321 0 : if ( p_stride->isInMemoryPool() == false )
117322 : {
117323 0 : std::cout << "SgSubscriptExpression :: ";
117324 0 : std::cout << " p_stride is not in memory pool of ";
117325 0 : std::cout << p_stride->class_name() << std::endl;
117326 : }
117327 : }
117328 : else
117329 : {
117330 0 : std::cout << "SgSubscriptExpression :: " << std::flush;
117331 0 : std::cout << "SgExpression* p_stride = " << p_stride << " --> " << std::flush;
117332 0 : std::cout << " not valid " << std::endl;
117333 : }
117334 : }
117335 :
117336 0 : if ( p_operatorPosition != NULL )
117337 : {
117338 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117339 : {
117340 0 : if ( p_operatorPosition->isInMemoryPool() == false )
117341 : {
117342 0 : std::cout << "SgSubscriptExpression :: ";
117343 0 : std::cout << " p_operatorPosition is not in memory pool of ";
117344 0 : std::cout << p_operatorPosition->class_name() << std::endl;
117345 : }
117346 : }
117347 : else
117348 : {
117349 0 : std::cout << "SgSubscriptExpression :: " << std::flush;
117350 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
117351 0 : std::cout << " not valid " << std::endl;
117352 : }
117353 : }
117354 :
117355 0 : if ( p_startOfConstruct != NULL )
117356 : {
117357 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117358 : {
117359 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
117360 : {
117361 0 : std::cout << "SgSubscriptExpression :: ";
117362 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
117363 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
117364 : }
117365 : }
117366 : else
117367 : {
117368 0 : std::cout << "SgSubscriptExpression :: " << std::flush;
117369 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
117370 0 : std::cout << " not valid " << std::endl;
117371 : }
117372 : }
117373 :
117374 0 : if ( p_endOfConstruct != NULL )
117375 : {
117376 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117377 : {
117378 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
117379 : {
117380 0 : std::cout << "SgSubscriptExpression :: ";
117381 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
117382 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
117383 : }
117384 : }
117385 : else
117386 : {
117387 0 : std::cout << "SgSubscriptExpression :: " << std::flush;
117388 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
117389 0 : std::cout << " not valid " << std::endl;
117390 : }
117391 : }
117392 :
117393 0 : if ( p_parent != NULL )
117394 : {
117395 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117396 : {
117397 0 : if ( p_parent->isInMemoryPool() == false )
117398 : {
117399 0 : std::cout << "SgSubscriptExpression :: ";
117400 0 : std::cout << " p_parent is not in memory pool of ";
117401 0 : std::cout << p_parent->class_name() << std::endl;
117402 : }
117403 : }
117404 : else
117405 : {
117406 0 : std::cout << "SgSubscriptExpression :: " << std::flush;
117407 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
117408 0 : std::cout << " not valid " << std::endl;
117409 : }
117410 : }
117411 :
117412 :
117413 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117414 :
117415 0 : }
117416 :
117417 :
117418 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
117419 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
117420 : bool
117421 0 : SgSubscriptExpression::isInMemoryPool ()
117422 : {
117423 0 : typedef unsigned char* TestType;
117424 :
117425 0 : bool found = false;
117426 :
117427 0 : ROSE_ASSERT(this != NULL);
117428 :
117429 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
117430 :
117431 0 : TestType tested = (TestType) ( this ) ;
117432 :
117433 0 : std::vector < unsigned char* > :: const_iterator block = SgSubscriptExpression::pools.begin();
117434 :
117435 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
117436 : // while (found == false && block < Memory_Block_List.end())
117437 0 : while ( (found == false) && (block != SgSubscriptExpression::pools.end()) )
117438 : {
117439 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSubscriptExpression::pool_size * sizeof(SgSubscriptExpression) ) ) ;
117440 0 : ++block;
117441 : }
117442 :
117443 : // Special handling for static data
117444 :
117445 :
117446 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
117447 0 : ROSE_ASSERT(found == true);
117448 :
117449 0 : return found;
117450 : }
117451 : /* #line 117452 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
117452 :
117453 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
117454 :
117455 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117456 :
117457 : /* #line 117458 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
117458 :
117459 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117460 :
117461 : void
117462 0 : SgColonShapeExp::checkDataMemberPointersIfInMemoryPool()
117463 : {
117464 : // ------------ checking pointers of SgColonShapeExp -------------------
117465 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
117466 :
117467 0 : if ( p_operatorPosition != NULL )
117468 : {
117469 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117470 : {
117471 0 : if ( p_operatorPosition->isInMemoryPool() == false )
117472 : {
117473 0 : std::cout << "SgColonShapeExp :: ";
117474 0 : std::cout << " p_operatorPosition is not in memory pool of ";
117475 0 : std::cout << p_operatorPosition->class_name() << std::endl;
117476 : }
117477 : }
117478 : else
117479 : {
117480 0 : std::cout << "SgColonShapeExp :: " << std::flush;
117481 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
117482 0 : std::cout << " not valid " << std::endl;
117483 : }
117484 : }
117485 :
117486 0 : if ( p_startOfConstruct != NULL )
117487 : {
117488 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117489 : {
117490 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
117491 : {
117492 0 : std::cout << "SgColonShapeExp :: ";
117493 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
117494 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
117495 : }
117496 : }
117497 : else
117498 : {
117499 0 : std::cout << "SgColonShapeExp :: " << std::flush;
117500 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
117501 0 : std::cout << " not valid " << std::endl;
117502 : }
117503 : }
117504 :
117505 0 : if ( p_endOfConstruct != NULL )
117506 : {
117507 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117508 : {
117509 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
117510 : {
117511 0 : std::cout << "SgColonShapeExp :: ";
117512 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
117513 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
117514 : }
117515 : }
117516 : else
117517 : {
117518 0 : std::cout << "SgColonShapeExp :: " << std::flush;
117519 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
117520 0 : std::cout << " not valid " << std::endl;
117521 : }
117522 : }
117523 :
117524 0 : if ( p_parent != NULL )
117525 : {
117526 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117527 : {
117528 0 : if ( p_parent->isInMemoryPool() == false )
117529 : {
117530 0 : std::cout << "SgColonShapeExp :: ";
117531 0 : std::cout << " p_parent is not in memory pool of ";
117532 0 : std::cout << p_parent->class_name() << std::endl;
117533 : }
117534 : }
117535 : else
117536 : {
117537 0 : std::cout << "SgColonShapeExp :: " << std::flush;
117538 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
117539 0 : std::cout << " not valid " << std::endl;
117540 : }
117541 : }
117542 :
117543 :
117544 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117545 :
117546 0 : }
117547 :
117548 :
117549 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
117550 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
117551 : bool
117552 0 : SgColonShapeExp::isInMemoryPool ()
117553 : {
117554 0 : typedef unsigned char* TestType;
117555 :
117556 0 : bool found = false;
117557 :
117558 0 : ROSE_ASSERT(this != NULL);
117559 :
117560 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
117561 :
117562 0 : TestType tested = (TestType) ( this ) ;
117563 :
117564 0 : std::vector < unsigned char* > :: const_iterator block = SgColonShapeExp::pools.begin();
117565 :
117566 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
117567 : // while (found == false && block < Memory_Block_List.end())
117568 0 : while ( (found == false) && (block != SgColonShapeExp::pools.end()) )
117569 : {
117570 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgColonShapeExp::pool_size * sizeof(SgColonShapeExp) ) ) ;
117571 0 : ++block;
117572 : }
117573 :
117574 : // Special handling for static data
117575 :
117576 :
117577 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
117578 0 : ROSE_ASSERT(found == true);
117579 :
117580 0 : return found;
117581 : }
117582 : /* #line 117583 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
117583 :
117584 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
117585 :
117586 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117587 :
117588 : /* #line 117589 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
117589 :
117590 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117591 :
117592 : void
117593 0 : SgAsteriskShapeExp::checkDataMemberPointersIfInMemoryPool()
117594 : {
117595 : // ------------ checking pointers of SgAsteriskShapeExp -------------------
117596 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
117597 :
117598 0 : if ( p_operatorPosition != NULL )
117599 : {
117600 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117601 : {
117602 0 : if ( p_operatorPosition->isInMemoryPool() == false )
117603 : {
117604 0 : std::cout << "SgAsteriskShapeExp :: ";
117605 0 : std::cout << " p_operatorPosition is not in memory pool of ";
117606 0 : std::cout << p_operatorPosition->class_name() << std::endl;
117607 : }
117608 : }
117609 : else
117610 : {
117611 0 : std::cout << "SgAsteriskShapeExp :: " << std::flush;
117612 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
117613 0 : std::cout << " not valid " << std::endl;
117614 : }
117615 : }
117616 :
117617 0 : if ( p_startOfConstruct != NULL )
117618 : {
117619 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117620 : {
117621 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
117622 : {
117623 0 : std::cout << "SgAsteriskShapeExp :: ";
117624 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
117625 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
117626 : }
117627 : }
117628 : else
117629 : {
117630 0 : std::cout << "SgAsteriskShapeExp :: " << std::flush;
117631 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
117632 0 : std::cout << " not valid " << std::endl;
117633 : }
117634 : }
117635 :
117636 0 : if ( p_endOfConstruct != NULL )
117637 : {
117638 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117639 : {
117640 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
117641 : {
117642 0 : std::cout << "SgAsteriskShapeExp :: ";
117643 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
117644 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
117645 : }
117646 : }
117647 : else
117648 : {
117649 0 : std::cout << "SgAsteriskShapeExp :: " << std::flush;
117650 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
117651 0 : std::cout << " not valid " << std::endl;
117652 : }
117653 : }
117654 :
117655 0 : if ( p_parent != NULL )
117656 : {
117657 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117658 : {
117659 0 : if ( p_parent->isInMemoryPool() == false )
117660 : {
117661 0 : std::cout << "SgAsteriskShapeExp :: ";
117662 0 : std::cout << " p_parent is not in memory pool of ";
117663 0 : std::cout << p_parent->class_name() << std::endl;
117664 : }
117665 : }
117666 : else
117667 : {
117668 0 : std::cout << "SgAsteriskShapeExp :: " << std::flush;
117669 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
117670 0 : std::cout << " not valid " << std::endl;
117671 : }
117672 : }
117673 :
117674 :
117675 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117676 :
117677 0 : }
117678 :
117679 :
117680 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
117681 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
117682 : bool
117683 0 : SgAsteriskShapeExp::isInMemoryPool ()
117684 : {
117685 0 : typedef unsigned char* TestType;
117686 :
117687 0 : bool found = false;
117688 :
117689 0 : ROSE_ASSERT(this != NULL);
117690 :
117691 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
117692 :
117693 0 : TestType tested = (TestType) ( this ) ;
117694 :
117695 0 : std::vector < unsigned char* > :: const_iterator block = SgAsteriskShapeExp::pools.begin();
117696 :
117697 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
117698 : // while (found == false && block < Memory_Block_List.end())
117699 0 : while ( (found == false) && (block != SgAsteriskShapeExp::pools.end()) )
117700 : {
117701 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAsteriskShapeExp::pool_size * sizeof(SgAsteriskShapeExp) ) ) ;
117702 0 : ++block;
117703 : }
117704 :
117705 : // Special handling for static data
117706 :
117707 :
117708 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
117709 0 : ROSE_ASSERT(found == true);
117710 :
117711 0 : return found;
117712 : }
117713 : /* #line 117714 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
117714 :
117715 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
117716 :
117717 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117718 :
117719 : /* #line 117720 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
117720 :
117721 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117722 :
117723 : void
117724 0 : SgImpliedDo::checkDataMemberPointersIfInMemoryPool()
117725 : {
117726 : // ------------ checking pointers of SgImpliedDo -------------------
117727 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
117728 :
117729 0 : if ( p_do_var_initialization != NULL )
117730 : {
117731 0 : if ( p_do_var_initialization->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117732 : {
117733 0 : if ( p_do_var_initialization->isInMemoryPool() == false )
117734 : {
117735 0 : std::cout << "SgImpliedDo :: ";
117736 0 : std::cout << " p_do_var_initialization is not in memory pool of ";
117737 0 : std::cout << p_do_var_initialization->class_name() << std::endl;
117738 : }
117739 : }
117740 : else
117741 : {
117742 0 : std::cout << "SgImpliedDo :: " << std::flush;
117743 0 : std::cout << "SgExpression* p_do_var_initialization = " << p_do_var_initialization << " --> " << std::flush;
117744 0 : std::cout << " not valid " << std::endl;
117745 : }
117746 : }
117747 :
117748 0 : if ( p_last_val != NULL )
117749 : {
117750 0 : if ( p_last_val->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117751 : {
117752 0 : if ( p_last_val->isInMemoryPool() == false )
117753 : {
117754 0 : std::cout << "SgImpliedDo :: ";
117755 0 : std::cout << " p_last_val is not in memory pool of ";
117756 0 : std::cout << p_last_val->class_name() << std::endl;
117757 : }
117758 : }
117759 : else
117760 : {
117761 0 : std::cout << "SgImpliedDo :: " << std::flush;
117762 0 : std::cout << "SgExpression* p_last_val = " << p_last_val << " --> " << std::flush;
117763 0 : std::cout << " not valid " << std::endl;
117764 : }
117765 : }
117766 :
117767 0 : if ( p_increment != NULL )
117768 : {
117769 0 : if ( p_increment->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117770 : {
117771 0 : if ( p_increment->isInMemoryPool() == false )
117772 : {
117773 0 : std::cout << "SgImpliedDo :: ";
117774 0 : std::cout << " p_increment is not in memory pool of ";
117775 0 : std::cout << p_increment->class_name() << std::endl;
117776 : }
117777 : }
117778 : else
117779 : {
117780 0 : std::cout << "SgImpliedDo :: " << std::flush;
117781 0 : std::cout << "SgExpression* p_increment = " << p_increment << " --> " << std::flush;
117782 0 : std::cout << " not valid " << std::endl;
117783 : }
117784 : }
117785 :
117786 0 : if ( p_object_list != NULL )
117787 : {
117788 0 : if ( p_object_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117789 : {
117790 0 : if ( p_object_list->isInMemoryPool() == false )
117791 : {
117792 0 : std::cout << "SgImpliedDo :: ";
117793 0 : std::cout << " p_object_list is not in memory pool of ";
117794 0 : std::cout << p_object_list->class_name() << std::endl;
117795 : }
117796 : }
117797 : else
117798 : {
117799 0 : std::cout << "SgImpliedDo :: " << std::flush;
117800 0 : std::cout << "SgExprListExp* p_object_list = " << p_object_list << " --> " << std::flush;
117801 0 : std::cout << " not valid " << std::endl;
117802 : }
117803 : }
117804 :
117805 0 : if ( p_implied_do_scope != NULL )
117806 : {
117807 0 : if ( p_implied_do_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117808 : {
117809 0 : if ( p_implied_do_scope->isInMemoryPool() == false )
117810 : {
117811 0 : std::cout << "SgImpliedDo :: ";
117812 0 : std::cout << " p_implied_do_scope is not in memory pool of ";
117813 0 : std::cout << p_implied_do_scope->class_name() << std::endl;
117814 : }
117815 : }
117816 : else
117817 : {
117818 0 : std::cout << "SgImpliedDo :: " << std::flush;
117819 0 : std::cout << "SgScopeStatement* p_implied_do_scope = " << p_implied_do_scope << " --> " << std::flush;
117820 0 : std::cout << " not valid " << std::endl;
117821 : }
117822 : }
117823 :
117824 0 : if ( p_operatorPosition != NULL )
117825 : {
117826 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117827 : {
117828 0 : if ( p_operatorPosition->isInMemoryPool() == false )
117829 : {
117830 0 : std::cout << "SgImpliedDo :: ";
117831 0 : std::cout << " p_operatorPosition is not in memory pool of ";
117832 0 : std::cout << p_operatorPosition->class_name() << std::endl;
117833 : }
117834 : }
117835 : else
117836 : {
117837 0 : std::cout << "SgImpliedDo :: " << std::flush;
117838 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
117839 0 : std::cout << " not valid " << std::endl;
117840 : }
117841 : }
117842 :
117843 0 : if ( p_startOfConstruct != NULL )
117844 : {
117845 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117846 : {
117847 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
117848 : {
117849 0 : std::cout << "SgImpliedDo :: ";
117850 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
117851 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
117852 : }
117853 : }
117854 : else
117855 : {
117856 0 : std::cout << "SgImpliedDo :: " << std::flush;
117857 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
117858 0 : std::cout << " not valid " << std::endl;
117859 : }
117860 : }
117861 :
117862 0 : if ( p_endOfConstruct != NULL )
117863 : {
117864 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117865 : {
117866 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
117867 : {
117868 0 : std::cout << "SgImpliedDo :: ";
117869 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
117870 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
117871 : }
117872 : }
117873 : else
117874 : {
117875 0 : std::cout << "SgImpliedDo :: " << std::flush;
117876 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
117877 0 : std::cout << " not valid " << std::endl;
117878 : }
117879 : }
117880 :
117881 0 : if ( p_parent != NULL )
117882 : {
117883 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117884 : {
117885 0 : if ( p_parent->isInMemoryPool() == false )
117886 : {
117887 0 : std::cout << "SgImpliedDo :: ";
117888 0 : std::cout << " p_parent is not in memory pool of ";
117889 0 : std::cout << p_parent->class_name() << std::endl;
117890 : }
117891 : }
117892 : else
117893 : {
117894 0 : std::cout << "SgImpliedDo :: " << std::flush;
117895 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
117896 0 : std::cout << " not valid " << std::endl;
117897 : }
117898 : }
117899 :
117900 :
117901 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117902 :
117903 0 : }
117904 :
117905 :
117906 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
117907 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
117908 : bool
117909 0 : SgImpliedDo::isInMemoryPool ()
117910 : {
117911 0 : typedef unsigned char* TestType;
117912 :
117913 0 : bool found = false;
117914 :
117915 0 : ROSE_ASSERT(this != NULL);
117916 :
117917 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
117918 :
117919 0 : TestType tested = (TestType) ( this ) ;
117920 :
117921 0 : std::vector < unsigned char* > :: const_iterator block = SgImpliedDo::pools.begin();
117922 :
117923 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
117924 : // while (found == false && block < Memory_Block_List.end())
117925 0 : while ( (found == false) && (block != SgImpliedDo::pools.end()) )
117926 : {
117927 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgImpliedDo::pool_size * sizeof(SgImpliedDo) ) ) ;
117928 0 : ++block;
117929 : }
117930 :
117931 : // Special handling for static data
117932 :
117933 :
117934 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
117935 0 : ROSE_ASSERT(found == true);
117936 :
117937 0 : return found;
117938 : }
117939 : /* #line 117940 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
117940 :
117941 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
117942 :
117943 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117944 :
117945 : /* #line 117946 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
117946 :
117947 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
117948 :
117949 : void
117950 0 : SgIOItemExpression::checkDataMemberPointersIfInMemoryPool()
117951 : {
117952 : // ------------ checking pointers of SgIOItemExpression -------------------
117953 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
117954 :
117955 0 : if ( p_io_item != NULL )
117956 : {
117957 0 : if ( p_io_item->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117958 : {
117959 0 : if ( p_io_item->isInMemoryPool() == false )
117960 : {
117961 0 : std::cout << "SgIOItemExpression :: ";
117962 0 : std::cout << " p_io_item is not in memory pool of ";
117963 0 : std::cout << p_io_item->class_name() << std::endl;
117964 : }
117965 : }
117966 : else
117967 : {
117968 0 : std::cout << "SgIOItemExpression :: " << std::flush;
117969 0 : std::cout << "SgExpression* p_io_item = " << p_io_item << " --> " << std::flush;
117970 0 : std::cout << " not valid " << std::endl;
117971 : }
117972 : }
117973 :
117974 0 : if ( p_operatorPosition != NULL )
117975 : {
117976 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117977 : {
117978 0 : if ( p_operatorPosition->isInMemoryPool() == false )
117979 : {
117980 0 : std::cout << "SgIOItemExpression :: ";
117981 0 : std::cout << " p_operatorPosition is not in memory pool of ";
117982 0 : std::cout << p_operatorPosition->class_name() << std::endl;
117983 : }
117984 : }
117985 : else
117986 : {
117987 0 : std::cout << "SgIOItemExpression :: " << std::flush;
117988 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
117989 0 : std::cout << " not valid " << std::endl;
117990 : }
117991 : }
117992 :
117993 0 : if ( p_startOfConstruct != NULL )
117994 : {
117995 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
117996 : {
117997 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
117998 : {
117999 0 : std::cout << "SgIOItemExpression :: ";
118000 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
118001 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
118002 : }
118003 : }
118004 : else
118005 : {
118006 0 : std::cout << "SgIOItemExpression :: " << std::flush;
118007 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
118008 0 : std::cout << " not valid " << std::endl;
118009 : }
118010 : }
118011 :
118012 0 : if ( p_endOfConstruct != NULL )
118013 : {
118014 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118015 : {
118016 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
118017 : {
118018 0 : std::cout << "SgIOItemExpression :: ";
118019 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
118020 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
118021 : }
118022 : }
118023 : else
118024 : {
118025 0 : std::cout << "SgIOItemExpression :: " << std::flush;
118026 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
118027 0 : std::cout << " not valid " << std::endl;
118028 : }
118029 : }
118030 :
118031 0 : if ( p_parent != NULL )
118032 : {
118033 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118034 : {
118035 0 : if ( p_parent->isInMemoryPool() == false )
118036 : {
118037 0 : std::cout << "SgIOItemExpression :: ";
118038 0 : std::cout << " p_parent is not in memory pool of ";
118039 0 : std::cout << p_parent->class_name() << std::endl;
118040 : }
118041 : }
118042 : else
118043 : {
118044 0 : std::cout << "SgIOItemExpression :: " << std::flush;
118045 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
118046 0 : std::cout << " not valid " << std::endl;
118047 : }
118048 : }
118049 :
118050 :
118051 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118052 :
118053 0 : }
118054 :
118055 :
118056 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
118057 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
118058 : bool
118059 0 : SgIOItemExpression::isInMemoryPool ()
118060 : {
118061 0 : typedef unsigned char* TestType;
118062 :
118063 0 : bool found = false;
118064 :
118065 0 : ROSE_ASSERT(this != NULL);
118066 :
118067 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
118068 :
118069 0 : TestType tested = (TestType) ( this ) ;
118070 :
118071 0 : std::vector < unsigned char* > :: const_iterator block = SgIOItemExpression::pools.begin();
118072 :
118073 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
118074 : // while (found == false && block < Memory_Block_List.end())
118075 0 : while ( (found == false) && (block != SgIOItemExpression::pools.end()) )
118076 : {
118077 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIOItemExpression::pool_size * sizeof(SgIOItemExpression) ) ) ;
118078 0 : ++block;
118079 : }
118080 :
118081 : // Special handling for static data
118082 :
118083 :
118084 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
118085 0 : ROSE_ASSERT(found == true);
118086 :
118087 0 : return found;
118088 : }
118089 : /* #line 118090 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
118090 :
118091 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
118092 :
118093 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118094 :
118095 : /* #line 118096 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
118096 :
118097 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118098 :
118099 : void
118100 0 : SgStatementExpression::checkDataMemberPointersIfInMemoryPool()
118101 : {
118102 : // ------------ checking pointers of SgStatementExpression -------------------
118103 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
118104 :
118105 0 : if ( p_statement != NULL )
118106 : {
118107 0 : if ( p_statement->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118108 : {
118109 0 : if ( p_statement->isInMemoryPool() == false )
118110 : {
118111 0 : std::cout << "SgStatementExpression :: ";
118112 0 : std::cout << " p_statement is not in memory pool of ";
118113 0 : std::cout << p_statement->class_name() << std::endl;
118114 : }
118115 : }
118116 : else
118117 : {
118118 0 : std::cout << "SgStatementExpression :: " << std::flush;
118119 0 : std::cout << "SgStatement* p_statement = " << p_statement << " --> " << std::flush;
118120 0 : std::cout << " not valid " << std::endl;
118121 : }
118122 : }
118123 :
118124 0 : if ( p_operatorPosition != NULL )
118125 : {
118126 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118127 : {
118128 0 : if ( p_operatorPosition->isInMemoryPool() == false )
118129 : {
118130 0 : std::cout << "SgStatementExpression :: ";
118131 0 : std::cout << " p_operatorPosition is not in memory pool of ";
118132 0 : std::cout << p_operatorPosition->class_name() << std::endl;
118133 : }
118134 : }
118135 : else
118136 : {
118137 0 : std::cout << "SgStatementExpression :: " << std::flush;
118138 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
118139 0 : std::cout << " not valid " << std::endl;
118140 : }
118141 : }
118142 :
118143 0 : if ( p_startOfConstruct != NULL )
118144 : {
118145 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118146 : {
118147 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
118148 : {
118149 0 : std::cout << "SgStatementExpression :: ";
118150 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
118151 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
118152 : }
118153 : }
118154 : else
118155 : {
118156 0 : std::cout << "SgStatementExpression :: " << std::flush;
118157 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
118158 0 : std::cout << " not valid " << std::endl;
118159 : }
118160 : }
118161 :
118162 0 : if ( p_endOfConstruct != NULL )
118163 : {
118164 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118165 : {
118166 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
118167 : {
118168 0 : std::cout << "SgStatementExpression :: ";
118169 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
118170 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
118171 : }
118172 : }
118173 : else
118174 : {
118175 0 : std::cout << "SgStatementExpression :: " << std::flush;
118176 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
118177 0 : std::cout << " not valid " << std::endl;
118178 : }
118179 : }
118180 :
118181 0 : if ( p_parent != NULL )
118182 : {
118183 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118184 : {
118185 0 : if ( p_parent->isInMemoryPool() == false )
118186 : {
118187 0 : std::cout << "SgStatementExpression :: ";
118188 0 : std::cout << " p_parent is not in memory pool of ";
118189 0 : std::cout << p_parent->class_name() << std::endl;
118190 : }
118191 : }
118192 : else
118193 : {
118194 0 : std::cout << "SgStatementExpression :: " << std::flush;
118195 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
118196 0 : std::cout << " not valid " << std::endl;
118197 : }
118198 : }
118199 :
118200 :
118201 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118202 :
118203 0 : }
118204 :
118205 :
118206 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
118207 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
118208 : bool
118209 0 : SgStatementExpression::isInMemoryPool ()
118210 : {
118211 0 : typedef unsigned char* TestType;
118212 :
118213 0 : bool found = false;
118214 :
118215 0 : ROSE_ASSERT(this != NULL);
118216 :
118217 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
118218 :
118219 0 : TestType tested = (TestType) ( this ) ;
118220 :
118221 0 : std::vector < unsigned char* > :: const_iterator block = SgStatementExpression::pools.begin();
118222 :
118223 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
118224 : // while (found == false && block < Memory_Block_List.end())
118225 0 : while ( (found == false) && (block != SgStatementExpression::pools.end()) )
118226 : {
118227 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgStatementExpression::pool_size * sizeof(SgStatementExpression) ) ) ;
118228 0 : ++block;
118229 : }
118230 :
118231 : // Special handling for static data
118232 :
118233 :
118234 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
118235 0 : ROSE_ASSERT(found == true);
118236 :
118237 0 : return found;
118238 : }
118239 : /* #line 118240 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
118240 :
118241 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
118242 :
118243 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118244 :
118245 : /* #line 118246 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
118246 :
118247 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118248 :
118249 : void
118250 0 : SgAsmOp::checkDataMemberPointersIfInMemoryPool()
118251 : {
118252 : // ------------ checking pointers of SgAsmOp -------------------
118253 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
118254 :
118255 0 : if ( p_expression != NULL )
118256 : {
118257 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118258 : {
118259 0 : if ( p_expression->isInMemoryPool() == false )
118260 : {
118261 0 : std::cout << "SgAsmOp :: ";
118262 0 : std::cout << " p_expression is not in memory pool of ";
118263 0 : std::cout << p_expression->class_name() << std::endl;
118264 : }
118265 : }
118266 : else
118267 : {
118268 0 : std::cout << "SgAsmOp :: " << std::flush;
118269 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
118270 0 : std::cout << " not valid " << std::endl;
118271 : }
118272 : }
118273 :
118274 0 : if ( p_operatorPosition != NULL )
118275 : {
118276 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118277 : {
118278 0 : if ( p_operatorPosition->isInMemoryPool() == false )
118279 : {
118280 0 : std::cout << "SgAsmOp :: ";
118281 0 : std::cout << " p_operatorPosition is not in memory pool of ";
118282 0 : std::cout << p_operatorPosition->class_name() << std::endl;
118283 : }
118284 : }
118285 : else
118286 : {
118287 0 : std::cout << "SgAsmOp :: " << std::flush;
118288 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
118289 0 : std::cout << " not valid " << std::endl;
118290 : }
118291 : }
118292 :
118293 0 : if ( p_startOfConstruct != NULL )
118294 : {
118295 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118296 : {
118297 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
118298 : {
118299 0 : std::cout << "SgAsmOp :: ";
118300 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
118301 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
118302 : }
118303 : }
118304 : else
118305 : {
118306 0 : std::cout << "SgAsmOp :: " << std::flush;
118307 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
118308 0 : std::cout << " not valid " << std::endl;
118309 : }
118310 : }
118311 :
118312 0 : if ( p_endOfConstruct != NULL )
118313 : {
118314 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118315 : {
118316 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
118317 : {
118318 0 : std::cout << "SgAsmOp :: ";
118319 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
118320 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
118321 : }
118322 : }
118323 : else
118324 : {
118325 0 : std::cout << "SgAsmOp :: " << std::flush;
118326 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
118327 0 : std::cout << " not valid " << std::endl;
118328 : }
118329 : }
118330 :
118331 0 : if ( p_parent != NULL )
118332 : {
118333 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118334 : {
118335 0 : if ( p_parent->isInMemoryPool() == false )
118336 : {
118337 0 : std::cout << "SgAsmOp :: ";
118338 0 : std::cout << " p_parent is not in memory pool of ";
118339 0 : std::cout << p_parent->class_name() << std::endl;
118340 : }
118341 : }
118342 : else
118343 : {
118344 0 : std::cout << "SgAsmOp :: " << std::flush;
118345 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
118346 0 : std::cout << " not valid " << std::endl;
118347 : }
118348 : }
118349 :
118350 :
118351 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118352 :
118353 0 : }
118354 :
118355 :
118356 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
118357 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
118358 : bool
118359 0 : SgAsmOp::isInMemoryPool ()
118360 : {
118361 0 : typedef unsigned char* TestType;
118362 :
118363 0 : bool found = false;
118364 :
118365 0 : ROSE_ASSERT(this != NULL);
118366 :
118367 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
118368 :
118369 0 : TestType tested = (TestType) ( this ) ;
118370 :
118371 0 : std::vector < unsigned char* > :: const_iterator block = SgAsmOp::pools.begin();
118372 :
118373 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
118374 : // while (found == false && block < Memory_Block_List.end())
118375 0 : while ( (found == false) && (block != SgAsmOp::pools.end()) )
118376 : {
118377 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAsmOp::pool_size * sizeof(SgAsmOp) ) ) ;
118378 0 : ++block;
118379 : }
118380 :
118381 : // Special handling for static data
118382 :
118383 :
118384 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
118385 0 : ROSE_ASSERT(found == true);
118386 :
118387 0 : return found;
118388 : }
118389 : /* #line 118390 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
118390 :
118391 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
118392 :
118393 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118394 :
118395 : /* #line 118396 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
118396 :
118397 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118398 :
118399 : void
118400 0 : SgLabelRefExp::checkDataMemberPointersIfInMemoryPool()
118401 : {
118402 : // ------------ checking pointers of SgLabelRefExp -------------------
118403 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
118404 :
118405 0 : if ( p_symbol != NULL )
118406 : {
118407 0 : if ( p_symbol->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118408 : {
118409 0 : if ( p_symbol->isInMemoryPool() == false )
118410 : {
118411 0 : std::cout << "SgLabelRefExp :: ";
118412 0 : std::cout << " p_symbol is not in memory pool of ";
118413 0 : std::cout << p_symbol->class_name() << std::endl;
118414 : }
118415 : }
118416 : else
118417 : {
118418 0 : std::cout << "SgLabelRefExp :: " << std::flush;
118419 0 : std::cout << "SgLabelSymbol* p_symbol = " << p_symbol << " --> " << std::flush;
118420 0 : std::cout << " not valid " << std::endl;
118421 : }
118422 : }
118423 :
118424 0 : if ( p_operatorPosition != NULL )
118425 : {
118426 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118427 : {
118428 0 : if ( p_operatorPosition->isInMemoryPool() == false )
118429 : {
118430 0 : std::cout << "SgLabelRefExp :: ";
118431 0 : std::cout << " p_operatorPosition is not in memory pool of ";
118432 0 : std::cout << p_operatorPosition->class_name() << std::endl;
118433 : }
118434 : }
118435 : else
118436 : {
118437 0 : std::cout << "SgLabelRefExp :: " << std::flush;
118438 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
118439 0 : std::cout << " not valid " << std::endl;
118440 : }
118441 : }
118442 :
118443 0 : if ( p_startOfConstruct != NULL )
118444 : {
118445 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118446 : {
118447 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
118448 : {
118449 0 : std::cout << "SgLabelRefExp :: ";
118450 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
118451 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
118452 : }
118453 : }
118454 : else
118455 : {
118456 0 : std::cout << "SgLabelRefExp :: " << std::flush;
118457 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
118458 0 : std::cout << " not valid " << std::endl;
118459 : }
118460 : }
118461 :
118462 0 : if ( p_endOfConstruct != NULL )
118463 : {
118464 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118465 : {
118466 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
118467 : {
118468 0 : std::cout << "SgLabelRefExp :: ";
118469 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
118470 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
118471 : }
118472 : }
118473 : else
118474 : {
118475 0 : std::cout << "SgLabelRefExp :: " << std::flush;
118476 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
118477 0 : std::cout << " not valid " << std::endl;
118478 : }
118479 : }
118480 :
118481 0 : if ( p_parent != NULL )
118482 : {
118483 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118484 : {
118485 0 : if ( p_parent->isInMemoryPool() == false )
118486 : {
118487 0 : std::cout << "SgLabelRefExp :: ";
118488 0 : std::cout << " p_parent is not in memory pool of ";
118489 0 : std::cout << p_parent->class_name() << std::endl;
118490 : }
118491 : }
118492 : else
118493 : {
118494 0 : std::cout << "SgLabelRefExp :: " << std::flush;
118495 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
118496 0 : std::cout << " not valid " << std::endl;
118497 : }
118498 : }
118499 :
118500 :
118501 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118502 :
118503 0 : }
118504 :
118505 :
118506 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
118507 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
118508 : bool
118509 0 : SgLabelRefExp::isInMemoryPool ()
118510 : {
118511 0 : typedef unsigned char* TestType;
118512 :
118513 0 : bool found = false;
118514 :
118515 0 : ROSE_ASSERT(this != NULL);
118516 :
118517 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
118518 :
118519 0 : TestType tested = (TestType) ( this ) ;
118520 :
118521 0 : std::vector < unsigned char* > :: const_iterator block = SgLabelRefExp::pools.begin();
118522 :
118523 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
118524 : // while (found == false && block < Memory_Block_List.end())
118525 0 : while ( (found == false) && (block != SgLabelRefExp::pools.end()) )
118526 : {
118527 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLabelRefExp::pool_size * sizeof(SgLabelRefExp) ) ) ;
118528 0 : ++block;
118529 : }
118530 :
118531 : // Special handling for static data
118532 :
118533 :
118534 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
118535 0 : ROSE_ASSERT(found == true);
118536 :
118537 0 : return found;
118538 : }
118539 : /* #line 118540 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
118540 :
118541 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
118542 :
118543 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118544 :
118545 : /* #line 118546 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
118546 :
118547 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118548 :
118549 : void
118550 0 : SgActualArgumentExpression::checkDataMemberPointersIfInMemoryPool()
118551 : {
118552 : // ------------ checking pointers of SgActualArgumentExpression -------------------
118553 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
118554 :
118555 0 : if ( p_expression != NULL )
118556 : {
118557 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118558 : {
118559 0 : if ( p_expression->isInMemoryPool() == false )
118560 : {
118561 0 : std::cout << "SgActualArgumentExpression :: ";
118562 0 : std::cout << " p_expression is not in memory pool of ";
118563 0 : std::cout << p_expression->class_name() << std::endl;
118564 : }
118565 : }
118566 : else
118567 : {
118568 0 : std::cout << "SgActualArgumentExpression :: " << std::flush;
118569 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
118570 0 : std::cout << " not valid " << std::endl;
118571 : }
118572 : }
118573 :
118574 0 : if ( p_operatorPosition != NULL )
118575 : {
118576 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118577 : {
118578 0 : if ( p_operatorPosition->isInMemoryPool() == false )
118579 : {
118580 0 : std::cout << "SgActualArgumentExpression :: ";
118581 0 : std::cout << " p_operatorPosition is not in memory pool of ";
118582 0 : std::cout << p_operatorPosition->class_name() << std::endl;
118583 : }
118584 : }
118585 : else
118586 : {
118587 0 : std::cout << "SgActualArgumentExpression :: " << std::flush;
118588 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
118589 0 : std::cout << " not valid " << std::endl;
118590 : }
118591 : }
118592 :
118593 0 : if ( p_startOfConstruct != NULL )
118594 : {
118595 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118596 : {
118597 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
118598 : {
118599 0 : std::cout << "SgActualArgumentExpression :: ";
118600 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
118601 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
118602 : }
118603 : }
118604 : else
118605 : {
118606 0 : std::cout << "SgActualArgumentExpression :: " << std::flush;
118607 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
118608 0 : std::cout << " not valid " << std::endl;
118609 : }
118610 : }
118611 :
118612 0 : if ( p_endOfConstruct != NULL )
118613 : {
118614 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118615 : {
118616 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
118617 : {
118618 0 : std::cout << "SgActualArgumentExpression :: ";
118619 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
118620 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
118621 : }
118622 : }
118623 : else
118624 : {
118625 0 : std::cout << "SgActualArgumentExpression :: " << std::flush;
118626 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
118627 0 : std::cout << " not valid " << std::endl;
118628 : }
118629 : }
118630 :
118631 0 : if ( p_parent != NULL )
118632 : {
118633 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118634 : {
118635 0 : if ( p_parent->isInMemoryPool() == false )
118636 : {
118637 0 : std::cout << "SgActualArgumentExpression :: ";
118638 0 : std::cout << " p_parent is not in memory pool of ";
118639 0 : std::cout << p_parent->class_name() << std::endl;
118640 : }
118641 : }
118642 : else
118643 : {
118644 0 : std::cout << "SgActualArgumentExpression :: " << std::flush;
118645 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
118646 0 : std::cout << " not valid " << std::endl;
118647 : }
118648 : }
118649 :
118650 :
118651 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118652 :
118653 0 : }
118654 :
118655 :
118656 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
118657 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
118658 : bool
118659 0 : SgActualArgumentExpression::isInMemoryPool ()
118660 : {
118661 0 : typedef unsigned char* TestType;
118662 :
118663 0 : bool found = false;
118664 :
118665 0 : ROSE_ASSERT(this != NULL);
118666 :
118667 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
118668 :
118669 0 : TestType tested = (TestType) ( this ) ;
118670 :
118671 0 : std::vector < unsigned char* > :: const_iterator block = SgActualArgumentExpression::pools.begin();
118672 :
118673 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
118674 : // while (found == false && block < Memory_Block_List.end())
118675 0 : while ( (found == false) && (block != SgActualArgumentExpression::pools.end()) )
118676 : {
118677 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgActualArgumentExpression::pool_size * sizeof(SgActualArgumentExpression) ) ) ;
118678 0 : ++block;
118679 : }
118680 :
118681 : // Special handling for static data
118682 :
118683 :
118684 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
118685 0 : ROSE_ASSERT(found == true);
118686 :
118687 0 : return found;
118688 : }
118689 : /* #line 118690 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
118690 :
118691 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
118692 :
118693 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118694 :
118695 : /* #line 118696 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
118696 :
118697 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118698 :
118699 : void
118700 0 : SgUnknownArrayOrFunctionReference::checkDataMemberPointersIfInMemoryPool()
118701 : {
118702 : // ------------ checking pointers of SgUnknownArrayOrFunctionReference -------------------
118703 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
118704 :
118705 0 : if ( p_named_reference != NULL )
118706 : {
118707 0 : if ( p_named_reference->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118708 : {
118709 0 : if ( p_named_reference->isInMemoryPool() == false )
118710 : {
118711 0 : std::cout << "SgUnknownArrayOrFunctionReference :: ";
118712 0 : std::cout << " p_named_reference is not in memory pool of ";
118713 0 : std::cout << p_named_reference->class_name() << std::endl;
118714 : }
118715 : }
118716 : else
118717 : {
118718 0 : std::cout << "SgUnknownArrayOrFunctionReference :: " << std::flush;
118719 0 : std::cout << "SgExpression* p_named_reference = " << p_named_reference << " --> " << std::flush;
118720 0 : std::cout << " not valid " << std::endl;
118721 : }
118722 : }
118723 :
118724 0 : if ( p_expression_list != NULL )
118725 : {
118726 0 : if ( p_expression_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118727 : {
118728 0 : if ( p_expression_list->isInMemoryPool() == false )
118729 : {
118730 0 : std::cout << "SgUnknownArrayOrFunctionReference :: ";
118731 0 : std::cout << " p_expression_list is not in memory pool of ";
118732 0 : std::cout << p_expression_list->class_name() << std::endl;
118733 : }
118734 : }
118735 : else
118736 : {
118737 0 : std::cout << "SgUnknownArrayOrFunctionReference :: " << std::flush;
118738 0 : std::cout << "SgExprListExp* p_expression_list = " << p_expression_list << " --> " << std::flush;
118739 0 : std::cout << " not valid " << std::endl;
118740 : }
118741 : }
118742 :
118743 0 : if ( p_operatorPosition != NULL )
118744 : {
118745 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118746 : {
118747 0 : if ( p_operatorPosition->isInMemoryPool() == false )
118748 : {
118749 0 : std::cout << "SgUnknownArrayOrFunctionReference :: ";
118750 0 : std::cout << " p_operatorPosition is not in memory pool of ";
118751 0 : std::cout << p_operatorPosition->class_name() << std::endl;
118752 : }
118753 : }
118754 : else
118755 : {
118756 0 : std::cout << "SgUnknownArrayOrFunctionReference :: " << std::flush;
118757 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
118758 0 : std::cout << " not valid " << std::endl;
118759 : }
118760 : }
118761 :
118762 0 : if ( p_startOfConstruct != NULL )
118763 : {
118764 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118765 : {
118766 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
118767 : {
118768 0 : std::cout << "SgUnknownArrayOrFunctionReference :: ";
118769 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
118770 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
118771 : }
118772 : }
118773 : else
118774 : {
118775 0 : std::cout << "SgUnknownArrayOrFunctionReference :: " << std::flush;
118776 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
118777 0 : std::cout << " not valid " << std::endl;
118778 : }
118779 : }
118780 :
118781 0 : if ( p_endOfConstruct != NULL )
118782 : {
118783 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118784 : {
118785 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
118786 : {
118787 0 : std::cout << "SgUnknownArrayOrFunctionReference :: ";
118788 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
118789 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
118790 : }
118791 : }
118792 : else
118793 : {
118794 0 : std::cout << "SgUnknownArrayOrFunctionReference :: " << std::flush;
118795 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
118796 0 : std::cout << " not valid " << std::endl;
118797 : }
118798 : }
118799 :
118800 0 : if ( p_parent != NULL )
118801 : {
118802 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118803 : {
118804 0 : if ( p_parent->isInMemoryPool() == false )
118805 : {
118806 0 : std::cout << "SgUnknownArrayOrFunctionReference :: ";
118807 0 : std::cout << " p_parent is not in memory pool of ";
118808 0 : std::cout << p_parent->class_name() << std::endl;
118809 : }
118810 : }
118811 : else
118812 : {
118813 0 : std::cout << "SgUnknownArrayOrFunctionReference :: " << std::flush;
118814 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
118815 0 : std::cout << " not valid " << std::endl;
118816 : }
118817 : }
118818 :
118819 :
118820 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118821 :
118822 0 : }
118823 :
118824 :
118825 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
118826 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
118827 : bool
118828 0 : SgUnknownArrayOrFunctionReference::isInMemoryPool ()
118829 : {
118830 0 : typedef unsigned char* TestType;
118831 :
118832 0 : bool found = false;
118833 :
118834 0 : ROSE_ASSERT(this != NULL);
118835 :
118836 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
118837 :
118838 0 : TestType tested = (TestType) ( this ) ;
118839 :
118840 0 : std::vector < unsigned char* > :: const_iterator block = SgUnknownArrayOrFunctionReference::pools.begin();
118841 :
118842 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
118843 : // while (found == false && block < Memory_Block_List.end())
118844 0 : while ( (found == false) && (block != SgUnknownArrayOrFunctionReference::pools.end()) )
118845 : {
118846 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgUnknownArrayOrFunctionReference::pool_size * sizeof(SgUnknownArrayOrFunctionReference) ) ) ;
118847 0 : ++block;
118848 : }
118849 :
118850 : // Special handling for static data
118851 :
118852 :
118853 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
118854 0 : ROSE_ASSERT(found == true);
118855 :
118856 0 : return found;
118857 : }
118858 : /* #line 118859 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
118859 :
118860 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
118861 :
118862 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118863 :
118864 : /* #line 118865 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
118865 :
118866 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118867 :
118868 : void
118869 0 : SgPseudoDestructorRefExp::checkDataMemberPointersIfInMemoryPool()
118870 : {
118871 : // ------------ checking pointers of SgPseudoDestructorRefExp -------------------
118872 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
118873 :
118874 0 : if ( p_object_type != NULL )
118875 : {
118876 0 : if ( p_object_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118877 : {
118878 0 : if ( p_object_type->isInMemoryPool() == false )
118879 : {
118880 0 : std::cout << "SgPseudoDestructorRefExp :: ";
118881 0 : std::cout << " p_object_type is not in memory pool of ";
118882 0 : std::cout << p_object_type->class_name() << std::endl;
118883 : }
118884 : }
118885 : else
118886 : {
118887 0 : std::cout << "SgPseudoDestructorRefExp :: " << std::flush;
118888 0 : std::cout << "SgType* p_object_type = " << p_object_type << " --> " << std::flush;
118889 0 : std::cout << " not valid " << std::endl;
118890 : }
118891 : }
118892 :
118893 0 : if ( p_expression_type != NULL )
118894 : {
118895 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118896 : {
118897 0 : if ( p_expression_type->isInMemoryPool() == false )
118898 : {
118899 0 : std::cout << "SgPseudoDestructorRefExp :: ";
118900 0 : std::cout << " p_expression_type is not in memory pool of ";
118901 0 : std::cout << p_expression_type->class_name() << std::endl;
118902 : }
118903 : }
118904 : else
118905 : {
118906 0 : std::cout << "SgPseudoDestructorRefExp :: " << std::flush;
118907 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
118908 0 : std::cout << " not valid " << std::endl;
118909 : }
118910 : }
118911 :
118912 0 : if ( p_operatorPosition != NULL )
118913 : {
118914 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118915 : {
118916 0 : if ( p_operatorPosition->isInMemoryPool() == false )
118917 : {
118918 0 : std::cout << "SgPseudoDestructorRefExp :: ";
118919 0 : std::cout << " p_operatorPosition is not in memory pool of ";
118920 0 : std::cout << p_operatorPosition->class_name() << std::endl;
118921 : }
118922 : }
118923 : else
118924 : {
118925 0 : std::cout << "SgPseudoDestructorRefExp :: " << std::flush;
118926 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
118927 0 : std::cout << " not valid " << std::endl;
118928 : }
118929 : }
118930 :
118931 0 : if ( p_startOfConstruct != NULL )
118932 : {
118933 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118934 : {
118935 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
118936 : {
118937 0 : std::cout << "SgPseudoDestructorRefExp :: ";
118938 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
118939 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
118940 : }
118941 : }
118942 : else
118943 : {
118944 0 : std::cout << "SgPseudoDestructorRefExp :: " << std::flush;
118945 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
118946 0 : std::cout << " not valid " << std::endl;
118947 : }
118948 : }
118949 :
118950 0 : if ( p_endOfConstruct != NULL )
118951 : {
118952 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118953 : {
118954 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
118955 : {
118956 0 : std::cout << "SgPseudoDestructorRefExp :: ";
118957 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
118958 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
118959 : }
118960 : }
118961 : else
118962 : {
118963 0 : std::cout << "SgPseudoDestructorRefExp :: " << std::flush;
118964 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
118965 0 : std::cout << " not valid " << std::endl;
118966 : }
118967 : }
118968 :
118969 0 : if ( p_parent != NULL )
118970 : {
118971 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
118972 : {
118973 0 : if ( p_parent->isInMemoryPool() == false )
118974 : {
118975 0 : std::cout << "SgPseudoDestructorRefExp :: ";
118976 0 : std::cout << " p_parent is not in memory pool of ";
118977 0 : std::cout << p_parent->class_name() << std::endl;
118978 : }
118979 : }
118980 : else
118981 : {
118982 0 : std::cout << "SgPseudoDestructorRefExp :: " << std::flush;
118983 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
118984 0 : std::cout << " not valid " << std::endl;
118985 : }
118986 : }
118987 :
118988 :
118989 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
118990 :
118991 0 : }
118992 :
118993 :
118994 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
118995 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
118996 : bool
118997 0 : SgPseudoDestructorRefExp::isInMemoryPool ()
118998 : {
118999 0 : typedef unsigned char* TestType;
119000 :
119001 0 : bool found = false;
119002 :
119003 0 : ROSE_ASSERT(this != NULL);
119004 :
119005 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
119006 :
119007 0 : TestType tested = (TestType) ( this ) ;
119008 :
119009 0 : std::vector < unsigned char* > :: const_iterator block = SgPseudoDestructorRefExp::pools.begin();
119010 :
119011 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
119012 : // while (found == false && block < Memory_Block_List.end())
119013 0 : while ( (found == false) && (block != SgPseudoDestructorRefExp::pools.end()) )
119014 : {
119015 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgPseudoDestructorRefExp::pool_size * sizeof(SgPseudoDestructorRefExp) ) ) ;
119016 0 : ++block;
119017 : }
119018 :
119019 : // Special handling for static data
119020 :
119021 :
119022 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
119023 0 : ROSE_ASSERT(found == true);
119024 :
119025 0 : return found;
119026 : }
119027 : /* #line 119028 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
119028 :
119029 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
119030 :
119031 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119032 :
119033 : /* #line 119034 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
119034 :
119035 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119036 :
119037 : void
119038 0 : SgCAFCoExpression::checkDataMemberPointersIfInMemoryPool()
119039 : {
119040 : // ------------ checking pointers of SgCAFCoExpression -------------------
119041 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
119042 :
119043 0 : if ( p_teamId != NULL )
119044 : {
119045 0 : if ( p_teamId->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119046 : {
119047 0 : if ( p_teamId->isInMemoryPool() == false )
119048 : {
119049 0 : std::cout << "SgCAFCoExpression :: ";
119050 0 : std::cout << " p_teamId is not in memory pool of ";
119051 0 : std::cout << p_teamId->class_name() << std::endl;
119052 : }
119053 : }
119054 : else
119055 : {
119056 0 : std::cout << "SgCAFCoExpression :: " << std::flush;
119057 0 : std::cout << "SgVarRefExp* p_teamId = " << p_teamId << " --> " << std::flush;
119058 0 : std::cout << " not valid " << std::endl;
119059 : }
119060 : }
119061 :
119062 0 : if ( p_teamRank != NULL )
119063 : {
119064 0 : if ( p_teamRank->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119065 : {
119066 0 : if ( p_teamRank->isInMemoryPool() == false )
119067 : {
119068 0 : std::cout << "SgCAFCoExpression :: ";
119069 0 : std::cout << " p_teamRank is not in memory pool of ";
119070 0 : std::cout << p_teamRank->class_name() << std::endl;
119071 : }
119072 : }
119073 : else
119074 : {
119075 0 : std::cout << "SgCAFCoExpression :: " << std::flush;
119076 0 : std::cout << "SgExpression* p_teamRank = " << p_teamRank << " --> " << std::flush;
119077 0 : std::cout << " not valid " << std::endl;
119078 : }
119079 : }
119080 :
119081 0 : if ( p_referData != NULL )
119082 : {
119083 0 : if ( p_referData->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119084 : {
119085 0 : if ( p_referData->isInMemoryPool() == false )
119086 : {
119087 0 : std::cout << "SgCAFCoExpression :: ";
119088 0 : std::cout << " p_referData is not in memory pool of ";
119089 0 : std::cout << p_referData->class_name() << std::endl;
119090 : }
119091 : }
119092 : else
119093 : {
119094 0 : std::cout << "SgCAFCoExpression :: " << std::flush;
119095 0 : std::cout << "SgExpression* p_referData = " << p_referData << " --> " << std::flush;
119096 0 : std::cout << " not valid " << std::endl;
119097 : }
119098 : }
119099 :
119100 0 : if ( p_operatorPosition != NULL )
119101 : {
119102 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119103 : {
119104 0 : if ( p_operatorPosition->isInMemoryPool() == false )
119105 : {
119106 0 : std::cout << "SgCAFCoExpression :: ";
119107 0 : std::cout << " p_operatorPosition is not in memory pool of ";
119108 0 : std::cout << p_operatorPosition->class_name() << std::endl;
119109 : }
119110 : }
119111 : else
119112 : {
119113 0 : std::cout << "SgCAFCoExpression :: " << std::flush;
119114 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
119115 0 : std::cout << " not valid " << std::endl;
119116 : }
119117 : }
119118 :
119119 0 : if ( p_startOfConstruct != NULL )
119120 : {
119121 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119122 : {
119123 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
119124 : {
119125 0 : std::cout << "SgCAFCoExpression :: ";
119126 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
119127 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
119128 : }
119129 : }
119130 : else
119131 : {
119132 0 : std::cout << "SgCAFCoExpression :: " << std::flush;
119133 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
119134 0 : std::cout << " not valid " << std::endl;
119135 : }
119136 : }
119137 :
119138 0 : if ( p_endOfConstruct != NULL )
119139 : {
119140 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119141 : {
119142 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
119143 : {
119144 0 : std::cout << "SgCAFCoExpression :: ";
119145 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
119146 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
119147 : }
119148 : }
119149 : else
119150 : {
119151 0 : std::cout << "SgCAFCoExpression :: " << std::flush;
119152 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
119153 0 : std::cout << " not valid " << std::endl;
119154 : }
119155 : }
119156 :
119157 0 : if ( p_parent != NULL )
119158 : {
119159 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119160 : {
119161 0 : if ( p_parent->isInMemoryPool() == false )
119162 : {
119163 0 : std::cout << "SgCAFCoExpression :: ";
119164 0 : std::cout << " p_parent is not in memory pool of ";
119165 0 : std::cout << p_parent->class_name() << std::endl;
119166 : }
119167 : }
119168 : else
119169 : {
119170 0 : std::cout << "SgCAFCoExpression :: " << std::flush;
119171 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
119172 0 : std::cout << " not valid " << std::endl;
119173 : }
119174 : }
119175 :
119176 :
119177 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119178 :
119179 0 : }
119180 :
119181 :
119182 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
119183 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
119184 : bool
119185 0 : SgCAFCoExpression::isInMemoryPool ()
119186 : {
119187 0 : typedef unsigned char* TestType;
119188 :
119189 0 : bool found = false;
119190 :
119191 0 : ROSE_ASSERT(this != NULL);
119192 :
119193 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
119194 :
119195 0 : TestType tested = (TestType) ( this ) ;
119196 :
119197 0 : std::vector < unsigned char* > :: const_iterator block = SgCAFCoExpression::pools.begin();
119198 :
119199 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
119200 : // while (found == false && block < Memory_Block_List.end())
119201 0 : while ( (found == false) && (block != SgCAFCoExpression::pools.end()) )
119202 : {
119203 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCAFCoExpression::pool_size * sizeof(SgCAFCoExpression) ) ) ;
119204 0 : ++block;
119205 : }
119206 :
119207 : // Special handling for static data
119208 :
119209 :
119210 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
119211 0 : ROSE_ASSERT(found == true);
119212 :
119213 0 : return found;
119214 : }
119215 : /* #line 119216 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
119216 :
119217 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
119218 :
119219 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119220 :
119221 : /* #line 119222 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
119222 :
119223 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119224 :
119225 : void
119226 0 : SgCudaKernelExecConfig::checkDataMemberPointersIfInMemoryPool()
119227 : {
119228 : // ------------ checking pointers of SgCudaKernelExecConfig -------------------
119229 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
119230 :
119231 0 : if ( p_grid != NULL )
119232 : {
119233 0 : if ( p_grid->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119234 : {
119235 0 : if ( p_grid->isInMemoryPool() == false )
119236 : {
119237 0 : std::cout << "SgCudaKernelExecConfig :: ";
119238 0 : std::cout << " p_grid is not in memory pool of ";
119239 0 : std::cout << p_grid->class_name() << std::endl;
119240 : }
119241 : }
119242 : else
119243 : {
119244 0 : std::cout << "SgCudaKernelExecConfig :: " << std::flush;
119245 0 : std::cout << "SgExpression* p_grid = " << p_grid << " --> " << std::flush;
119246 0 : std::cout << " not valid " << std::endl;
119247 : }
119248 : }
119249 :
119250 0 : if ( p_blocks != NULL )
119251 : {
119252 0 : if ( p_blocks->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119253 : {
119254 0 : if ( p_blocks->isInMemoryPool() == false )
119255 : {
119256 0 : std::cout << "SgCudaKernelExecConfig :: ";
119257 0 : std::cout << " p_blocks is not in memory pool of ";
119258 0 : std::cout << p_blocks->class_name() << std::endl;
119259 : }
119260 : }
119261 : else
119262 : {
119263 0 : std::cout << "SgCudaKernelExecConfig :: " << std::flush;
119264 0 : std::cout << "SgExpression* p_blocks = " << p_blocks << " --> " << std::flush;
119265 0 : std::cout << " not valid " << std::endl;
119266 : }
119267 : }
119268 :
119269 0 : if ( p_shared != NULL )
119270 : {
119271 0 : if ( p_shared->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119272 : {
119273 0 : if ( p_shared->isInMemoryPool() == false )
119274 : {
119275 0 : std::cout << "SgCudaKernelExecConfig :: ";
119276 0 : std::cout << " p_shared is not in memory pool of ";
119277 0 : std::cout << p_shared->class_name() << std::endl;
119278 : }
119279 : }
119280 : else
119281 : {
119282 0 : std::cout << "SgCudaKernelExecConfig :: " << std::flush;
119283 0 : std::cout << "SgExpression* p_shared = " << p_shared << " --> " << std::flush;
119284 0 : std::cout << " not valid " << std::endl;
119285 : }
119286 : }
119287 :
119288 0 : if ( p_stream != NULL )
119289 : {
119290 0 : if ( p_stream->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119291 : {
119292 0 : if ( p_stream->isInMemoryPool() == false )
119293 : {
119294 0 : std::cout << "SgCudaKernelExecConfig :: ";
119295 0 : std::cout << " p_stream is not in memory pool of ";
119296 0 : std::cout << p_stream->class_name() << std::endl;
119297 : }
119298 : }
119299 : else
119300 : {
119301 0 : std::cout << "SgCudaKernelExecConfig :: " << std::flush;
119302 0 : std::cout << "SgExpression* p_stream = " << p_stream << " --> " << std::flush;
119303 0 : std::cout << " not valid " << std::endl;
119304 : }
119305 : }
119306 :
119307 0 : if ( p_operatorPosition != NULL )
119308 : {
119309 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119310 : {
119311 0 : if ( p_operatorPosition->isInMemoryPool() == false )
119312 : {
119313 0 : std::cout << "SgCudaKernelExecConfig :: ";
119314 0 : std::cout << " p_operatorPosition is not in memory pool of ";
119315 0 : std::cout << p_operatorPosition->class_name() << std::endl;
119316 : }
119317 : }
119318 : else
119319 : {
119320 0 : std::cout << "SgCudaKernelExecConfig :: " << std::flush;
119321 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
119322 0 : std::cout << " not valid " << std::endl;
119323 : }
119324 : }
119325 :
119326 0 : if ( p_startOfConstruct != NULL )
119327 : {
119328 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119329 : {
119330 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
119331 : {
119332 0 : std::cout << "SgCudaKernelExecConfig :: ";
119333 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
119334 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
119335 : }
119336 : }
119337 : else
119338 : {
119339 0 : std::cout << "SgCudaKernelExecConfig :: " << std::flush;
119340 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
119341 0 : std::cout << " not valid " << std::endl;
119342 : }
119343 : }
119344 :
119345 0 : if ( p_endOfConstruct != NULL )
119346 : {
119347 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119348 : {
119349 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
119350 : {
119351 0 : std::cout << "SgCudaKernelExecConfig :: ";
119352 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
119353 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
119354 : }
119355 : }
119356 : else
119357 : {
119358 0 : std::cout << "SgCudaKernelExecConfig :: " << std::flush;
119359 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
119360 0 : std::cout << " not valid " << std::endl;
119361 : }
119362 : }
119363 :
119364 0 : if ( p_parent != NULL )
119365 : {
119366 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119367 : {
119368 0 : if ( p_parent->isInMemoryPool() == false )
119369 : {
119370 0 : std::cout << "SgCudaKernelExecConfig :: ";
119371 0 : std::cout << " p_parent is not in memory pool of ";
119372 0 : std::cout << p_parent->class_name() << std::endl;
119373 : }
119374 : }
119375 : else
119376 : {
119377 0 : std::cout << "SgCudaKernelExecConfig :: " << std::flush;
119378 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
119379 0 : std::cout << " not valid " << std::endl;
119380 : }
119381 : }
119382 :
119383 :
119384 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119385 :
119386 0 : }
119387 :
119388 :
119389 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
119390 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
119391 : bool
119392 0 : SgCudaKernelExecConfig::isInMemoryPool ()
119393 : {
119394 0 : typedef unsigned char* TestType;
119395 :
119396 0 : bool found = false;
119397 :
119398 0 : ROSE_ASSERT(this != NULL);
119399 :
119400 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
119401 :
119402 0 : TestType tested = (TestType) ( this ) ;
119403 :
119404 0 : std::vector < unsigned char* > :: const_iterator block = SgCudaKernelExecConfig::pools.begin();
119405 :
119406 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
119407 : // while (found == false && block < Memory_Block_List.end())
119408 0 : while ( (found == false) && (block != SgCudaKernelExecConfig::pools.end()) )
119409 : {
119410 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCudaKernelExecConfig::pool_size * sizeof(SgCudaKernelExecConfig) ) ) ;
119411 0 : ++block;
119412 : }
119413 :
119414 : // Special handling for static data
119415 :
119416 :
119417 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
119418 0 : ROSE_ASSERT(found == true);
119419 :
119420 0 : return found;
119421 : }
119422 : /* #line 119423 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
119423 :
119424 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
119425 :
119426 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119427 :
119428 : /* #line 119429 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
119429 :
119430 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119431 :
119432 : void
119433 0 : SgLambdaRefExp::checkDataMemberPointersIfInMemoryPool()
119434 : {
119435 : // ------------ checking pointers of SgLambdaRefExp -------------------
119436 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
119437 :
119438 0 : if ( p_functionDeclaration != NULL )
119439 : {
119440 0 : if ( p_functionDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119441 : {
119442 0 : if ( p_functionDeclaration->isInMemoryPool() == false )
119443 : {
119444 0 : std::cout << "SgLambdaRefExp :: ";
119445 0 : std::cout << " p_functionDeclaration is not in memory pool of ";
119446 0 : std::cout << p_functionDeclaration->class_name() << std::endl;
119447 : }
119448 : }
119449 : else
119450 : {
119451 0 : std::cout << "SgLambdaRefExp :: " << std::flush;
119452 0 : std::cout << "SgFunctionDeclaration* p_functionDeclaration = " << p_functionDeclaration << " --> " << std::flush;
119453 0 : std::cout << " not valid " << std::endl;
119454 : }
119455 : }
119456 :
119457 0 : if ( p_operatorPosition != NULL )
119458 : {
119459 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119460 : {
119461 0 : if ( p_operatorPosition->isInMemoryPool() == false )
119462 : {
119463 0 : std::cout << "SgLambdaRefExp :: ";
119464 0 : std::cout << " p_operatorPosition is not in memory pool of ";
119465 0 : std::cout << p_operatorPosition->class_name() << std::endl;
119466 : }
119467 : }
119468 : else
119469 : {
119470 0 : std::cout << "SgLambdaRefExp :: " << std::flush;
119471 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
119472 0 : std::cout << " not valid " << std::endl;
119473 : }
119474 : }
119475 :
119476 0 : if ( p_startOfConstruct != NULL )
119477 : {
119478 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119479 : {
119480 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
119481 : {
119482 0 : std::cout << "SgLambdaRefExp :: ";
119483 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
119484 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
119485 : }
119486 : }
119487 : else
119488 : {
119489 0 : std::cout << "SgLambdaRefExp :: " << std::flush;
119490 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
119491 0 : std::cout << " not valid " << std::endl;
119492 : }
119493 : }
119494 :
119495 0 : if ( p_endOfConstruct != NULL )
119496 : {
119497 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119498 : {
119499 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
119500 : {
119501 0 : std::cout << "SgLambdaRefExp :: ";
119502 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
119503 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
119504 : }
119505 : }
119506 : else
119507 : {
119508 0 : std::cout << "SgLambdaRefExp :: " << std::flush;
119509 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
119510 0 : std::cout << " not valid " << std::endl;
119511 : }
119512 : }
119513 :
119514 0 : if ( p_parent != NULL )
119515 : {
119516 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119517 : {
119518 0 : if ( p_parent->isInMemoryPool() == false )
119519 : {
119520 0 : std::cout << "SgLambdaRefExp :: ";
119521 0 : std::cout << " p_parent is not in memory pool of ";
119522 0 : std::cout << p_parent->class_name() << std::endl;
119523 : }
119524 : }
119525 : else
119526 : {
119527 0 : std::cout << "SgLambdaRefExp :: " << std::flush;
119528 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
119529 0 : std::cout << " not valid " << std::endl;
119530 : }
119531 : }
119532 :
119533 :
119534 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119535 :
119536 0 : }
119537 :
119538 :
119539 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
119540 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
119541 : bool
119542 0 : SgLambdaRefExp::isInMemoryPool ()
119543 : {
119544 0 : typedef unsigned char* TestType;
119545 :
119546 0 : bool found = false;
119547 :
119548 0 : ROSE_ASSERT(this != NULL);
119549 :
119550 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
119551 :
119552 0 : TestType tested = (TestType) ( this ) ;
119553 :
119554 0 : std::vector < unsigned char* > :: const_iterator block = SgLambdaRefExp::pools.begin();
119555 :
119556 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
119557 : // while (found == false && block < Memory_Block_List.end())
119558 0 : while ( (found == false) && (block != SgLambdaRefExp::pools.end()) )
119559 : {
119560 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLambdaRefExp::pool_size * sizeof(SgLambdaRefExp) ) ) ;
119561 0 : ++block;
119562 : }
119563 :
119564 : // Special handling for static data
119565 :
119566 :
119567 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
119568 0 : ROSE_ASSERT(found == true);
119569 :
119570 0 : return found;
119571 : }
119572 : /* #line 119573 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
119573 :
119574 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
119575 :
119576 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119577 :
119578 : /* #line 119579 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
119579 :
119580 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119581 :
119582 : void
119583 0 : SgDictionaryExp::checkDataMemberPointersIfInMemoryPool()
119584 : {
119585 : // ------------ checking pointers of SgDictionaryExp -------------------
119586 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
119587 :
119588 0 : SgKeyDatumPairPtrList::iterator i_key_datum_pairs = p_key_datum_pairs.begin() ;
119589 0 : for ( ; i_key_datum_pairs != p_key_datum_pairs.end(); ++i_key_datum_pairs )
119590 : {
119591 0 : if ( (*i_key_datum_pairs) != NULL )
119592 : {
119593 0 : if ( (*i_key_datum_pairs)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119594 : {
119595 0 : if ( (*i_key_datum_pairs)->isInMemoryPool() == false )
119596 : {
119597 0 : std::cout << "SgDictionaryExp :: ";
119598 0 : std::cout << " p_key_datum_pairs ( list of poitners to IR nodes ), entry is not in memory pool of ";
119599 0 : std::cout << (*i_key_datum_pairs)->class_name() << std::endl;
119600 : }
119601 : }
119602 : else
119603 : {
119604 0 : std::cout << "SgDictionaryExp :: " << std::flush;
119605 0 : std::cout << "SgKeyDatumPairPtrList p_key_datum_pairs --> " << std::flush;
119606 0 : std::cout << " entry not valid " << std::endl;
119607 : }
119608 : }
119609 : else
119610 : {
119611 0 : std::cout << "SgKeyDatumPairPtrList p_key_datum_pairs --> NULL " << std::endl;
119612 : }
119613 : }
119614 :
119615 0 : if ( p_operatorPosition != NULL )
119616 : {
119617 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119618 : {
119619 0 : if ( p_operatorPosition->isInMemoryPool() == false )
119620 : {
119621 0 : std::cout << "SgDictionaryExp :: ";
119622 0 : std::cout << " p_operatorPosition is not in memory pool of ";
119623 0 : std::cout << p_operatorPosition->class_name() << std::endl;
119624 : }
119625 : }
119626 : else
119627 : {
119628 0 : std::cout << "SgDictionaryExp :: " << std::flush;
119629 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
119630 0 : std::cout << " not valid " << std::endl;
119631 : }
119632 : }
119633 :
119634 0 : if ( p_startOfConstruct != NULL )
119635 : {
119636 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119637 : {
119638 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
119639 : {
119640 0 : std::cout << "SgDictionaryExp :: ";
119641 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
119642 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
119643 : }
119644 : }
119645 : else
119646 : {
119647 0 : std::cout << "SgDictionaryExp :: " << std::flush;
119648 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
119649 0 : std::cout << " not valid " << std::endl;
119650 : }
119651 : }
119652 :
119653 0 : if ( p_endOfConstruct != NULL )
119654 : {
119655 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119656 : {
119657 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
119658 : {
119659 0 : std::cout << "SgDictionaryExp :: ";
119660 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
119661 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
119662 : }
119663 : }
119664 : else
119665 : {
119666 0 : std::cout << "SgDictionaryExp :: " << std::flush;
119667 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
119668 0 : std::cout << " not valid " << std::endl;
119669 : }
119670 : }
119671 :
119672 0 : if ( p_parent != NULL )
119673 : {
119674 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119675 : {
119676 0 : if ( p_parent->isInMemoryPool() == false )
119677 : {
119678 0 : std::cout << "SgDictionaryExp :: ";
119679 0 : std::cout << " p_parent is not in memory pool of ";
119680 0 : std::cout << p_parent->class_name() << std::endl;
119681 : }
119682 : }
119683 : else
119684 : {
119685 0 : std::cout << "SgDictionaryExp :: " << std::flush;
119686 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
119687 0 : std::cout << " not valid " << std::endl;
119688 : }
119689 : }
119690 :
119691 :
119692 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119693 :
119694 0 : }
119695 :
119696 :
119697 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
119698 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
119699 : bool
119700 0 : SgDictionaryExp::isInMemoryPool ()
119701 : {
119702 0 : typedef unsigned char* TestType;
119703 :
119704 0 : bool found = false;
119705 :
119706 0 : ROSE_ASSERT(this != NULL);
119707 :
119708 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
119709 :
119710 0 : TestType tested = (TestType) ( this ) ;
119711 :
119712 0 : std::vector < unsigned char* > :: const_iterator block = SgDictionaryExp::pools.begin();
119713 :
119714 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
119715 : // while (found == false && block < Memory_Block_List.end())
119716 0 : while ( (found == false) && (block != SgDictionaryExp::pools.end()) )
119717 : {
119718 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDictionaryExp::pool_size * sizeof(SgDictionaryExp) ) ) ;
119719 0 : ++block;
119720 : }
119721 :
119722 : // Special handling for static data
119723 :
119724 :
119725 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
119726 0 : ROSE_ASSERT(found == true);
119727 :
119728 0 : return found;
119729 : }
119730 : /* #line 119731 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
119731 :
119732 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
119733 :
119734 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119735 :
119736 : /* #line 119737 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
119737 :
119738 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119739 :
119740 : void
119741 0 : SgKeyDatumPair::checkDataMemberPointersIfInMemoryPool()
119742 : {
119743 : // ------------ checking pointers of SgKeyDatumPair -------------------
119744 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
119745 :
119746 0 : if ( p_key != NULL )
119747 : {
119748 0 : if ( p_key->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119749 : {
119750 0 : if ( p_key->isInMemoryPool() == false )
119751 : {
119752 0 : std::cout << "SgKeyDatumPair :: ";
119753 0 : std::cout << " p_key is not in memory pool of ";
119754 0 : std::cout << p_key->class_name() << std::endl;
119755 : }
119756 : }
119757 : else
119758 : {
119759 0 : std::cout << "SgKeyDatumPair :: " << std::flush;
119760 0 : std::cout << "SgExpression* p_key = " << p_key << " --> " << std::flush;
119761 0 : std::cout << " not valid " << std::endl;
119762 : }
119763 : }
119764 :
119765 0 : if ( p_datum != NULL )
119766 : {
119767 0 : if ( p_datum->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119768 : {
119769 0 : if ( p_datum->isInMemoryPool() == false )
119770 : {
119771 0 : std::cout << "SgKeyDatumPair :: ";
119772 0 : std::cout << " p_datum is not in memory pool of ";
119773 0 : std::cout << p_datum->class_name() << std::endl;
119774 : }
119775 : }
119776 : else
119777 : {
119778 0 : std::cout << "SgKeyDatumPair :: " << std::flush;
119779 0 : std::cout << "SgExpression* p_datum = " << p_datum << " --> " << std::flush;
119780 0 : std::cout << " not valid " << std::endl;
119781 : }
119782 : }
119783 :
119784 0 : if ( p_operatorPosition != NULL )
119785 : {
119786 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119787 : {
119788 0 : if ( p_operatorPosition->isInMemoryPool() == false )
119789 : {
119790 0 : std::cout << "SgKeyDatumPair :: ";
119791 0 : std::cout << " p_operatorPosition is not in memory pool of ";
119792 0 : std::cout << p_operatorPosition->class_name() << std::endl;
119793 : }
119794 : }
119795 : else
119796 : {
119797 0 : std::cout << "SgKeyDatumPair :: " << std::flush;
119798 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
119799 0 : std::cout << " not valid " << std::endl;
119800 : }
119801 : }
119802 :
119803 0 : if ( p_startOfConstruct != NULL )
119804 : {
119805 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119806 : {
119807 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
119808 : {
119809 0 : std::cout << "SgKeyDatumPair :: ";
119810 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
119811 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
119812 : }
119813 : }
119814 : else
119815 : {
119816 0 : std::cout << "SgKeyDatumPair :: " << std::flush;
119817 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
119818 0 : std::cout << " not valid " << std::endl;
119819 : }
119820 : }
119821 :
119822 0 : if ( p_endOfConstruct != NULL )
119823 : {
119824 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119825 : {
119826 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
119827 : {
119828 0 : std::cout << "SgKeyDatumPair :: ";
119829 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
119830 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
119831 : }
119832 : }
119833 : else
119834 : {
119835 0 : std::cout << "SgKeyDatumPair :: " << std::flush;
119836 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
119837 0 : std::cout << " not valid " << std::endl;
119838 : }
119839 : }
119840 :
119841 0 : if ( p_parent != NULL )
119842 : {
119843 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119844 : {
119845 0 : if ( p_parent->isInMemoryPool() == false )
119846 : {
119847 0 : std::cout << "SgKeyDatumPair :: ";
119848 0 : std::cout << " p_parent is not in memory pool of ";
119849 0 : std::cout << p_parent->class_name() << std::endl;
119850 : }
119851 : }
119852 : else
119853 : {
119854 0 : std::cout << "SgKeyDatumPair :: " << std::flush;
119855 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
119856 0 : std::cout << " not valid " << std::endl;
119857 : }
119858 : }
119859 :
119860 :
119861 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119862 :
119863 0 : }
119864 :
119865 :
119866 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
119867 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
119868 : bool
119869 0 : SgKeyDatumPair::isInMemoryPool ()
119870 : {
119871 0 : typedef unsigned char* TestType;
119872 :
119873 0 : bool found = false;
119874 :
119875 0 : ROSE_ASSERT(this != NULL);
119876 :
119877 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
119878 :
119879 0 : TestType tested = (TestType) ( this ) ;
119880 :
119881 0 : std::vector < unsigned char* > :: const_iterator block = SgKeyDatumPair::pools.begin();
119882 :
119883 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
119884 : // while (found == false && block < Memory_Block_List.end())
119885 0 : while ( (found == false) && (block != SgKeyDatumPair::pools.end()) )
119886 : {
119887 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgKeyDatumPair::pool_size * sizeof(SgKeyDatumPair) ) ) ;
119888 0 : ++block;
119889 : }
119890 :
119891 : // Special handling for static data
119892 :
119893 :
119894 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
119895 0 : ROSE_ASSERT(found == true);
119896 :
119897 0 : return found;
119898 : }
119899 : /* #line 119900 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
119900 :
119901 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
119902 :
119903 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119904 :
119905 : /* #line 119906 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
119906 :
119907 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
119908 :
119909 : void
119910 0 : SgComprehension::checkDataMemberPointersIfInMemoryPool()
119911 : {
119912 : // ------------ checking pointers of SgComprehension -------------------
119913 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
119914 :
119915 0 : if ( p_target != NULL )
119916 : {
119917 0 : if ( p_target->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119918 : {
119919 0 : if ( p_target->isInMemoryPool() == false )
119920 : {
119921 0 : std::cout << "SgComprehension :: ";
119922 0 : std::cout << " p_target is not in memory pool of ";
119923 0 : std::cout << p_target->class_name() << std::endl;
119924 : }
119925 : }
119926 : else
119927 : {
119928 0 : std::cout << "SgComprehension :: " << std::flush;
119929 0 : std::cout << "SgExpression* p_target = " << p_target << " --> " << std::flush;
119930 0 : std::cout << " not valid " << std::endl;
119931 : }
119932 : }
119933 :
119934 0 : if ( p_iter != NULL )
119935 : {
119936 0 : if ( p_iter->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119937 : {
119938 0 : if ( p_iter->isInMemoryPool() == false )
119939 : {
119940 0 : std::cout << "SgComprehension :: ";
119941 0 : std::cout << " p_iter is not in memory pool of ";
119942 0 : std::cout << p_iter->class_name() << std::endl;
119943 : }
119944 : }
119945 : else
119946 : {
119947 0 : std::cout << "SgComprehension :: " << std::flush;
119948 0 : std::cout << "SgExpression* p_iter = " << p_iter << " --> " << std::flush;
119949 0 : std::cout << " not valid " << std::endl;
119950 : }
119951 : }
119952 :
119953 0 : if ( p_filters != NULL )
119954 : {
119955 0 : if ( p_filters->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119956 : {
119957 0 : if ( p_filters->isInMemoryPool() == false )
119958 : {
119959 0 : std::cout << "SgComprehension :: ";
119960 0 : std::cout << " p_filters is not in memory pool of ";
119961 0 : std::cout << p_filters->class_name() << std::endl;
119962 : }
119963 : }
119964 : else
119965 : {
119966 0 : std::cout << "SgComprehension :: " << std::flush;
119967 0 : std::cout << "SgExprListExp* p_filters = " << p_filters << " --> " << std::flush;
119968 0 : std::cout << " not valid " << std::endl;
119969 : }
119970 : }
119971 :
119972 0 : if ( p_operatorPosition != NULL )
119973 : {
119974 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119975 : {
119976 0 : if ( p_operatorPosition->isInMemoryPool() == false )
119977 : {
119978 0 : std::cout << "SgComprehension :: ";
119979 0 : std::cout << " p_operatorPosition is not in memory pool of ";
119980 0 : std::cout << p_operatorPosition->class_name() << std::endl;
119981 : }
119982 : }
119983 : else
119984 : {
119985 0 : std::cout << "SgComprehension :: " << std::flush;
119986 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
119987 0 : std::cout << " not valid " << std::endl;
119988 : }
119989 : }
119990 :
119991 0 : if ( p_startOfConstruct != NULL )
119992 : {
119993 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
119994 : {
119995 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
119996 : {
119997 0 : std::cout << "SgComprehension :: ";
119998 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
119999 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
120000 : }
120001 : }
120002 : else
120003 : {
120004 0 : std::cout << "SgComprehension :: " << std::flush;
120005 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
120006 0 : std::cout << " not valid " << std::endl;
120007 : }
120008 : }
120009 :
120010 0 : if ( p_endOfConstruct != NULL )
120011 : {
120012 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120013 : {
120014 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
120015 : {
120016 0 : std::cout << "SgComprehension :: ";
120017 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
120018 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
120019 : }
120020 : }
120021 : else
120022 : {
120023 0 : std::cout << "SgComprehension :: " << std::flush;
120024 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
120025 0 : std::cout << " not valid " << std::endl;
120026 : }
120027 : }
120028 :
120029 0 : if ( p_parent != NULL )
120030 : {
120031 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120032 : {
120033 0 : if ( p_parent->isInMemoryPool() == false )
120034 : {
120035 0 : std::cout << "SgComprehension :: ";
120036 0 : std::cout << " p_parent is not in memory pool of ";
120037 0 : std::cout << p_parent->class_name() << std::endl;
120038 : }
120039 : }
120040 : else
120041 : {
120042 0 : std::cout << "SgComprehension :: " << std::flush;
120043 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
120044 0 : std::cout << " not valid " << std::endl;
120045 : }
120046 : }
120047 :
120048 :
120049 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120050 :
120051 0 : }
120052 :
120053 :
120054 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
120055 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
120056 : bool
120057 0 : SgComprehension::isInMemoryPool ()
120058 : {
120059 0 : typedef unsigned char* TestType;
120060 :
120061 0 : bool found = false;
120062 :
120063 0 : ROSE_ASSERT(this != NULL);
120064 :
120065 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
120066 :
120067 0 : TestType tested = (TestType) ( this ) ;
120068 :
120069 0 : std::vector < unsigned char* > :: const_iterator block = SgComprehension::pools.begin();
120070 :
120071 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
120072 : // while (found == false && block < Memory_Block_List.end())
120073 0 : while ( (found == false) && (block != SgComprehension::pools.end()) )
120074 : {
120075 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgComprehension::pool_size * sizeof(SgComprehension) ) ) ;
120076 0 : ++block;
120077 : }
120078 :
120079 : // Special handling for static data
120080 :
120081 :
120082 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
120083 0 : ROSE_ASSERT(found == true);
120084 :
120085 0 : return found;
120086 : }
120087 : /* #line 120088 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
120088 :
120089 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
120090 :
120091 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120092 :
120093 : /* #line 120094 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
120094 :
120095 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120096 :
120097 : void
120098 0 : SgListComprehension::checkDataMemberPointersIfInMemoryPool()
120099 : {
120100 : // ------------ checking pointers of SgListComprehension -------------------
120101 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
120102 :
120103 0 : if ( p_element != NULL )
120104 : {
120105 0 : if ( p_element->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120106 : {
120107 0 : if ( p_element->isInMemoryPool() == false )
120108 : {
120109 0 : std::cout << "SgListComprehension :: ";
120110 0 : std::cout << " p_element is not in memory pool of ";
120111 0 : std::cout << p_element->class_name() << std::endl;
120112 : }
120113 : }
120114 : else
120115 : {
120116 0 : std::cout << "SgListComprehension :: " << std::flush;
120117 0 : std::cout << "SgExpression* p_element = " << p_element << " --> " << std::flush;
120118 0 : std::cout << " not valid " << std::endl;
120119 : }
120120 : }
120121 :
120122 0 : if ( p_generators != NULL )
120123 : {
120124 0 : if ( p_generators->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120125 : {
120126 0 : if ( p_generators->isInMemoryPool() == false )
120127 : {
120128 0 : std::cout << "SgListComprehension :: ";
120129 0 : std::cout << " p_generators is not in memory pool of ";
120130 0 : std::cout << p_generators->class_name() << std::endl;
120131 : }
120132 : }
120133 : else
120134 : {
120135 0 : std::cout << "SgListComprehension :: " << std::flush;
120136 0 : std::cout << "SgExprListExp* p_generators = " << p_generators << " --> " << std::flush;
120137 0 : std::cout << " not valid " << std::endl;
120138 : }
120139 : }
120140 :
120141 0 : if ( p_operatorPosition != NULL )
120142 : {
120143 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120144 : {
120145 0 : if ( p_operatorPosition->isInMemoryPool() == false )
120146 : {
120147 0 : std::cout << "SgListComprehension :: ";
120148 0 : std::cout << " p_operatorPosition is not in memory pool of ";
120149 0 : std::cout << p_operatorPosition->class_name() << std::endl;
120150 : }
120151 : }
120152 : else
120153 : {
120154 0 : std::cout << "SgListComprehension :: " << std::flush;
120155 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
120156 0 : std::cout << " not valid " << std::endl;
120157 : }
120158 : }
120159 :
120160 0 : if ( p_startOfConstruct != NULL )
120161 : {
120162 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120163 : {
120164 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
120165 : {
120166 0 : std::cout << "SgListComprehension :: ";
120167 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
120168 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
120169 : }
120170 : }
120171 : else
120172 : {
120173 0 : std::cout << "SgListComprehension :: " << std::flush;
120174 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
120175 0 : std::cout << " not valid " << std::endl;
120176 : }
120177 : }
120178 :
120179 0 : if ( p_endOfConstruct != NULL )
120180 : {
120181 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120182 : {
120183 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
120184 : {
120185 0 : std::cout << "SgListComprehension :: ";
120186 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
120187 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
120188 : }
120189 : }
120190 : else
120191 : {
120192 0 : std::cout << "SgListComprehension :: " << std::flush;
120193 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
120194 0 : std::cout << " not valid " << std::endl;
120195 : }
120196 : }
120197 :
120198 0 : if ( p_parent != NULL )
120199 : {
120200 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120201 : {
120202 0 : if ( p_parent->isInMemoryPool() == false )
120203 : {
120204 0 : std::cout << "SgListComprehension :: ";
120205 0 : std::cout << " p_parent is not in memory pool of ";
120206 0 : std::cout << p_parent->class_name() << std::endl;
120207 : }
120208 : }
120209 : else
120210 : {
120211 0 : std::cout << "SgListComprehension :: " << std::flush;
120212 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
120213 0 : std::cout << " not valid " << std::endl;
120214 : }
120215 : }
120216 :
120217 :
120218 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120219 :
120220 0 : }
120221 :
120222 :
120223 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
120224 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
120225 : bool
120226 0 : SgListComprehension::isInMemoryPool ()
120227 : {
120228 0 : typedef unsigned char* TestType;
120229 :
120230 0 : bool found = false;
120231 :
120232 0 : ROSE_ASSERT(this != NULL);
120233 :
120234 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
120235 :
120236 0 : TestType tested = (TestType) ( this ) ;
120237 :
120238 0 : std::vector < unsigned char* > :: const_iterator block = SgListComprehension::pools.begin();
120239 :
120240 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
120241 : // while (found == false && block < Memory_Block_List.end())
120242 0 : while ( (found == false) && (block != SgListComprehension::pools.end()) )
120243 : {
120244 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgListComprehension::pool_size * sizeof(SgListComprehension) ) ) ;
120245 0 : ++block;
120246 : }
120247 :
120248 : // Special handling for static data
120249 :
120250 :
120251 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
120252 0 : ROSE_ASSERT(found == true);
120253 :
120254 0 : return found;
120255 : }
120256 : /* #line 120257 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
120257 :
120258 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
120259 :
120260 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120261 :
120262 : /* #line 120263 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
120263 :
120264 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120265 :
120266 : void
120267 0 : SgSetComprehension::checkDataMemberPointersIfInMemoryPool()
120268 : {
120269 : // ------------ checking pointers of SgSetComprehension -------------------
120270 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
120271 :
120272 0 : if ( p_element != NULL )
120273 : {
120274 0 : if ( p_element->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120275 : {
120276 0 : if ( p_element->isInMemoryPool() == false )
120277 : {
120278 0 : std::cout << "SgSetComprehension :: ";
120279 0 : std::cout << " p_element is not in memory pool of ";
120280 0 : std::cout << p_element->class_name() << std::endl;
120281 : }
120282 : }
120283 : else
120284 : {
120285 0 : std::cout << "SgSetComprehension :: " << std::flush;
120286 0 : std::cout << "SgExpression* p_element = " << p_element << " --> " << std::flush;
120287 0 : std::cout << " not valid " << std::endl;
120288 : }
120289 : }
120290 :
120291 0 : if ( p_generators != NULL )
120292 : {
120293 0 : if ( p_generators->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120294 : {
120295 0 : if ( p_generators->isInMemoryPool() == false )
120296 : {
120297 0 : std::cout << "SgSetComprehension :: ";
120298 0 : std::cout << " p_generators is not in memory pool of ";
120299 0 : std::cout << p_generators->class_name() << std::endl;
120300 : }
120301 : }
120302 : else
120303 : {
120304 0 : std::cout << "SgSetComprehension :: " << std::flush;
120305 0 : std::cout << "SgExprListExp* p_generators = " << p_generators << " --> " << std::flush;
120306 0 : std::cout << " not valid " << std::endl;
120307 : }
120308 : }
120309 :
120310 0 : if ( p_operatorPosition != NULL )
120311 : {
120312 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120313 : {
120314 0 : if ( p_operatorPosition->isInMemoryPool() == false )
120315 : {
120316 0 : std::cout << "SgSetComprehension :: ";
120317 0 : std::cout << " p_operatorPosition is not in memory pool of ";
120318 0 : std::cout << p_operatorPosition->class_name() << std::endl;
120319 : }
120320 : }
120321 : else
120322 : {
120323 0 : std::cout << "SgSetComprehension :: " << std::flush;
120324 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
120325 0 : std::cout << " not valid " << std::endl;
120326 : }
120327 : }
120328 :
120329 0 : if ( p_startOfConstruct != NULL )
120330 : {
120331 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120332 : {
120333 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
120334 : {
120335 0 : std::cout << "SgSetComprehension :: ";
120336 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
120337 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
120338 : }
120339 : }
120340 : else
120341 : {
120342 0 : std::cout << "SgSetComprehension :: " << std::flush;
120343 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
120344 0 : std::cout << " not valid " << std::endl;
120345 : }
120346 : }
120347 :
120348 0 : if ( p_endOfConstruct != NULL )
120349 : {
120350 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120351 : {
120352 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
120353 : {
120354 0 : std::cout << "SgSetComprehension :: ";
120355 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
120356 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
120357 : }
120358 : }
120359 : else
120360 : {
120361 0 : std::cout << "SgSetComprehension :: " << std::flush;
120362 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
120363 0 : std::cout << " not valid " << std::endl;
120364 : }
120365 : }
120366 :
120367 0 : if ( p_parent != NULL )
120368 : {
120369 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120370 : {
120371 0 : if ( p_parent->isInMemoryPool() == false )
120372 : {
120373 0 : std::cout << "SgSetComprehension :: ";
120374 0 : std::cout << " p_parent is not in memory pool of ";
120375 0 : std::cout << p_parent->class_name() << std::endl;
120376 : }
120377 : }
120378 : else
120379 : {
120380 0 : std::cout << "SgSetComprehension :: " << std::flush;
120381 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
120382 0 : std::cout << " not valid " << std::endl;
120383 : }
120384 : }
120385 :
120386 :
120387 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120388 :
120389 0 : }
120390 :
120391 :
120392 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
120393 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
120394 : bool
120395 0 : SgSetComprehension::isInMemoryPool ()
120396 : {
120397 0 : typedef unsigned char* TestType;
120398 :
120399 0 : bool found = false;
120400 :
120401 0 : ROSE_ASSERT(this != NULL);
120402 :
120403 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
120404 :
120405 0 : TestType tested = (TestType) ( this ) ;
120406 :
120407 0 : std::vector < unsigned char* > :: const_iterator block = SgSetComprehension::pools.begin();
120408 :
120409 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
120410 : // while (found == false && block < Memory_Block_List.end())
120411 0 : while ( (found == false) && (block != SgSetComprehension::pools.end()) )
120412 : {
120413 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSetComprehension::pool_size * sizeof(SgSetComprehension) ) ) ;
120414 0 : ++block;
120415 : }
120416 :
120417 : // Special handling for static data
120418 :
120419 :
120420 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
120421 0 : ROSE_ASSERT(found == true);
120422 :
120423 0 : return found;
120424 : }
120425 : /* #line 120426 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
120426 :
120427 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
120428 :
120429 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120430 :
120431 : /* #line 120432 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
120432 :
120433 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120434 :
120435 : void
120436 0 : SgDictionaryComprehension::checkDataMemberPointersIfInMemoryPool()
120437 : {
120438 : // ------------ checking pointers of SgDictionaryComprehension -------------------
120439 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
120440 :
120441 0 : if ( p_element != NULL )
120442 : {
120443 0 : if ( p_element->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120444 : {
120445 0 : if ( p_element->isInMemoryPool() == false )
120446 : {
120447 0 : std::cout << "SgDictionaryComprehension :: ";
120448 0 : std::cout << " p_element is not in memory pool of ";
120449 0 : std::cout << p_element->class_name() << std::endl;
120450 : }
120451 : }
120452 : else
120453 : {
120454 0 : std::cout << "SgDictionaryComprehension :: " << std::flush;
120455 0 : std::cout << "SgKeyDatumPair* p_element = " << p_element << " --> " << std::flush;
120456 0 : std::cout << " not valid " << std::endl;
120457 : }
120458 : }
120459 :
120460 0 : if ( p_generators != NULL )
120461 : {
120462 0 : if ( p_generators->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120463 : {
120464 0 : if ( p_generators->isInMemoryPool() == false )
120465 : {
120466 0 : std::cout << "SgDictionaryComprehension :: ";
120467 0 : std::cout << " p_generators is not in memory pool of ";
120468 0 : std::cout << p_generators->class_name() << std::endl;
120469 : }
120470 : }
120471 : else
120472 : {
120473 0 : std::cout << "SgDictionaryComprehension :: " << std::flush;
120474 0 : std::cout << "SgExprListExp* p_generators = " << p_generators << " --> " << std::flush;
120475 0 : std::cout << " not valid " << std::endl;
120476 : }
120477 : }
120478 :
120479 0 : if ( p_operatorPosition != NULL )
120480 : {
120481 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120482 : {
120483 0 : if ( p_operatorPosition->isInMemoryPool() == false )
120484 : {
120485 0 : std::cout << "SgDictionaryComprehension :: ";
120486 0 : std::cout << " p_operatorPosition is not in memory pool of ";
120487 0 : std::cout << p_operatorPosition->class_name() << std::endl;
120488 : }
120489 : }
120490 : else
120491 : {
120492 0 : std::cout << "SgDictionaryComprehension :: " << std::flush;
120493 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
120494 0 : std::cout << " not valid " << std::endl;
120495 : }
120496 : }
120497 :
120498 0 : if ( p_startOfConstruct != NULL )
120499 : {
120500 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120501 : {
120502 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
120503 : {
120504 0 : std::cout << "SgDictionaryComprehension :: ";
120505 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
120506 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
120507 : }
120508 : }
120509 : else
120510 : {
120511 0 : std::cout << "SgDictionaryComprehension :: " << std::flush;
120512 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
120513 0 : std::cout << " not valid " << std::endl;
120514 : }
120515 : }
120516 :
120517 0 : if ( p_endOfConstruct != NULL )
120518 : {
120519 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120520 : {
120521 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
120522 : {
120523 0 : std::cout << "SgDictionaryComprehension :: ";
120524 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
120525 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
120526 : }
120527 : }
120528 : else
120529 : {
120530 0 : std::cout << "SgDictionaryComprehension :: " << std::flush;
120531 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
120532 0 : std::cout << " not valid " << std::endl;
120533 : }
120534 : }
120535 :
120536 0 : if ( p_parent != NULL )
120537 : {
120538 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120539 : {
120540 0 : if ( p_parent->isInMemoryPool() == false )
120541 : {
120542 0 : std::cout << "SgDictionaryComprehension :: ";
120543 0 : std::cout << " p_parent is not in memory pool of ";
120544 0 : std::cout << p_parent->class_name() << std::endl;
120545 : }
120546 : }
120547 : else
120548 : {
120549 0 : std::cout << "SgDictionaryComprehension :: " << std::flush;
120550 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
120551 0 : std::cout << " not valid " << std::endl;
120552 : }
120553 : }
120554 :
120555 :
120556 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120557 :
120558 0 : }
120559 :
120560 :
120561 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
120562 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
120563 : bool
120564 0 : SgDictionaryComprehension::isInMemoryPool ()
120565 : {
120566 0 : typedef unsigned char* TestType;
120567 :
120568 0 : bool found = false;
120569 :
120570 0 : ROSE_ASSERT(this != NULL);
120571 :
120572 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
120573 :
120574 0 : TestType tested = (TestType) ( this ) ;
120575 :
120576 0 : std::vector < unsigned char* > :: const_iterator block = SgDictionaryComprehension::pools.begin();
120577 :
120578 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
120579 : // while (found == false && block < Memory_Block_List.end())
120580 0 : while ( (found == false) && (block != SgDictionaryComprehension::pools.end()) )
120581 : {
120582 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDictionaryComprehension::pool_size * sizeof(SgDictionaryComprehension) ) ) ;
120583 0 : ++block;
120584 : }
120585 :
120586 : // Special handling for static data
120587 :
120588 :
120589 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
120590 0 : ROSE_ASSERT(found == true);
120591 :
120592 0 : return found;
120593 : }
120594 : /* #line 120595 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
120595 :
120596 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
120597 :
120598 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120599 :
120600 : /* #line 120601 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
120601 :
120602 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120603 :
120604 : void
120605 0 : SgNaryOp::checkDataMemberPointersIfInMemoryPool()
120606 : {
120607 : // ------------ checking pointers of SgNaryOp -------------------
120608 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
120609 :
120610 0 : SgExpressionPtrList::iterator i_operands = p_operands.begin() ;
120611 0 : for ( ; i_operands != p_operands.end(); ++i_operands )
120612 : {
120613 0 : if ( (*i_operands) != NULL )
120614 : {
120615 0 : if ( (*i_operands)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120616 : {
120617 0 : if ( (*i_operands)->isInMemoryPool() == false )
120618 : {
120619 0 : std::cout << "SgNaryOp :: ";
120620 0 : std::cout << " p_operands ( list of poitners to IR nodes ), entry is not in memory pool of ";
120621 0 : std::cout << (*i_operands)->class_name() << std::endl;
120622 : }
120623 : }
120624 : else
120625 : {
120626 0 : std::cout << "SgNaryOp :: " << std::flush;
120627 0 : std::cout << "SgExpressionPtrList p_operands --> " << std::flush;
120628 0 : std::cout << " entry not valid " << std::endl;
120629 : }
120630 : }
120631 : else
120632 : {
120633 0 : std::cout << "SgExpressionPtrList p_operands --> NULL " << std::endl;
120634 : }
120635 : }
120636 :
120637 0 : if ( p_operatorPosition != NULL )
120638 : {
120639 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120640 : {
120641 0 : if ( p_operatorPosition->isInMemoryPool() == false )
120642 : {
120643 0 : std::cout << "SgNaryOp :: ";
120644 0 : std::cout << " p_operatorPosition is not in memory pool of ";
120645 0 : std::cout << p_operatorPosition->class_name() << std::endl;
120646 : }
120647 : }
120648 : else
120649 : {
120650 0 : std::cout << "SgNaryOp :: " << std::flush;
120651 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
120652 0 : std::cout << " not valid " << std::endl;
120653 : }
120654 : }
120655 :
120656 0 : if ( p_startOfConstruct != NULL )
120657 : {
120658 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120659 : {
120660 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
120661 : {
120662 0 : std::cout << "SgNaryOp :: ";
120663 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
120664 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
120665 : }
120666 : }
120667 : else
120668 : {
120669 0 : std::cout << "SgNaryOp :: " << std::flush;
120670 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
120671 0 : std::cout << " not valid " << std::endl;
120672 : }
120673 : }
120674 :
120675 0 : if ( p_endOfConstruct != NULL )
120676 : {
120677 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120678 : {
120679 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
120680 : {
120681 0 : std::cout << "SgNaryOp :: ";
120682 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
120683 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
120684 : }
120685 : }
120686 : else
120687 : {
120688 0 : std::cout << "SgNaryOp :: " << std::flush;
120689 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
120690 0 : std::cout << " not valid " << std::endl;
120691 : }
120692 : }
120693 :
120694 0 : if ( p_parent != NULL )
120695 : {
120696 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120697 : {
120698 0 : if ( p_parent->isInMemoryPool() == false )
120699 : {
120700 0 : std::cout << "SgNaryOp :: ";
120701 0 : std::cout << " p_parent is not in memory pool of ";
120702 0 : std::cout << p_parent->class_name() << std::endl;
120703 : }
120704 : }
120705 : else
120706 : {
120707 0 : std::cout << "SgNaryOp :: " << std::flush;
120708 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
120709 0 : std::cout << " not valid " << std::endl;
120710 : }
120711 : }
120712 :
120713 :
120714 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120715 :
120716 0 : }
120717 :
120718 :
120719 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
120720 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
120721 : bool
120722 0 : SgNaryOp::isInMemoryPool ()
120723 : {
120724 0 : typedef unsigned char* TestType;
120725 :
120726 0 : bool found = false;
120727 :
120728 0 : ROSE_ASSERT(this != NULL);
120729 :
120730 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
120731 :
120732 0 : TestType tested = (TestType) ( this ) ;
120733 :
120734 0 : std::vector < unsigned char* > :: const_iterator block = SgNaryOp::pools.begin();
120735 :
120736 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
120737 : // while (found == false && block < Memory_Block_List.end())
120738 0 : while ( (found == false) && (block != SgNaryOp::pools.end()) )
120739 : {
120740 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNaryOp::pool_size * sizeof(SgNaryOp) ) ) ;
120741 0 : ++block;
120742 : }
120743 :
120744 : // Special handling for static data
120745 :
120746 :
120747 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
120748 0 : ROSE_ASSERT(found == true);
120749 :
120750 0 : return found;
120751 : }
120752 : /* #line 120753 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
120753 :
120754 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
120755 :
120756 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120757 :
120758 : /* #line 120759 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
120759 :
120760 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120761 :
120762 : void
120763 0 : SgNaryBooleanOp::checkDataMemberPointersIfInMemoryPool()
120764 : {
120765 : // ------------ checking pointers of SgNaryBooleanOp -------------------
120766 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
120767 :
120768 0 : SgExpressionPtrList::iterator i_operands = p_operands.begin() ;
120769 0 : for ( ; i_operands != p_operands.end(); ++i_operands )
120770 : {
120771 0 : if ( (*i_operands) != NULL )
120772 : {
120773 0 : if ( (*i_operands)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120774 : {
120775 0 : if ( (*i_operands)->isInMemoryPool() == false )
120776 : {
120777 0 : std::cout << "SgNaryBooleanOp :: ";
120778 0 : std::cout << " p_operands ( list of poitners to IR nodes ), entry is not in memory pool of ";
120779 0 : std::cout << (*i_operands)->class_name() << std::endl;
120780 : }
120781 : }
120782 : else
120783 : {
120784 0 : std::cout << "SgNaryBooleanOp :: " << std::flush;
120785 0 : std::cout << "SgExpressionPtrList p_operands --> " << std::flush;
120786 0 : std::cout << " entry not valid " << std::endl;
120787 : }
120788 : }
120789 : else
120790 : {
120791 0 : std::cout << "SgExpressionPtrList p_operands --> NULL " << std::endl;
120792 : }
120793 : }
120794 :
120795 0 : if ( p_operatorPosition != NULL )
120796 : {
120797 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120798 : {
120799 0 : if ( p_operatorPosition->isInMemoryPool() == false )
120800 : {
120801 0 : std::cout << "SgNaryBooleanOp :: ";
120802 0 : std::cout << " p_operatorPosition is not in memory pool of ";
120803 0 : std::cout << p_operatorPosition->class_name() << std::endl;
120804 : }
120805 : }
120806 : else
120807 : {
120808 0 : std::cout << "SgNaryBooleanOp :: " << std::flush;
120809 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
120810 0 : std::cout << " not valid " << std::endl;
120811 : }
120812 : }
120813 :
120814 0 : if ( p_startOfConstruct != NULL )
120815 : {
120816 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120817 : {
120818 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
120819 : {
120820 0 : std::cout << "SgNaryBooleanOp :: ";
120821 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
120822 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
120823 : }
120824 : }
120825 : else
120826 : {
120827 0 : std::cout << "SgNaryBooleanOp :: " << std::flush;
120828 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
120829 0 : std::cout << " not valid " << std::endl;
120830 : }
120831 : }
120832 :
120833 0 : if ( p_endOfConstruct != NULL )
120834 : {
120835 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120836 : {
120837 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
120838 : {
120839 0 : std::cout << "SgNaryBooleanOp :: ";
120840 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
120841 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
120842 : }
120843 : }
120844 : else
120845 : {
120846 0 : std::cout << "SgNaryBooleanOp :: " << std::flush;
120847 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
120848 0 : std::cout << " not valid " << std::endl;
120849 : }
120850 : }
120851 :
120852 0 : if ( p_parent != NULL )
120853 : {
120854 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120855 : {
120856 0 : if ( p_parent->isInMemoryPool() == false )
120857 : {
120858 0 : std::cout << "SgNaryBooleanOp :: ";
120859 0 : std::cout << " p_parent is not in memory pool of ";
120860 0 : std::cout << p_parent->class_name() << std::endl;
120861 : }
120862 : }
120863 : else
120864 : {
120865 0 : std::cout << "SgNaryBooleanOp :: " << std::flush;
120866 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
120867 0 : std::cout << " not valid " << std::endl;
120868 : }
120869 : }
120870 :
120871 :
120872 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120873 :
120874 0 : }
120875 :
120876 :
120877 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
120878 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
120879 : bool
120880 0 : SgNaryBooleanOp::isInMemoryPool ()
120881 : {
120882 0 : typedef unsigned char* TestType;
120883 :
120884 0 : bool found = false;
120885 :
120886 0 : ROSE_ASSERT(this != NULL);
120887 :
120888 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
120889 :
120890 0 : TestType tested = (TestType) ( this ) ;
120891 :
120892 0 : std::vector < unsigned char* > :: const_iterator block = SgNaryBooleanOp::pools.begin();
120893 :
120894 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
120895 : // while (found == false && block < Memory_Block_List.end())
120896 0 : while ( (found == false) && (block != SgNaryBooleanOp::pools.end()) )
120897 : {
120898 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNaryBooleanOp::pool_size * sizeof(SgNaryBooleanOp) ) ) ;
120899 0 : ++block;
120900 : }
120901 :
120902 : // Special handling for static data
120903 :
120904 :
120905 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
120906 0 : ROSE_ASSERT(found == true);
120907 :
120908 0 : return found;
120909 : }
120910 : /* #line 120911 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
120911 :
120912 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
120913 :
120914 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120915 :
120916 : /* #line 120917 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
120917 :
120918 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
120919 :
120920 : void
120921 0 : SgNaryComparisonOp::checkDataMemberPointersIfInMemoryPool()
120922 : {
120923 : // ------------ checking pointers of SgNaryComparisonOp -------------------
120924 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
120925 :
120926 0 : SgExpressionPtrList::iterator i_operands = p_operands.begin() ;
120927 0 : for ( ; i_operands != p_operands.end(); ++i_operands )
120928 : {
120929 0 : if ( (*i_operands) != NULL )
120930 : {
120931 0 : if ( (*i_operands)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120932 : {
120933 0 : if ( (*i_operands)->isInMemoryPool() == false )
120934 : {
120935 0 : std::cout << "SgNaryComparisonOp :: ";
120936 0 : std::cout << " p_operands ( list of poitners to IR nodes ), entry is not in memory pool of ";
120937 0 : std::cout << (*i_operands)->class_name() << std::endl;
120938 : }
120939 : }
120940 : else
120941 : {
120942 0 : std::cout << "SgNaryComparisonOp :: " << std::flush;
120943 0 : std::cout << "SgExpressionPtrList p_operands --> " << std::flush;
120944 0 : std::cout << " entry not valid " << std::endl;
120945 : }
120946 : }
120947 : else
120948 : {
120949 0 : std::cout << "SgExpressionPtrList p_operands --> NULL " << std::endl;
120950 : }
120951 : }
120952 :
120953 0 : if ( p_operatorPosition != NULL )
120954 : {
120955 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120956 : {
120957 0 : if ( p_operatorPosition->isInMemoryPool() == false )
120958 : {
120959 0 : std::cout << "SgNaryComparisonOp :: ";
120960 0 : std::cout << " p_operatorPosition is not in memory pool of ";
120961 0 : std::cout << p_operatorPosition->class_name() << std::endl;
120962 : }
120963 : }
120964 : else
120965 : {
120966 0 : std::cout << "SgNaryComparisonOp :: " << std::flush;
120967 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
120968 0 : std::cout << " not valid " << std::endl;
120969 : }
120970 : }
120971 :
120972 0 : if ( p_startOfConstruct != NULL )
120973 : {
120974 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120975 : {
120976 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
120977 : {
120978 0 : std::cout << "SgNaryComparisonOp :: ";
120979 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
120980 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
120981 : }
120982 : }
120983 : else
120984 : {
120985 0 : std::cout << "SgNaryComparisonOp :: " << std::flush;
120986 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
120987 0 : std::cout << " not valid " << std::endl;
120988 : }
120989 : }
120990 :
120991 0 : if ( p_endOfConstruct != NULL )
120992 : {
120993 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
120994 : {
120995 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
120996 : {
120997 0 : std::cout << "SgNaryComparisonOp :: ";
120998 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
120999 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
121000 : }
121001 : }
121002 : else
121003 : {
121004 0 : std::cout << "SgNaryComparisonOp :: " << std::flush;
121005 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
121006 0 : std::cout << " not valid " << std::endl;
121007 : }
121008 : }
121009 :
121010 0 : if ( p_parent != NULL )
121011 : {
121012 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121013 : {
121014 0 : if ( p_parent->isInMemoryPool() == false )
121015 : {
121016 0 : std::cout << "SgNaryComparisonOp :: ";
121017 0 : std::cout << " p_parent is not in memory pool of ";
121018 0 : std::cout << p_parent->class_name() << std::endl;
121019 : }
121020 : }
121021 : else
121022 : {
121023 0 : std::cout << "SgNaryComparisonOp :: " << std::flush;
121024 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
121025 0 : std::cout << " not valid " << std::endl;
121026 : }
121027 : }
121028 :
121029 :
121030 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121031 :
121032 0 : }
121033 :
121034 :
121035 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
121036 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
121037 : bool
121038 0 : SgNaryComparisonOp::isInMemoryPool ()
121039 : {
121040 0 : typedef unsigned char* TestType;
121041 :
121042 0 : bool found = false;
121043 :
121044 0 : ROSE_ASSERT(this != NULL);
121045 :
121046 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
121047 :
121048 0 : TestType tested = (TestType) ( this ) ;
121049 :
121050 0 : std::vector < unsigned char* > :: const_iterator block = SgNaryComparisonOp::pools.begin();
121051 :
121052 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
121053 : // while (found == false && block < Memory_Block_List.end())
121054 0 : while ( (found == false) && (block != SgNaryComparisonOp::pools.end()) )
121055 : {
121056 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNaryComparisonOp::pool_size * sizeof(SgNaryComparisonOp) ) ) ;
121057 0 : ++block;
121058 : }
121059 :
121060 : // Special handling for static data
121061 :
121062 :
121063 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
121064 0 : ROSE_ASSERT(found == true);
121065 :
121066 0 : return found;
121067 : }
121068 : /* #line 121069 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
121069 :
121070 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
121071 :
121072 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121073 :
121074 : /* #line 121075 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
121075 :
121076 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121077 :
121078 : void
121079 0 : SgStringConversion::checkDataMemberPointersIfInMemoryPool()
121080 : {
121081 : // ------------ checking pointers of SgStringConversion -------------------
121082 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
121083 :
121084 0 : if ( p_expression != NULL )
121085 : {
121086 0 : if ( p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121087 : {
121088 0 : if ( p_expression->isInMemoryPool() == false )
121089 : {
121090 0 : std::cout << "SgStringConversion :: ";
121091 0 : std::cout << " p_expression is not in memory pool of ";
121092 0 : std::cout << p_expression->class_name() << std::endl;
121093 : }
121094 : }
121095 : else
121096 : {
121097 0 : std::cout << "SgStringConversion :: " << std::flush;
121098 0 : std::cout << "SgExpression* p_expression = " << p_expression << " --> " << std::flush;
121099 0 : std::cout << " not valid " << std::endl;
121100 : }
121101 : }
121102 :
121103 0 : if ( p_operatorPosition != NULL )
121104 : {
121105 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121106 : {
121107 0 : if ( p_operatorPosition->isInMemoryPool() == false )
121108 : {
121109 0 : std::cout << "SgStringConversion :: ";
121110 0 : std::cout << " p_operatorPosition is not in memory pool of ";
121111 0 : std::cout << p_operatorPosition->class_name() << std::endl;
121112 : }
121113 : }
121114 : else
121115 : {
121116 0 : std::cout << "SgStringConversion :: " << std::flush;
121117 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
121118 0 : std::cout << " not valid " << std::endl;
121119 : }
121120 : }
121121 :
121122 0 : if ( p_startOfConstruct != NULL )
121123 : {
121124 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121125 : {
121126 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
121127 : {
121128 0 : std::cout << "SgStringConversion :: ";
121129 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
121130 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
121131 : }
121132 : }
121133 : else
121134 : {
121135 0 : std::cout << "SgStringConversion :: " << std::flush;
121136 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
121137 0 : std::cout << " not valid " << std::endl;
121138 : }
121139 : }
121140 :
121141 0 : if ( p_endOfConstruct != NULL )
121142 : {
121143 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121144 : {
121145 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
121146 : {
121147 0 : std::cout << "SgStringConversion :: ";
121148 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
121149 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
121150 : }
121151 : }
121152 : else
121153 : {
121154 0 : std::cout << "SgStringConversion :: " << std::flush;
121155 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
121156 0 : std::cout << " not valid " << std::endl;
121157 : }
121158 : }
121159 :
121160 0 : if ( p_parent != NULL )
121161 : {
121162 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121163 : {
121164 0 : if ( p_parent->isInMemoryPool() == false )
121165 : {
121166 0 : std::cout << "SgStringConversion :: ";
121167 0 : std::cout << " p_parent is not in memory pool of ";
121168 0 : std::cout << p_parent->class_name() << std::endl;
121169 : }
121170 : }
121171 : else
121172 : {
121173 0 : std::cout << "SgStringConversion :: " << std::flush;
121174 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
121175 0 : std::cout << " not valid " << std::endl;
121176 : }
121177 : }
121178 :
121179 :
121180 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121181 :
121182 0 : }
121183 :
121184 :
121185 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
121186 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
121187 : bool
121188 0 : SgStringConversion::isInMemoryPool ()
121189 : {
121190 0 : typedef unsigned char* TestType;
121191 :
121192 0 : bool found = false;
121193 :
121194 0 : ROSE_ASSERT(this != NULL);
121195 :
121196 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
121197 :
121198 0 : TestType tested = (TestType) ( this ) ;
121199 :
121200 0 : std::vector < unsigned char* > :: const_iterator block = SgStringConversion::pools.begin();
121201 :
121202 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
121203 : // while (found == false && block < Memory_Block_List.end())
121204 0 : while ( (found == false) && (block != SgStringConversion::pools.end()) )
121205 : {
121206 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgStringConversion::pool_size * sizeof(SgStringConversion) ) ) ;
121207 0 : ++block;
121208 : }
121209 :
121210 : // Special handling for static data
121211 :
121212 :
121213 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
121214 0 : ROSE_ASSERT(found == true);
121215 :
121216 0 : return found;
121217 : }
121218 : /* #line 121219 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
121219 :
121220 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
121221 :
121222 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121223 :
121224 : /* #line 121225 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
121225 :
121226 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121227 :
121228 : void
121229 0 : SgYieldExpression::checkDataMemberPointersIfInMemoryPool()
121230 : {
121231 : // ------------ checking pointers of SgYieldExpression -------------------
121232 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
121233 :
121234 0 : if ( p_value != NULL )
121235 : {
121236 0 : if ( p_value->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121237 : {
121238 0 : if ( p_value->isInMemoryPool() == false )
121239 : {
121240 0 : std::cout << "SgYieldExpression :: ";
121241 0 : std::cout << " p_value is not in memory pool of ";
121242 0 : std::cout << p_value->class_name() << std::endl;
121243 : }
121244 : }
121245 : else
121246 : {
121247 0 : std::cout << "SgYieldExpression :: " << std::flush;
121248 0 : std::cout << "SgExpression* p_value = " << p_value << " --> " << std::flush;
121249 0 : std::cout << " not valid " << std::endl;
121250 : }
121251 : }
121252 :
121253 0 : if ( p_operatorPosition != NULL )
121254 : {
121255 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121256 : {
121257 0 : if ( p_operatorPosition->isInMemoryPool() == false )
121258 : {
121259 0 : std::cout << "SgYieldExpression :: ";
121260 0 : std::cout << " p_operatorPosition is not in memory pool of ";
121261 0 : std::cout << p_operatorPosition->class_name() << std::endl;
121262 : }
121263 : }
121264 : else
121265 : {
121266 0 : std::cout << "SgYieldExpression :: " << std::flush;
121267 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
121268 0 : std::cout << " not valid " << std::endl;
121269 : }
121270 : }
121271 :
121272 0 : if ( p_startOfConstruct != NULL )
121273 : {
121274 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121275 : {
121276 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
121277 : {
121278 0 : std::cout << "SgYieldExpression :: ";
121279 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
121280 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
121281 : }
121282 : }
121283 : else
121284 : {
121285 0 : std::cout << "SgYieldExpression :: " << std::flush;
121286 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
121287 0 : std::cout << " not valid " << std::endl;
121288 : }
121289 : }
121290 :
121291 0 : if ( p_endOfConstruct != NULL )
121292 : {
121293 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121294 : {
121295 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
121296 : {
121297 0 : std::cout << "SgYieldExpression :: ";
121298 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
121299 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
121300 : }
121301 : }
121302 : else
121303 : {
121304 0 : std::cout << "SgYieldExpression :: " << std::flush;
121305 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
121306 0 : std::cout << " not valid " << std::endl;
121307 : }
121308 : }
121309 :
121310 0 : if ( p_parent != NULL )
121311 : {
121312 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121313 : {
121314 0 : if ( p_parent->isInMemoryPool() == false )
121315 : {
121316 0 : std::cout << "SgYieldExpression :: ";
121317 0 : std::cout << " p_parent is not in memory pool of ";
121318 0 : std::cout << p_parent->class_name() << std::endl;
121319 : }
121320 : }
121321 : else
121322 : {
121323 0 : std::cout << "SgYieldExpression :: " << std::flush;
121324 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
121325 0 : std::cout << " not valid " << std::endl;
121326 : }
121327 : }
121328 :
121329 :
121330 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121331 :
121332 0 : }
121333 :
121334 :
121335 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
121336 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
121337 : bool
121338 0 : SgYieldExpression::isInMemoryPool ()
121339 : {
121340 0 : typedef unsigned char* TestType;
121341 :
121342 0 : bool found = false;
121343 :
121344 0 : ROSE_ASSERT(this != NULL);
121345 :
121346 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
121347 :
121348 0 : TestType tested = (TestType) ( this ) ;
121349 :
121350 0 : std::vector < unsigned char* > :: const_iterator block = SgYieldExpression::pools.begin();
121351 :
121352 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
121353 : // while (found == false && block < Memory_Block_List.end())
121354 0 : while ( (found == false) && (block != SgYieldExpression::pools.end()) )
121355 : {
121356 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgYieldExpression::pool_size * sizeof(SgYieldExpression) ) ) ;
121357 0 : ++block;
121358 : }
121359 :
121360 : // Special handling for static data
121361 :
121362 :
121363 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
121364 0 : ROSE_ASSERT(found == true);
121365 :
121366 0 : return found;
121367 : }
121368 : /* #line 121369 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
121369 :
121370 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
121371 :
121372 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121373 :
121374 : /* #line 121375 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
121375 :
121376 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121377 :
121378 : void
121379 0 : SgTemplateFunctionRefExp::checkDataMemberPointersIfInMemoryPool()
121380 : {
121381 : // ------------ checking pointers of SgTemplateFunctionRefExp -------------------
121382 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
121383 :
121384 0 : if ( p_symbol_i != NULL )
121385 : {
121386 0 : if ( p_symbol_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121387 : {
121388 0 : if ( p_symbol_i->isInMemoryPool() == false )
121389 : {
121390 0 : std::cout << "SgTemplateFunctionRefExp :: ";
121391 0 : std::cout << " p_symbol_i is not in memory pool of ";
121392 0 : std::cout << p_symbol_i->class_name() << std::endl;
121393 : }
121394 : }
121395 : else
121396 : {
121397 0 : std::cout << "SgTemplateFunctionRefExp :: " << std::flush;
121398 0 : std::cout << "SgTemplateFunctionSymbol* p_symbol_i = " << p_symbol_i << " --> " << std::flush;
121399 0 : std::cout << " not valid " << std::endl;
121400 : }
121401 : }
121402 :
121403 0 : if ( p_operatorPosition != NULL )
121404 : {
121405 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121406 : {
121407 0 : if ( p_operatorPosition->isInMemoryPool() == false )
121408 : {
121409 0 : std::cout << "SgTemplateFunctionRefExp :: ";
121410 0 : std::cout << " p_operatorPosition is not in memory pool of ";
121411 0 : std::cout << p_operatorPosition->class_name() << std::endl;
121412 : }
121413 : }
121414 : else
121415 : {
121416 0 : std::cout << "SgTemplateFunctionRefExp :: " << std::flush;
121417 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
121418 0 : std::cout << " not valid " << std::endl;
121419 : }
121420 : }
121421 :
121422 0 : if ( p_startOfConstruct != NULL )
121423 : {
121424 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121425 : {
121426 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
121427 : {
121428 0 : std::cout << "SgTemplateFunctionRefExp :: ";
121429 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
121430 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
121431 : }
121432 : }
121433 : else
121434 : {
121435 0 : std::cout << "SgTemplateFunctionRefExp :: " << std::flush;
121436 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
121437 0 : std::cout << " not valid " << std::endl;
121438 : }
121439 : }
121440 :
121441 0 : if ( p_endOfConstruct != NULL )
121442 : {
121443 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121444 : {
121445 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
121446 : {
121447 0 : std::cout << "SgTemplateFunctionRefExp :: ";
121448 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
121449 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
121450 : }
121451 : }
121452 : else
121453 : {
121454 0 : std::cout << "SgTemplateFunctionRefExp :: " << std::flush;
121455 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
121456 0 : std::cout << " not valid " << std::endl;
121457 : }
121458 : }
121459 :
121460 0 : if ( p_parent != NULL )
121461 : {
121462 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121463 : {
121464 0 : if ( p_parent->isInMemoryPool() == false )
121465 : {
121466 0 : std::cout << "SgTemplateFunctionRefExp :: ";
121467 0 : std::cout << " p_parent is not in memory pool of ";
121468 0 : std::cout << p_parent->class_name() << std::endl;
121469 : }
121470 : }
121471 : else
121472 : {
121473 0 : std::cout << "SgTemplateFunctionRefExp :: " << std::flush;
121474 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
121475 0 : std::cout << " not valid " << std::endl;
121476 : }
121477 : }
121478 :
121479 :
121480 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121481 :
121482 0 : }
121483 :
121484 :
121485 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
121486 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
121487 : bool
121488 0 : SgTemplateFunctionRefExp::isInMemoryPool ()
121489 : {
121490 0 : typedef unsigned char* TestType;
121491 :
121492 0 : bool found = false;
121493 :
121494 0 : ROSE_ASSERT(this != NULL);
121495 :
121496 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
121497 :
121498 0 : TestType tested = (TestType) ( this ) ;
121499 :
121500 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateFunctionRefExp::pools.begin();
121501 :
121502 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
121503 : // while (found == false && block < Memory_Block_List.end())
121504 0 : while ( (found == false) && (block != SgTemplateFunctionRefExp::pools.end()) )
121505 : {
121506 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateFunctionRefExp::pool_size * sizeof(SgTemplateFunctionRefExp) ) ) ;
121507 0 : ++block;
121508 : }
121509 :
121510 : // Special handling for static data
121511 :
121512 :
121513 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
121514 0 : ROSE_ASSERT(found == true);
121515 :
121516 0 : return found;
121517 : }
121518 : /* #line 121519 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
121519 :
121520 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
121521 :
121522 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121523 :
121524 : /* #line 121525 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
121525 :
121526 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121527 :
121528 : void
121529 0 : SgTemplateMemberFunctionRefExp::checkDataMemberPointersIfInMemoryPool()
121530 : {
121531 : // ------------ checking pointers of SgTemplateMemberFunctionRefExp -------------------
121532 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
121533 :
121534 0 : if ( p_symbol_i != NULL )
121535 : {
121536 0 : if ( p_symbol_i->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121537 : {
121538 0 : if ( p_symbol_i->isInMemoryPool() == false )
121539 : {
121540 0 : std::cout << "SgTemplateMemberFunctionRefExp :: ";
121541 0 : std::cout << " p_symbol_i is not in memory pool of ";
121542 0 : std::cout << p_symbol_i->class_name() << std::endl;
121543 : }
121544 : }
121545 : else
121546 : {
121547 0 : std::cout << "SgTemplateMemberFunctionRefExp :: " << std::flush;
121548 0 : std::cout << "SgTemplateMemberFunctionSymbol* p_symbol_i = " << p_symbol_i << " --> " << std::flush;
121549 0 : std::cout << " not valid " << std::endl;
121550 : }
121551 : }
121552 :
121553 0 : if ( p_operatorPosition != NULL )
121554 : {
121555 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121556 : {
121557 0 : if ( p_operatorPosition->isInMemoryPool() == false )
121558 : {
121559 0 : std::cout << "SgTemplateMemberFunctionRefExp :: ";
121560 0 : std::cout << " p_operatorPosition is not in memory pool of ";
121561 0 : std::cout << p_operatorPosition->class_name() << std::endl;
121562 : }
121563 : }
121564 : else
121565 : {
121566 0 : std::cout << "SgTemplateMemberFunctionRefExp :: " << std::flush;
121567 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
121568 0 : std::cout << " not valid " << std::endl;
121569 : }
121570 : }
121571 :
121572 0 : if ( p_startOfConstruct != NULL )
121573 : {
121574 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121575 : {
121576 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
121577 : {
121578 0 : std::cout << "SgTemplateMemberFunctionRefExp :: ";
121579 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
121580 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
121581 : }
121582 : }
121583 : else
121584 : {
121585 0 : std::cout << "SgTemplateMemberFunctionRefExp :: " << std::flush;
121586 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
121587 0 : std::cout << " not valid " << std::endl;
121588 : }
121589 : }
121590 :
121591 0 : if ( p_endOfConstruct != NULL )
121592 : {
121593 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121594 : {
121595 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
121596 : {
121597 0 : std::cout << "SgTemplateMemberFunctionRefExp :: ";
121598 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
121599 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
121600 : }
121601 : }
121602 : else
121603 : {
121604 0 : std::cout << "SgTemplateMemberFunctionRefExp :: " << std::flush;
121605 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
121606 0 : std::cout << " not valid " << std::endl;
121607 : }
121608 : }
121609 :
121610 0 : if ( p_parent != NULL )
121611 : {
121612 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121613 : {
121614 0 : if ( p_parent->isInMemoryPool() == false )
121615 : {
121616 0 : std::cout << "SgTemplateMemberFunctionRefExp :: ";
121617 0 : std::cout << " p_parent is not in memory pool of ";
121618 0 : std::cout << p_parent->class_name() << std::endl;
121619 : }
121620 : }
121621 : else
121622 : {
121623 0 : std::cout << "SgTemplateMemberFunctionRefExp :: " << std::flush;
121624 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
121625 0 : std::cout << " not valid " << std::endl;
121626 : }
121627 : }
121628 :
121629 :
121630 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121631 :
121632 0 : }
121633 :
121634 :
121635 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
121636 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
121637 : bool
121638 0 : SgTemplateMemberFunctionRefExp::isInMemoryPool ()
121639 : {
121640 0 : typedef unsigned char* TestType;
121641 :
121642 0 : bool found = false;
121643 :
121644 0 : ROSE_ASSERT(this != NULL);
121645 :
121646 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
121647 :
121648 0 : TestType tested = (TestType) ( this ) ;
121649 :
121650 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateMemberFunctionRefExp::pools.begin();
121651 :
121652 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
121653 : // while (found == false && block < Memory_Block_List.end())
121654 0 : while ( (found == false) && (block != SgTemplateMemberFunctionRefExp::pools.end()) )
121655 : {
121656 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateMemberFunctionRefExp::pool_size * sizeof(SgTemplateMemberFunctionRefExp) ) ) ;
121657 0 : ++block;
121658 : }
121659 :
121660 : // Special handling for static data
121661 :
121662 :
121663 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
121664 0 : ROSE_ASSERT(found == true);
121665 :
121666 0 : return found;
121667 : }
121668 : /* #line 121669 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
121669 :
121670 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
121671 :
121672 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121673 :
121674 : /* #line 121675 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
121675 :
121676 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121677 :
121678 : void
121679 0 : SgAlignOfOp::checkDataMemberPointersIfInMemoryPool()
121680 : {
121681 : // ------------ checking pointers of SgAlignOfOp -------------------
121682 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
121683 :
121684 0 : if ( p_operand_expr != NULL )
121685 : {
121686 0 : if ( p_operand_expr->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121687 : {
121688 0 : if ( p_operand_expr->isInMemoryPool() == false )
121689 : {
121690 0 : std::cout << "SgAlignOfOp :: ";
121691 0 : std::cout << " p_operand_expr is not in memory pool of ";
121692 0 : std::cout << p_operand_expr->class_name() << std::endl;
121693 : }
121694 : }
121695 : else
121696 : {
121697 0 : std::cout << "SgAlignOfOp :: " << std::flush;
121698 0 : std::cout << "SgExpression* p_operand_expr = " << p_operand_expr << " --> " << std::flush;
121699 0 : std::cout << " not valid " << std::endl;
121700 : }
121701 : }
121702 :
121703 0 : if ( p_operand_type != NULL )
121704 : {
121705 0 : if ( p_operand_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121706 : {
121707 0 : if ( p_operand_type->isInMemoryPool() == false )
121708 : {
121709 0 : std::cout << "SgAlignOfOp :: ";
121710 0 : std::cout << " p_operand_type is not in memory pool of ";
121711 0 : std::cout << p_operand_type->class_name() << std::endl;
121712 : }
121713 : }
121714 : else
121715 : {
121716 0 : std::cout << "SgAlignOfOp :: " << std::flush;
121717 0 : std::cout << "SgType* p_operand_type = " << p_operand_type << " --> " << std::flush;
121718 0 : std::cout << " not valid " << std::endl;
121719 : }
121720 : }
121721 :
121722 0 : if ( p_expression_type != NULL )
121723 : {
121724 0 : if ( p_expression_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121725 : {
121726 0 : if ( p_expression_type->isInMemoryPool() == false )
121727 : {
121728 0 : std::cout << "SgAlignOfOp :: ";
121729 0 : std::cout << " p_expression_type is not in memory pool of ";
121730 0 : std::cout << p_expression_type->class_name() << std::endl;
121731 : }
121732 : }
121733 : else
121734 : {
121735 0 : std::cout << "SgAlignOfOp :: " << std::flush;
121736 0 : std::cout << "SgType* p_expression_type = " << p_expression_type << " --> " << std::flush;
121737 0 : std::cout << " not valid " << std::endl;
121738 : }
121739 : }
121740 :
121741 0 : if ( p_operatorPosition != NULL )
121742 : {
121743 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121744 : {
121745 0 : if ( p_operatorPosition->isInMemoryPool() == false )
121746 : {
121747 0 : std::cout << "SgAlignOfOp :: ";
121748 0 : std::cout << " p_operatorPosition is not in memory pool of ";
121749 0 : std::cout << p_operatorPosition->class_name() << std::endl;
121750 : }
121751 : }
121752 : else
121753 : {
121754 0 : std::cout << "SgAlignOfOp :: " << std::flush;
121755 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
121756 0 : std::cout << " not valid " << std::endl;
121757 : }
121758 : }
121759 :
121760 0 : if ( p_startOfConstruct != NULL )
121761 : {
121762 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121763 : {
121764 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
121765 : {
121766 0 : std::cout << "SgAlignOfOp :: ";
121767 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
121768 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
121769 : }
121770 : }
121771 : else
121772 : {
121773 0 : std::cout << "SgAlignOfOp :: " << std::flush;
121774 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
121775 0 : std::cout << " not valid " << std::endl;
121776 : }
121777 : }
121778 :
121779 0 : if ( p_endOfConstruct != NULL )
121780 : {
121781 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121782 : {
121783 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
121784 : {
121785 0 : std::cout << "SgAlignOfOp :: ";
121786 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
121787 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
121788 : }
121789 : }
121790 : else
121791 : {
121792 0 : std::cout << "SgAlignOfOp :: " << std::flush;
121793 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
121794 0 : std::cout << " not valid " << std::endl;
121795 : }
121796 : }
121797 :
121798 0 : if ( p_parent != NULL )
121799 : {
121800 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121801 : {
121802 0 : if ( p_parent->isInMemoryPool() == false )
121803 : {
121804 0 : std::cout << "SgAlignOfOp :: ";
121805 0 : std::cout << " p_parent is not in memory pool of ";
121806 0 : std::cout << p_parent->class_name() << std::endl;
121807 : }
121808 : }
121809 : else
121810 : {
121811 0 : std::cout << "SgAlignOfOp :: " << std::flush;
121812 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
121813 0 : std::cout << " not valid " << std::endl;
121814 : }
121815 : }
121816 :
121817 :
121818 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121819 :
121820 0 : }
121821 :
121822 :
121823 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
121824 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
121825 : bool
121826 0 : SgAlignOfOp::isInMemoryPool ()
121827 : {
121828 0 : typedef unsigned char* TestType;
121829 :
121830 0 : bool found = false;
121831 :
121832 0 : ROSE_ASSERT(this != NULL);
121833 :
121834 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
121835 :
121836 0 : TestType tested = (TestType) ( this ) ;
121837 :
121838 0 : std::vector < unsigned char* > :: const_iterator block = SgAlignOfOp::pools.begin();
121839 :
121840 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
121841 : // while (found == false && block < Memory_Block_List.end())
121842 0 : while ( (found == false) && (block != SgAlignOfOp::pools.end()) )
121843 : {
121844 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAlignOfOp::pool_size * sizeof(SgAlignOfOp) ) ) ;
121845 0 : ++block;
121846 : }
121847 :
121848 : // Special handling for static data
121849 :
121850 :
121851 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
121852 0 : ROSE_ASSERT(found == true);
121853 :
121854 0 : return found;
121855 : }
121856 : /* #line 121857 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
121857 :
121858 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
121859 :
121860 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121861 :
121862 : /* #line 121863 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
121863 :
121864 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
121865 :
121866 : void
121867 0 : SgRangeExp::checkDataMemberPointersIfInMemoryPool()
121868 : {
121869 : // ------------ checking pointers of SgRangeExp -------------------
121870 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
121871 :
121872 0 : if ( p_start != NULL )
121873 : {
121874 0 : if ( p_start->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121875 : {
121876 0 : if ( p_start->isInMemoryPool() == false )
121877 : {
121878 0 : std::cout << "SgRangeExp :: ";
121879 0 : std::cout << " p_start is not in memory pool of ";
121880 0 : std::cout << p_start->class_name() << std::endl;
121881 : }
121882 : }
121883 : else
121884 : {
121885 0 : std::cout << "SgRangeExp :: " << std::flush;
121886 0 : std::cout << "SgExpression* p_start = " << p_start << " --> " << std::flush;
121887 0 : std::cout << " not valid " << std::endl;
121888 : }
121889 : }
121890 :
121891 0 : if ( p_end != NULL )
121892 : {
121893 0 : if ( p_end->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121894 : {
121895 0 : if ( p_end->isInMemoryPool() == false )
121896 : {
121897 0 : std::cout << "SgRangeExp :: ";
121898 0 : std::cout << " p_end is not in memory pool of ";
121899 0 : std::cout << p_end->class_name() << std::endl;
121900 : }
121901 : }
121902 : else
121903 : {
121904 0 : std::cout << "SgRangeExp :: " << std::flush;
121905 0 : std::cout << "SgExpression* p_end = " << p_end << " --> " << std::flush;
121906 0 : std::cout << " not valid " << std::endl;
121907 : }
121908 : }
121909 :
121910 0 : if ( p_stride != NULL )
121911 : {
121912 0 : if ( p_stride->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121913 : {
121914 0 : if ( p_stride->isInMemoryPool() == false )
121915 : {
121916 0 : std::cout << "SgRangeExp :: ";
121917 0 : std::cout << " p_stride is not in memory pool of ";
121918 0 : std::cout << p_stride->class_name() << std::endl;
121919 : }
121920 : }
121921 : else
121922 : {
121923 0 : std::cout << "SgRangeExp :: " << std::flush;
121924 0 : std::cout << "SgExpression* p_stride = " << p_stride << " --> " << std::flush;
121925 0 : std::cout << " not valid " << std::endl;
121926 : }
121927 : }
121928 :
121929 0 : if ( p_operatorPosition != NULL )
121930 : {
121931 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121932 : {
121933 0 : if ( p_operatorPosition->isInMemoryPool() == false )
121934 : {
121935 0 : std::cout << "SgRangeExp :: ";
121936 0 : std::cout << " p_operatorPosition is not in memory pool of ";
121937 0 : std::cout << p_operatorPosition->class_name() << std::endl;
121938 : }
121939 : }
121940 : else
121941 : {
121942 0 : std::cout << "SgRangeExp :: " << std::flush;
121943 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
121944 0 : std::cout << " not valid " << std::endl;
121945 : }
121946 : }
121947 :
121948 0 : if ( p_startOfConstruct != NULL )
121949 : {
121950 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121951 : {
121952 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
121953 : {
121954 0 : std::cout << "SgRangeExp :: ";
121955 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
121956 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
121957 : }
121958 : }
121959 : else
121960 : {
121961 0 : std::cout << "SgRangeExp :: " << std::flush;
121962 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
121963 0 : std::cout << " not valid " << std::endl;
121964 : }
121965 : }
121966 :
121967 0 : if ( p_endOfConstruct != NULL )
121968 : {
121969 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121970 : {
121971 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
121972 : {
121973 0 : std::cout << "SgRangeExp :: ";
121974 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
121975 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
121976 : }
121977 : }
121978 : else
121979 : {
121980 0 : std::cout << "SgRangeExp :: " << std::flush;
121981 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
121982 0 : std::cout << " not valid " << std::endl;
121983 : }
121984 : }
121985 :
121986 0 : if ( p_parent != NULL )
121987 : {
121988 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
121989 : {
121990 0 : if ( p_parent->isInMemoryPool() == false )
121991 : {
121992 0 : std::cout << "SgRangeExp :: ";
121993 0 : std::cout << " p_parent is not in memory pool of ";
121994 0 : std::cout << p_parent->class_name() << std::endl;
121995 : }
121996 : }
121997 : else
121998 : {
121999 0 : std::cout << "SgRangeExp :: " << std::flush;
122000 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
122001 0 : std::cout << " not valid " << std::endl;
122002 : }
122003 : }
122004 :
122005 :
122006 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122007 :
122008 0 : }
122009 :
122010 :
122011 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
122012 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
122013 : bool
122014 0 : SgRangeExp::isInMemoryPool ()
122015 : {
122016 0 : typedef unsigned char* TestType;
122017 :
122018 0 : bool found = false;
122019 :
122020 0 : ROSE_ASSERT(this != NULL);
122021 :
122022 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
122023 :
122024 0 : TestType tested = (TestType) ( this ) ;
122025 :
122026 0 : std::vector < unsigned char* > :: const_iterator block = SgRangeExp::pools.begin();
122027 :
122028 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
122029 : // while (found == false && block < Memory_Block_List.end())
122030 0 : while ( (found == false) && (block != SgRangeExp::pools.end()) )
122031 : {
122032 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgRangeExp::pool_size * sizeof(SgRangeExp) ) ) ;
122033 0 : ++block;
122034 : }
122035 :
122036 : // Special handling for static data
122037 :
122038 :
122039 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
122040 0 : ROSE_ASSERT(found == true);
122041 :
122042 0 : return found;
122043 : }
122044 : /* #line 122045 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
122045 :
122046 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
122047 :
122048 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122049 :
122050 : /* #line 122051 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
122051 :
122052 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122053 :
122054 : void
122055 0 : SgMagicColonExp::checkDataMemberPointersIfInMemoryPool()
122056 : {
122057 : // ------------ checking pointers of SgMagicColonExp -------------------
122058 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
122059 :
122060 0 : if ( p_operatorPosition != NULL )
122061 : {
122062 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122063 : {
122064 0 : if ( p_operatorPosition->isInMemoryPool() == false )
122065 : {
122066 0 : std::cout << "SgMagicColonExp :: ";
122067 0 : std::cout << " p_operatorPosition is not in memory pool of ";
122068 0 : std::cout << p_operatorPosition->class_name() << std::endl;
122069 : }
122070 : }
122071 : else
122072 : {
122073 0 : std::cout << "SgMagicColonExp :: " << std::flush;
122074 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
122075 0 : std::cout << " not valid " << std::endl;
122076 : }
122077 : }
122078 :
122079 0 : if ( p_startOfConstruct != NULL )
122080 : {
122081 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122082 : {
122083 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
122084 : {
122085 0 : std::cout << "SgMagicColonExp :: ";
122086 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
122087 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
122088 : }
122089 : }
122090 : else
122091 : {
122092 0 : std::cout << "SgMagicColonExp :: " << std::flush;
122093 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
122094 0 : std::cout << " not valid " << std::endl;
122095 : }
122096 : }
122097 :
122098 0 : if ( p_endOfConstruct != NULL )
122099 : {
122100 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122101 : {
122102 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
122103 : {
122104 0 : std::cout << "SgMagicColonExp :: ";
122105 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
122106 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
122107 : }
122108 : }
122109 : else
122110 : {
122111 0 : std::cout << "SgMagicColonExp :: " << std::flush;
122112 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
122113 0 : std::cout << " not valid " << std::endl;
122114 : }
122115 : }
122116 :
122117 0 : if ( p_parent != NULL )
122118 : {
122119 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122120 : {
122121 0 : if ( p_parent->isInMemoryPool() == false )
122122 : {
122123 0 : std::cout << "SgMagicColonExp :: ";
122124 0 : std::cout << " p_parent is not in memory pool of ";
122125 0 : std::cout << p_parent->class_name() << std::endl;
122126 : }
122127 : }
122128 : else
122129 : {
122130 0 : std::cout << "SgMagicColonExp :: " << std::flush;
122131 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
122132 0 : std::cout << " not valid " << std::endl;
122133 : }
122134 : }
122135 :
122136 :
122137 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122138 :
122139 0 : }
122140 :
122141 :
122142 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
122143 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
122144 : bool
122145 0 : SgMagicColonExp::isInMemoryPool ()
122146 : {
122147 0 : typedef unsigned char* TestType;
122148 :
122149 0 : bool found = false;
122150 :
122151 0 : ROSE_ASSERT(this != NULL);
122152 :
122153 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
122154 :
122155 0 : TestType tested = (TestType) ( this ) ;
122156 :
122157 0 : std::vector < unsigned char* > :: const_iterator block = SgMagicColonExp::pools.begin();
122158 :
122159 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
122160 : // while (found == false && block < Memory_Block_List.end())
122161 0 : while ( (found == false) && (block != SgMagicColonExp::pools.end()) )
122162 : {
122163 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgMagicColonExp::pool_size * sizeof(SgMagicColonExp) ) ) ;
122164 0 : ++block;
122165 : }
122166 :
122167 : // Special handling for static data
122168 :
122169 :
122170 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
122171 0 : ROSE_ASSERT(found == true);
122172 :
122173 0 : return found;
122174 : }
122175 : /* #line 122176 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
122176 :
122177 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
122178 :
122179 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122180 :
122181 : /* #line 122182 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
122182 :
122183 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122184 :
122185 : void
122186 0 : SgTypeTraitBuiltinOperator::checkDataMemberPointersIfInMemoryPool()
122187 : {
122188 : // ------------ checking pointers of SgTypeTraitBuiltinOperator -------------------
122189 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
122190 :
122191 0 : SgNodePtrList::iterator i_args = p_args.begin() ;
122192 0 : for ( ; i_args != p_args.end(); ++i_args )
122193 : {
122194 0 : if ( (*i_args) != NULL )
122195 : {
122196 0 : if ( (*i_args)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122197 : {
122198 0 : if ( (*i_args)->isInMemoryPool() == false )
122199 : {
122200 0 : std::cout << "SgTypeTraitBuiltinOperator :: ";
122201 0 : std::cout << " p_args ( list of poitners to IR nodes ), entry is not in memory pool of ";
122202 0 : std::cout << (*i_args)->class_name() << std::endl;
122203 : }
122204 : }
122205 : else
122206 : {
122207 0 : std::cout << "SgTypeTraitBuiltinOperator :: " << std::flush;
122208 0 : std::cout << "SgNodePtrList p_args --> " << std::flush;
122209 0 : std::cout << " entry not valid " << std::endl;
122210 : }
122211 : }
122212 : else
122213 : {
122214 0 : std::cout << "SgNodePtrList p_args --> NULL " << std::endl;
122215 : }
122216 : }
122217 :
122218 0 : if ( p_operatorPosition != NULL )
122219 : {
122220 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122221 : {
122222 0 : if ( p_operatorPosition->isInMemoryPool() == false )
122223 : {
122224 0 : std::cout << "SgTypeTraitBuiltinOperator :: ";
122225 0 : std::cout << " p_operatorPosition is not in memory pool of ";
122226 0 : std::cout << p_operatorPosition->class_name() << std::endl;
122227 : }
122228 : }
122229 : else
122230 : {
122231 0 : std::cout << "SgTypeTraitBuiltinOperator :: " << std::flush;
122232 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
122233 0 : std::cout << " not valid " << std::endl;
122234 : }
122235 : }
122236 :
122237 0 : if ( p_startOfConstruct != NULL )
122238 : {
122239 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122240 : {
122241 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
122242 : {
122243 0 : std::cout << "SgTypeTraitBuiltinOperator :: ";
122244 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
122245 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
122246 : }
122247 : }
122248 : else
122249 : {
122250 0 : std::cout << "SgTypeTraitBuiltinOperator :: " << std::flush;
122251 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
122252 0 : std::cout << " not valid " << std::endl;
122253 : }
122254 : }
122255 :
122256 0 : if ( p_endOfConstruct != NULL )
122257 : {
122258 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122259 : {
122260 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
122261 : {
122262 0 : std::cout << "SgTypeTraitBuiltinOperator :: ";
122263 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
122264 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
122265 : }
122266 : }
122267 : else
122268 : {
122269 0 : std::cout << "SgTypeTraitBuiltinOperator :: " << std::flush;
122270 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
122271 0 : std::cout << " not valid " << std::endl;
122272 : }
122273 : }
122274 :
122275 0 : if ( p_parent != NULL )
122276 : {
122277 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122278 : {
122279 0 : if ( p_parent->isInMemoryPool() == false )
122280 : {
122281 0 : std::cout << "SgTypeTraitBuiltinOperator :: ";
122282 0 : std::cout << " p_parent is not in memory pool of ";
122283 0 : std::cout << p_parent->class_name() << std::endl;
122284 : }
122285 : }
122286 : else
122287 : {
122288 0 : std::cout << "SgTypeTraitBuiltinOperator :: " << std::flush;
122289 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
122290 0 : std::cout << " not valid " << std::endl;
122291 : }
122292 : }
122293 :
122294 :
122295 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122296 :
122297 0 : }
122298 :
122299 :
122300 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
122301 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
122302 : bool
122303 0 : SgTypeTraitBuiltinOperator::isInMemoryPool ()
122304 : {
122305 0 : typedef unsigned char* TestType;
122306 :
122307 0 : bool found = false;
122308 :
122309 0 : ROSE_ASSERT(this != NULL);
122310 :
122311 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
122312 :
122313 0 : TestType tested = (TestType) ( this ) ;
122314 :
122315 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeTraitBuiltinOperator::pools.begin();
122316 :
122317 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
122318 : // while (found == false && block < Memory_Block_List.end())
122319 0 : while ( (found == false) && (block != SgTypeTraitBuiltinOperator::pools.end()) )
122320 : {
122321 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeTraitBuiltinOperator::pool_size * sizeof(SgTypeTraitBuiltinOperator) ) ) ;
122322 0 : ++block;
122323 : }
122324 :
122325 : // Special handling for static data
122326 :
122327 :
122328 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
122329 0 : ROSE_ASSERT(found == true);
122330 :
122331 0 : return found;
122332 : }
122333 : /* #line 122334 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
122334 :
122335 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
122336 :
122337 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122338 :
122339 : /* #line 122340 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
122340 :
122341 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122342 :
122343 : void
122344 0 : SgCompoundLiteralExp::checkDataMemberPointersIfInMemoryPool()
122345 : {
122346 : // ------------ checking pointers of SgCompoundLiteralExp -------------------
122347 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
122348 :
122349 0 : if ( p_symbol != NULL )
122350 : {
122351 0 : if ( p_symbol->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122352 : {
122353 0 : if ( p_symbol->isInMemoryPool() == false )
122354 : {
122355 0 : std::cout << "SgCompoundLiteralExp :: ";
122356 0 : std::cout << " p_symbol is not in memory pool of ";
122357 0 : std::cout << p_symbol->class_name() << std::endl;
122358 : }
122359 : }
122360 : else
122361 : {
122362 0 : std::cout << "SgCompoundLiteralExp :: " << std::flush;
122363 0 : std::cout << "SgVariableSymbol* p_symbol = " << p_symbol << " --> " << std::flush;
122364 0 : std::cout << " not valid " << std::endl;
122365 : }
122366 : }
122367 :
122368 0 : if ( p_operatorPosition != NULL )
122369 : {
122370 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122371 : {
122372 0 : if ( p_operatorPosition->isInMemoryPool() == false )
122373 : {
122374 0 : std::cout << "SgCompoundLiteralExp :: ";
122375 0 : std::cout << " p_operatorPosition is not in memory pool of ";
122376 0 : std::cout << p_operatorPosition->class_name() << std::endl;
122377 : }
122378 : }
122379 : else
122380 : {
122381 0 : std::cout << "SgCompoundLiteralExp :: " << std::flush;
122382 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
122383 0 : std::cout << " not valid " << std::endl;
122384 : }
122385 : }
122386 :
122387 0 : if ( p_startOfConstruct != NULL )
122388 : {
122389 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122390 : {
122391 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
122392 : {
122393 0 : std::cout << "SgCompoundLiteralExp :: ";
122394 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
122395 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
122396 : }
122397 : }
122398 : else
122399 : {
122400 0 : std::cout << "SgCompoundLiteralExp :: " << std::flush;
122401 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
122402 0 : std::cout << " not valid " << std::endl;
122403 : }
122404 : }
122405 :
122406 0 : if ( p_endOfConstruct != NULL )
122407 : {
122408 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122409 : {
122410 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
122411 : {
122412 0 : std::cout << "SgCompoundLiteralExp :: ";
122413 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
122414 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
122415 : }
122416 : }
122417 : else
122418 : {
122419 0 : std::cout << "SgCompoundLiteralExp :: " << std::flush;
122420 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
122421 0 : std::cout << " not valid " << std::endl;
122422 : }
122423 : }
122424 :
122425 0 : if ( p_parent != NULL )
122426 : {
122427 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122428 : {
122429 0 : if ( p_parent->isInMemoryPool() == false )
122430 : {
122431 0 : std::cout << "SgCompoundLiteralExp :: ";
122432 0 : std::cout << " p_parent is not in memory pool of ";
122433 0 : std::cout << p_parent->class_name() << std::endl;
122434 : }
122435 : }
122436 : else
122437 : {
122438 0 : std::cout << "SgCompoundLiteralExp :: " << std::flush;
122439 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
122440 0 : std::cout << " not valid " << std::endl;
122441 : }
122442 : }
122443 :
122444 :
122445 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122446 :
122447 0 : }
122448 :
122449 :
122450 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
122451 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
122452 : bool
122453 0 : SgCompoundLiteralExp::isInMemoryPool ()
122454 : {
122455 0 : typedef unsigned char* TestType;
122456 :
122457 0 : bool found = false;
122458 :
122459 0 : ROSE_ASSERT(this != NULL);
122460 :
122461 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
122462 :
122463 0 : TestType tested = (TestType) ( this ) ;
122464 :
122465 0 : std::vector < unsigned char* > :: const_iterator block = SgCompoundLiteralExp::pools.begin();
122466 :
122467 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
122468 : // while (found == false && block < Memory_Block_List.end())
122469 0 : while ( (found == false) && (block != SgCompoundLiteralExp::pools.end()) )
122470 : {
122471 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCompoundLiteralExp::pool_size * sizeof(SgCompoundLiteralExp) ) ) ;
122472 0 : ++block;
122473 : }
122474 :
122475 : // Special handling for static data
122476 :
122477 :
122478 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
122479 0 : ROSE_ASSERT(found == true);
122480 :
122481 0 : return found;
122482 : }
122483 : /* #line 122484 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
122484 :
122485 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
122486 :
122487 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122488 :
122489 : /* #line 122490 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
122490 :
122491 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122492 :
122493 : void
122494 0 : SgTypeExpression::checkDataMemberPointersIfInMemoryPool()
122495 : {
122496 : // ------------ checking pointers of SgTypeExpression -------------------
122497 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
122498 :
122499 0 : if ( p_type != NULL )
122500 : {
122501 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122502 : {
122503 0 : if ( p_type->isInMemoryPool() == false )
122504 : {
122505 0 : std::cout << "SgTypeExpression :: ";
122506 0 : std::cout << " p_type is not in memory pool of ";
122507 0 : std::cout << p_type->class_name() << std::endl;
122508 : }
122509 : }
122510 : else
122511 : {
122512 0 : std::cout << "SgTypeExpression :: " << std::flush;
122513 0 : std::cout << "SgType* p_type = " << p_type << " --> " << std::flush;
122514 0 : std::cout << " not valid " << std::endl;
122515 : }
122516 : }
122517 :
122518 0 : if ( p_operatorPosition != NULL )
122519 : {
122520 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122521 : {
122522 0 : if ( p_operatorPosition->isInMemoryPool() == false )
122523 : {
122524 0 : std::cout << "SgTypeExpression :: ";
122525 0 : std::cout << " p_operatorPosition is not in memory pool of ";
122526 0 : std::cout << p_operatorPosition->class_name() << std::endl;
122527 : }
122528 : }
122529 : else
122530 : {
122531 0 : std::cout << "SgTypeExpression :: " << std::flush;
122532 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
122533 0 : std::cout << " not valid " << std::endl;
122534 : }
122535 : }
122536 :
122537 0 : if ( p_startOfConstruct != NULL )
122538 : {
122539 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122540 : {
122541 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
122542 : {
122543 0 : std::cout << "SgTypeExpression :: ";
122544 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
122545 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
122546 : }
122547 : }
122548 : else
122549 : {
122550 0 : std::cout << "SgTypeExpression :: " << std::flush;
122551 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
122552 0 : std::cout << " not valid " << std::endl;
122553 : }
122554 : }
122555 :
122556 0 : if ( p_endOfConstruct != NULL )
122557 : {
122558 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122559 : {
122560 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
122561 : {
122562 0 : std::cout << "SgTypeExpression :: ";
122563 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
122564 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
122565 : }
122566 : }
122567 : else
122568 : {
122569 0 : std::cout << "SgTypeExpression :: " << std::flush;
122570 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
122571 0 : std::cout << " not valid " << std::endl;
122572 : }
122573 : }
122574 :
122575 0 : if ( p_parent != NULL )
122576 : {
122577 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122578 : {
122579 0 : if ( p_parent->isInMemoryPool() == false )
122580 : {
122581 0 : std::cout << "SgTypeExpression :: ";
122582 0 : std::cout << " p_parent is not in memory pool of ";
122583 0 : std::cout << p_parent->class_name() << std::endl;
122584 : }
122585 : }
122586 : else
122587 : {
122588 0 : std::cout << "SgTypeExpression :: " << std::flush;
122589 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
122590 0 : std::cout << " not valid " << std::endl;
122591 : }
122592 : }
122593 :
122594 :
122595 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122596 :
122597 0 : }
122598 :
122599 :
122600 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
122601 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
122602 : bool
122603 0 : SgTypeExpression::isInMemoryPool ()
122604 : {
122605 0 : typedef unsigned char* TestType;
122606 :
122607 0 : bool found = false;
122608 :
122609 0 : ROSE_ASSERT(this != NULL);
122610 :
122611 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
122612 :
122613 0 : TestType tested = (TestType) ( this ) ;
122614 :
122615 0 : std::vector < unsigned char* > :: const_iterator block = SgTypeExpression::pools.begin();
122616 :
122617 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
122618 : // while (found == false && block < Memory_Block_List.end())
122619 0 : while ( (found == false) && (block != SgTypeExpression::pools.end()) )
122620 : {
122621 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypeExpression::pool_size * sizeof(SgTypeExpression) ) ) ;
122622 0 : ++block;
122623 : }
122624 :
122625 : // Special handling for static data
122626 :
122627 :
122628 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
122629 0 : ROSE_ASSERT(found == true);
122630 :
122631 0 : return found;
122632 : }
122633 : /* #line 122634 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
122634 :
122635 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
122636 :
122637 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122638 :
122639 : /* #line 122640 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
122640 :
122641 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122642 :
122643 : void
122644 0 : SgClassExp::checkDataMemberPointersIfInMemoryPool()
122645 : {
122646 : // ------------ checking pointers of SgClassExp -------------------
122647 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
122648 :
122649 0 : if ( p_class_symbol != NULL )
122650 : {
122651 0 : if ( p_class_symbol->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122652 : {
122653 0 : if ( p_class_symbol->isInMemoryPool() == false )
122654 : {
122655 0 : std::cout << "SgClassExp :: ";
122656 0 : std::cout << " p_class_symbol is not in memory pool of ";
122657 0 : std::cout << p_class_symbol->class_name() << std::endl;
122658 : }
122659 : }
122660 : else
122661 : {
122662 0 : std::cout << "SgClassExp :: " << std::flush;
122663 0 : std::cout << "SgClassSymbol* p_class_symbol = " << p_class_symbol << " --> " << std::flush;
122664 0 : std::cout << " not valid " << std::endl;
122665 : }
122666 : }
122667 :
122668 0 : if ( p_operatorPosition != NULL )
122669 : {
122670 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122671 : {
122672 0 : if ( p_operatorPosition->isInMemoryPool() == false )
122673 : {
122674 0 : std::cout << "SgClassExp :: ";
122675 0 : std::cout << " p_operatorPosition is not in memory pool of ";
122676 0 : std::cout << p_operatorPosition->class_name() << std::endl;
122677 : }
122678 : }
122679 : else
122680 : {
122681 0 : std::cout << "SgClassExp :: " << std::flush;
122682 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
122683 0 : std::cout << " not valid " << std::endl;
122684 : }
122685 : }
122686 :
122687 0 : if ( p_startOfConstruct != NULL )
122688 : {
122689 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122690 : {
122691 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
122692 : {
122693 0 : std::cout << "SgClassExp :: ";
122694 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
122695 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
122696 : }
122697 : }
122698 : else
122699 : {
122700 0 : std::cout << "SgClassExp :: " << std::flush;
122701 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
122702 0 : std::cout << " not valid " << std::endl;
122703 : }
122704 : }
122705 :
122706 0 : if ( p_endOfConstruct != NULL )
122707 : {
122708 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122709 : {
122710 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
122711 : {
122712 0 : std::cout << "SgClassExp :: ";
122713 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
122714 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
122715 : }
122716 : }
122717 : else
122718 : {
122719 0 : std::cout << "SgClassExp :: " << std::flush;
122720 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
122721 0 : std::cout << " not valid " << std::endl;
122722 : }
122723 : }
122724 :
122725 0 : if ( p_parent != NULL )
122726 : {
122727 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122728 : {
122729 0 : if ( p_parent->isInMemoryPool() == false )
122730 : {
122731 0 : std::cout << "SgClassExp :: ";
122732 0 : std::cout << " p_parent is not in memory pool of ";
122733 0 : std::cout << p_parent->class_name() << std::endl;
122734 : }
122735 : }
122736 : else
122737 : {
122738 0 : std::cout << "SgClassExp :: " << std::flush;
122739 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
122740 0 : std::cout << " not valid " << std::endl;
122741 : }
122742 : }
122743 :
122744 :
122745 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122746 :
122747 0 : }
122748 :
122749 :
122750 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
122751 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
122752 : bool
122753 0 : SgClassExp::isInMemoryPool ()
122754 : {
122755 0 : typedef unsigned char* TestType;
122756 :
122757 0 : bool found = false;
122758 :
122759 0 : ROSE_ASSERT(this != NULL);
122760 :
122761 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
122762 :
122763 0 : TestType tested = (TestType) ( this ) ;
122764 :
122765 0 : std::vector < unsigned char* > :: const_iterator block = SgClassExp::pools.begin();
122766 :
122767 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
122768 : // while (found == false && block < Memory_Block_List.end())
122769 0 : while ( (found == false) && (block != SgClassExp::pools.end()) )
122770 : {
122771 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgClassExp::pool_size * sizeof(SgClassExp) ) ) ;
122772 0 : ++block;
122773 : }
122774 :
122775 : // Special handling for static data
122776 :
122777 :
122778 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
122779 0 : ROSE_ASSERT(found == true);
122780 :
122781 0 : return found;
122782 : }
122783 : /* #line 122784 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
122784 :
122785 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
122786 :
122787 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122788 :
122789 : /* #line 122790 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
122790 :
122791 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122792 :
122793 : void
122794 0 : SgFunctionParameterRefExp::checkDataMemberPointersIfInMemoryPool()
122795 : {
122796 : // ------------ checking pointers of SgFunctionParameterRefExp -------------------
122797 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
122798 :
122799 0 : if ( p_parameter_expression != NULL )
122800 : {
122801 0 : if ( p_parameter_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122802 : {
122803 0 : if ( p_parameter_expression->isInMemoryPool() == false )
122804 : {
122805 0 : std::cout << "SgFunctionParameterRefExp :: ";
122806 0 : std::cout << " p_parameter_expression is not in memory pool of ";
122807 0 : std::cout << p_parameter_expression->class_name() << std::endl;
122808 : }
122809 : }
122810 : else
122811 : {
122812 0 : std::cout << "SgFunctionParameterRefExp :: " << std::flush;
122813 0 : std::cout << "SgExpression* p_parameter_expression = " << p_parameter_expression << " --> " << std::flush;
122814 0 : std::cout << " not valid " << std::endl;
122815 : }
122816 : }
122817 :
122818 0 : if ( p_parameter_type != NULL )
122819 : {
122820 0 : if ( p_parameter_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122821 : {
122822 0 : if ( p_parameter_type->isInMemoryPool() == false )
122823 : {
122824 0 : std::cout << "SgFunctionParameterRefExp :: ";
122825 0 : std::cout << " p_parameter_type is not in memory pool of ";
122826 0 : std::cout << p_parameter_type->class_name() << std::endl;
122827 : }
122828 : }
122829 : else
122830 : {
122831 0 : std::cout << "SgFunctionParameterRefExp :: " << std::flush;
122832 0 : std::cout << "SgType* p_parameter_type = " << p_parameter_type << " --> " << std::flush;
122833 0 : std::cout << " not valid " << std::endl;
122834 : }
122835 : }
122836 :
122837 0 : if ( p_operatorPosition != NULL )
122838 : {
122839 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122840 : {
122841 0 : if ( p_operatorPosition->isInMemoryPool() == false )
122842 : {
122843 0 : std::cout << "SgFunctionParameterRefExp :: ";
122844 0 : std::cout << " p_operatorPosition is not in memory pool of ";
122845 0 : std::cout << p_operatorPosition->class_name() << std::endl;
122846 : }
122847 : }
122848 : else
122849 : {
122850 0 : std::cout << "SgFunctionParameterRefExp :: " << std::flush;
122851 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
122852 0 : std::cout << " not valid " << std::endl;
122853 : }
122854 : }
122855 :
122856 0 : if ( p_startOfConstruct != NULL )
122857 : {
122858 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122859 : {
122860 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
122861 : {
122862 0 : std::cout << "SgFunctionParameterRefExp :: ";
122863 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
122864 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
122865 : }
122866 : }
122867 : else
122868 : {
122869 0 : std::cout << "SgFunctionParameterRefExp :: " << std::flush;
122870 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
122871 0 : std::cout << " not valid " << std::endl;
122872 : }
122873 : }
122874 :
122875 0 : if ( p_endOfConstruct != NULL )
122876 : {
122877 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122878 : {
122879 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
122880 : {
122881 0 : std::cout << "SgFunctionParameterRefExp :: ";
122882 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
122883 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
122884 : }
122885 : }
122886 : else
122887 : {
122888 0 : std::cout << "SgFunctionParameterRefExp :: " << std::flush;
122889 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
122890 0 : std::cout << " not valid " << std::endl;
122891 : }
122892 : }
122893 :
122894 0 : if ( p_parent != NULL )
122895 : {
122896 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122897 : {
122898 0 : if ( p_parent->isInMemoryPool() == false )
122899 : {
122900 0 : std::cout << "SgFunctionParameterRefExp :: ";
122901 0 : std::cout << " p_parent is not in memory pool of ";
122902 0 : std::cout << p_parent->class_name() << std::endl;
122903 : }
122904 : }
122905 : else
122906 : {
122907 0 : std::cout << "SgFunctionParameterRefExp :: " << std::flush;
122908 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
122909 0 : std::cout << " not valid " << std::endl;
122910 : }
122911 : }
122912 :
122913 :
122914 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122915 :
122916 0 : }
122917 :
122918 :
122919 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
122920 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
122921 : bool
122922 0 : SgFunctionParameterRefExp::isInMemoryPool ()
122923 : {
122924 0 : typedef unsigned char* TestType;
122925 :
122926 0 : bool found = false;
122927 :
122928 0 : ROSE_ASSERT(this != NULL);
122929 :
122930 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
122931 :
122932 0 : TestType tested = (TestType) ( this ) ;
122933 :
122934 0 : std::vector < unsigned char* > :: const_iterator block = SgFunctionParameterRefExp::pools.begin();
122935 :
122936 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
122937 : // while (found == false && block < Memory_Block_List.end())
122938 0 : while ( (found == false) && (block != SgFunctionParameterRefExp::pools.end()) )
122939 : {
122940 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFunctionParameterRefExp::pool_size * sizeof(SgFunctionParameterRefExp) ) ) ;
122941 0 : ++block;
122942 : }
122943 :
122944 : // Special handling for static data
122945 :
122946 :
122947 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
122948 0 : ROSE_ASSERT(found == true);
122949 :
122950 0 : return found;
122951 : }
122952 : /* #line 122953 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
122953 :
122954 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
122955 :
122956 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122957 :
122958 : /* #line 122959 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
122959 :
122960 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
122961 :
122962 : void
122963 0 : SgLambdaExp::checkDataMemberPointersIfInMemoryPool()
122964 : {
122965 : // ------------ checking pointers of SgLambdaExp -------------------
122966 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
122967 :
122968 0 : if ( p_lambda_capture_list != NULL )
122969 : {
122970 0 : if ( p_lambda_capture_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122971 : {
122972 0 : if ( p_lambda_capture_list->isInMemoryPool() == false )
122973 : {
122974 0 : std::cout << "SgLambdaExp :: ";
122975 0 : std::cout << " p_lambda_capture_list is not in memory pool of ";
122976 0 : std::cout << p_lambda_capture_list->class_name() << std::endl;
122977 : }
122978 : }
122979 : else
122980 : {
122981 0 : std::cout << "SgLambdaExp :: " << std::flush;
122982 0 : std::cout << "SgLambdaCaptureList* p_lambda_capture_list = " << p_lambda_capture_list << " --> " << std::flush;
122983 0 : std::cout << " not valid " << std::endl;
122984 : }
122985 : }
122986 :
122987 0 : if ( p_lambda_closure_class != NULL )
122988 : {
122989 0 : if ( p_lambda_closure_class->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
122990 : {
122991 0 : if ( p_lambda_closure_class->isInMemoryPool() == false )
122992 : {
122993 0 : std::cout << "SgLambdaExp :: ";
122994 0 : std::cout << " p_lambda_closure_class is not in memory pool of ";
122995 0 : std::cout << p_lambda_closure_class->class_name() << std::endl;
122996 : }
122997 : }
122998 : else
122999 : {
123000 0 : std::cout << "SgLambdaExp :: " << std::flush;
123001 0 : std::cout << "SgClassDeclaration* p_lambda_closure_class = " << p_lambda_closure_class << " --> " << std::flush;
123002 0 : std::cout << " not valid " << std::endl;
123003 : }
123004 : }
123005 :
123006 0 : if ( p_lambda_function != NULL )
123007 : {
123008 0 : if ( p_lambda_function->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123009 : {
123010 0 : if ( p_lambda_function->isInMemoryPool() == false )
123011 : {
123012 0 : std::cout << "SgLambdaExp :: ";
123013 0 : std::cout << " p_lambda_function is not in memory pool of ";
123014 0 : std::cout << p_lambda_function->class_name() << std::endl;
123015 : }
123016 : }
123017 : else
123018 : {
123019 0 : std::cout << "SgLambdaExp :: " << std::flush;
123020 0 : std::cout << "SgFunctionDeclaration* p_lambda_function = " << p_lambda_function << " --> " << std::flush;
123021 0 : std::cout << " not valid " << std::endl;
123022 : }
123023 : }
123024 :
123025 0 : if ( p_operatorPosition != NULL )
123026 : {
123027 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123028 : {
123029 0 : if ( p_operatorPosition->isInMemoryPool() == false )
123030 : {
123031 0 : std::cout << "SgLambdaExp :: ";
123032 0 : std::cout << " p_operatorPosition is not in memory pool of ";
123033 0 : std::cout << p_operatorPosition->class_name() << std::endl;
123034 : }
123035 : }
123036 : else
123037 : {
123038 0 : std::cout << "SgLambdaExp :: " << std::flush;
123039 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
123040 0 : std::cout << " not valid " << std::endl;
123041 : }
123042 : }
123043 :
123044 0 : if ( p_startOfConstruct != NULL )
123045 : {
123046 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123047 : {
123048 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
123049 : {
123050 0 : std::cout << "SgLambdaExp :: ";
123051 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
123052 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
123053 : }
123054 : }
123055 : else
123056 : {
123057 0 : std::cout << "SgLambdaExp :: " << std::flush;
123058 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
123059 0 : std::cout << " not valid " << std::endl;
123060 : }
123061 : }
123062 :
123063 0 : if ( p_endOfConstruct != NULL )
123064 : {
123065 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123066 : {
123067 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
123068 : {
123069 0 : std::cout << "SgLambdaExp :: ";
123070 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
123071 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
123072 : }
123073 : }
123074 : else
123075 : {
123076 0 : std::cout << "SgLambdaExp :: " << std::flush;
123077 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
123078 0 : std::cout << " not valid " << std::endl;
123079 : }
123080 : }
123081 :
123082 0 : if ( p_parent != NULL )
123083 : {
123084 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123085 : {
123086 0 : if ( p_parent->isInMemoryPool() == false )
123087 : {
123088 0 : std::cout << "SgLambdaExp :: ";
123089 0 : std::cout << " p_parent is not in memory pool of ";
123090 0 : std::cout << p_parent->class_name() << std::endl;
123091 : }
123092 : }
123093 : else
123094 : {
123095 0 : std::cout << "SgLambdaExp :: " << std::flush;
123096 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
123097 0 : std::cout << " not valid " << std::endl;
123098 : }
123099 : }
123100 :
123101 :
123102 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123103 :
123104 0 : }
123105 :
123106 :
123107 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
123108 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
123109 : bool
123110 0 : SgLambdaExp::isInMemoryPool ()
123111 : {
123112 0 : typedef unsigned char* TestType;
123113 :
123114 0 : bool found = false;
123115 :
123116 0 : ROSE_ASSERT(this != NULL);
123117 :
123118 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
123119 :
123120 0 : TestType tested = (TestType) ( this ) ;
123121 :
123122 0 : std::vector < unsigned char* > :: const_iterator block = SgLambdaExp::pools.begin();
123123 :
123124 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
123125 : // while (found == false && block < Memory_Block_List.end())
123126 0 : while ( (found == false) && (block != SgLambdaExp::pools.end()) )
123127 : {
123128 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLambdaExp::pool_size * sizeof(SgLambdaExp) ) ) ;
123129 0 : ++block;
123130 : }
123131 :
123132 : // Special handling for static data
123133 :
123134 :
123135 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
123136 0 : ROSE_ASSERT(found == true);
123137 :
123138 0 : return found;
123139 : }
123140 : /* #line 123141 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
123141 :
123142 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
123143 :
123144 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123145 :
123146 : /* #line 123147 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
123147 :
123148 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123149 :
123150 : void
123151 0 : SgNoexceptOp::checkDataMemberPointersIfInMemoryPool()
123152 : {
123153 : // ------------ checking pointers of SgNoexceptOp -------------------
123154 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
123155 :
123156 0 : if ( p_operand_expr != NULL )
123157 : {
123158 0 : if ( p_operand_expr->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123159 : {
123160 0 : if ( p_operand_expr->isInMemoryPool() == false )
123161 : {
123162 0 : std::cout << "SgNoexceptOp :: ";
123163 0 : std::cout << " p_operand_expr is not in memory pool of ";
123164 0 : std::cout << p_operand_expr->class_name() << std::endl;
123165 : }
123166 : }
123167 : else
123168 : {
123169 0 : std::cout << "SgNoexceptOp :: " << std::flush;
123170 0 : std::cout << "SgExpression* p_operand_expr = " << p_operand_expr << " --> " << std::flush;
123171 0 : std::cout << " not valid " << std::endl;
123172 : }
123173 : }
123174 :
123175 0 : if ( p_operatorPosition != NULL )
123176 : {
123177 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123178 : {
123179 0 : if ( p_operatorPosition->isInMemoryPool() == false )
123180 : {
123181 0 : std::cout << "SgNoexceptOp :: ";
123182 0 : std::cout << " p_operatorPosition is not in memory pool of ";
123183 0 : std::cout << p_operatorPosition->class_name() << std::endl;
123184 : }
123185 : }
123186 : else
123187 : {
123188 0 : std::cout << "SgNoexceptOp :: " << std::flush;
123189 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
123190 0 : std::cout << " not valid " << std::endl;
123191 : }
123192 : }
123193 :
123194 0 : if ( p_startOfConstruct != NULL )
123195 : {
123196 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123197 : {
123198 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
123199 : {
123200 0 : std::cout << "SgNoexceptOp :: ";
123201 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
123202 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
123203 : }
123204 : }
123205 : else
123206 : {
123207 0 : std::cout << "SgNoexceptOp :: " << std::flush;
123208 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
123209 0 : std::cout << " not valid " << std::endl;
123210 : }
123211 : }
123212 :
123213 0 : if ( p_endOfConstruct != NULL )
123214 : {
123215 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123216 : {
123217 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
123218 : {
123219 0 : std::cout << "SgNoexceptOp :: ";
123220 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
123221 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
123222 : }
123223 : }
123224 : else
123225 : {
123226 0 : std::cout << "SgNoexceptOp :: " << std::flush;
123227 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
123228 0 : std::cout << " not valid " << std::endl;
123229 : }
123230 : }
123231 :
123232 0 : if ( p_parent != NULL )
123233 : {
123234 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123235 : {
123236 0 : if ( p_parent->isInMemoryPool() == false )
123237 : {
123238 0 : std::cout << "SgNoexceptOp :: ";
123239 0 : std::cout << " p_parent is not in memory pool of ";
123240 0 : std::cout << p_parent->class_name() << std::endl;
123241 : }
123242 : }
123243 : else
123244 : {
123245 0 : std::cout << "SgNoexceptOp :: " << std::flush;
123246 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
123247 0 : std::cout << " not valid " << std::endl;
123248 : }
123249 : }
123250 :
123251 :
123252 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123253 :
123254 0 : }
123255 :
123256 :
123257 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
123258 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
123259 : bool
123260 0 : SgNoexceptOp::isInMemoryPool ()
123261 : {
123262 0 : typedef unsigned char* TestType;
123263 :
123264 0 : bool found = false;
123265 :
123266 0 : ROSE_ASSERT(this != NULL);
123267 :
123268 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
123269 :
123270 0 : TestType tested = (TestType) ( this ) ;
123271 :
123272 0 : std::vector < unsigned char* > :: const_iterator block = SgNoexceptOp::pools.begin();
123273 :
123274 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
123275 : // while (found == false && block < Memory_Block_List.end())
123276 0 : while ( (found == false) && (block != SgNoexceptOp::pools.end()) )
123277 : {
123278 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNoexceptOp::pool_size * sizeof(SgNoexceptOp) ) ) ;
123279 0 : ++block;
123280 : }
123281 :
123282 : // Special handling for static data
123283 :
123284 :
123285 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
123286 0 : ROSE_ASSERT(found == true);
123287 :
123288 0 : return found;
123289 : }
123290 : /* #line 123291 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
123291 :
123292 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
123293 :
123294 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123295 :
123296 : /* #line 123297 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
123297 :
123298 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123299 :
123300 : void
123301 0 : SgNonrealRefExp::checkDataMemberPointersIfInMemoryPool()
123302 : {
123303 : // ------------ checking pointers of SgNonrealRefExp -------------------
123304 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
123305 :
123306 0 : if ( p_symbol != NULL )
123307 : {
123308 0 : if ( p_symbol->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123309 : {
123310 0 : if ( p_symbol->isInMemoryPool() == false )
123311 : {
123312 0 : std::cout << "SgNonrealRefExp :: ";
123313 0 : std::cout << " p_symbol is not in memory pool of ";
123314 0 : std::cout << p_symbol->class_name() << std::endl;
123315 : }
123316 : }
123317 : else
123318 : {
123319 0 : std::cout << "SgNonrealRefExp :: " << std::flush;
123320 0 : std::cout << "SgNonrealSymbol* p_symbol = " << p_symbol << " --> " << std::flush;
123321 0 : std::cout << " not valid " << std::endl;
123322 : }
123323 : }
123324 :
123325 0 : if ( p_operatorPosition != NULL )
123326 : {
123327 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123328 : {
123329 0 : if ( p_operatorPosition->isInMemoryPool() == false )
123330 : {
123331 0 : std::cout << "SgNonrealRefExp :: ";
123332 0 : std::cout << " p_operatorPosition is not in memory pool of ";
123333 0 : std::cout << p_operatorPosition->class_name() << std::endl;
123334 : }
123335 : }
123336 : else
123337 : {
123338 0 : std::cout << "SgNonrealRefExp :: " << std::flush;
123339 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
123340 0 : std::cout << " not valid " << std::endl;
123341 : }
123342 : }
123343 :
123344 0 : if ( p_startOfConstruct != NULL )
123345 : {
123346 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123347 : {
123348 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
123349 : {
123350 0 : std::cout << "SgNonrealRefExp :: ";
123351 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
123352 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
123353 : }
123354 : }
123355 : else
123356 : {
123357 0 : std::cout << "SgNonrealRefExp :: " << std::flush;
123358 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
123359 0 : std::cout << " not valid " << std::endl;
123360 : }
123361 : }
123362 :
123363 0 : if ( p_endOfConstruct != NULL )
123364 : {
123365 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123366 : {
123367 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
123368 : {
123369 0 : std::cout << "SgNonrealRefExp :: ";
123370 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
123371 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
123372 : }
123373 : }
123374 : else
123375 : {
123376 0 : std::cout << "SgNonrealRefExp :: " << std::flush;
123377 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
123378 0 : std::cout << " not valid " << std::endl;
123379 : }
123380 : }
123381 :
123382 0 : if ( p_parent != NULL )
123383 : {
123384 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123385 : {
123386 0 : if ( p_parent->isInMemoryPool() == false )
123387 : {
123388 0 : std::cout << "SgNonrealRefExp :: ";
123389 0 : std::cout << " p_parent is not in memory pool of ";
123390 0 : std::cout << p_parent->class_name() << std::endl;
123391 : }
123392 : }
123393 : else
123394 : {
123395 0 : std::cout << "SgNonrealRefExp :: " << std::flush;
123396 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
123397 0 : std::cout << " not valid " << std::endl;
123398 : }
123399 : }
123400 :
123401 :
123402 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123403 :
123404 0 : }
123405 :
123406 :
123407 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
123408 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
123409 : bool
123410 0 : SgNonrealRefExp::isInMemoryPool ()
123411 : {
123412 0 : typedef unsigned char* TestType;
123413 :
123414 0 : bool found = false;
123415 :
123416 0 : ROSE_ASSERT(this != NULL);
123417 :
123418 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
123419 :
123420 0 : TestType tested = (TestType) ( this ) ;
123421 :
123422 0 : std::vector < unsigned char* > :: const_iterator block = SgNonrealRefExp::pools.begin();
123423 :
123424 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
123425 : // while (found == false && block < Memory_Block_List.end())
123426 0 : while ( (found == false) && (block != SgNonrealRefExp::pools.end()) )
123427 : {
123428 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNonrealRefExp::pool_size * sizeof(SgNonrealRefExp) ) ) ;
123429 0 : ++block;
123430 : }
123431 :
123432 : // Special handling for static data
123433 :
123434 :
123435 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
123436 0 : ROSE_ASSERT(found == true);
123437 :
123438 0 : return found;
123439 : }
123440 : /* #line 123441 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
123441 :
123442 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
123443 :
123444 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123445 :
123446 : /* #line 123447 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
123447 :
123448 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123449 :
123450 : void
123451 0 : SgFoldExpression::checkDataMemberPointersIfInMemoryPool()
123452 : {
123453 : // ------------ checking pointers of SgFoldExpression -------------------
123454 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
123455 :
123456 0 : if ( p_operands != NULL )
123457 : {
123458 0 : if ( p_operands->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123459 : {
123460 0 : if ( p_operands->isInMemoryPool() == false )
123461 : {
123462 0 : std::cout << "SgFoldExpression :: ";
123463 0 : std::cout << " p_operands is not in memory pool of ";
123464 0 : std::cout << p_operands->class_name() << std::endl;
123465 : }
123466 : }
123467 : else
123468 : {
123469 0 : std::cout << "SgFoldExpression :: " << std::flush;
123470 0 : std::cout << "SgExpression* p_operands = " << p_operands << " --> " << std::flush;
123471 0 : std::cout << " not valid " << std::endl;
123472 : }
123473 : }
123474 :
123475 0 : if ( p_operatorPosition != NULL )
123476 : {
123477 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123478 : {
123479 0 : if ( p_operatorPosition->isInMemoryPool() == false )
123480 : {
123481 0 : std::cout << "SgFoldExpression :: ";
123482 0 : std::cout << " p_operatorPosition is not in memory pool of ";
123483 0 : std::cout << p_operatorPosition->class_name() << std::endl;
123484 : }
123485 : }
123486 : else
123487 : {
123488 0 : std::cout << "SgFoldExpression :: " << std::flush;
123489 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
123490 0 : std::cout << " not valid " << std::endl;
123491 : }
123492 : }
123493 :
123494 0 : if ( p_startOfConstruct != NULL )
123495 : {
123496 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123497 : {
123498 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
123499 : {
123500 0 : std::cout << "SgFoldExpression :: ";
123501 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
123502 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
123503 : }
123504 : }
123505 : else
123506 : {
123507 0 : std::cout << "SgFoldExpression :: " << std::flush;
123508 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
123509 0 : std::cout << " not valid " << std::endl;
123510 : }
123511 : }
123512 :
123513 0 : if ( p_endOfConstruct != NULL )
123514 : {
123515 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123516 : {
123517 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
123518 : {
123519 0 : std::cout << "SgFoldExpression :: ";
123520 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
123521 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
123522 : }
123523 : }
123524 : else
123525 : {
123526 0 : std::cout << "SgFoldExpression :: " << std::flush;
123527 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
123528 0 : std::cout << " not valid " << std::endl;
123529 : }
123530 : }
123531 :
123532 0 : if ( p_parent != NULL )
123533 : {
123534 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123535 : {
123536 0 : if ( p_parent->isInMemoryPool() == false )
123537 : {
123538 0 : std::cout << "SgFoldExpression :: ";
123539 0 : std::cout << " p_parent is not in memory pool of ";
123540 0 : std::cout << p_parent->class_name() << std::endl;
123541 : }
123542 : }
123543 : else
123544 : {
123545 0 : std::cout << "SgFoldExpression :: " << std::flush;
123546 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
123547 0 : std::cout << " not valid " << std::endl;
123548 : }
123549 : }
123550 :
123551 :
123552 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123553 :
123554 0 : }
123555 :
123556 :
123557 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
123558 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
123559 : bool
123560 0 : SgFoldExpression::isInMemoryPool ()
123561 : {
123562 0 : typedef unsigned char* TestType;
123563 :
123564 0 : bool found = false;
123565 :
123566 0 : ROSE_ASSERT(this != NULL);
123567 :
123568 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
123569 :
123570 0 : TestType tested = (TestType) ( this ) ;
123571 :
123572 0 : std::vector < unsigned char* > :: const_iterator block = SgFoldExpression::pools.begin();
123573 :
123574 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
123575 : // while (found == false && block < Memory_Block_List.end())
123576 0 : while ( (found == false) && (block != SgFoldExpression::pools.end()) )
123577 : {
123578 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFoldExpression::pool_size * sizeof(SgFoldExpression) ) ) ;
123579 0 : ++block;
123580 : }
123581 :
123582 : // Special handling for static data
123583 :
123584 :
123585 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
123586 0 : ROSE_ASSERT(found == true);
123587 :
123588 0 : return found;
123589 : }
123590 : /* #line 123591 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
123591 :
123592 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
123593 :
123594 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123595 :
123596 : /* #line 123597 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
123597 :
123598 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123599 :
123600 : void
123601 0 : SgAwaitExpression::checkDataMemberPointersIfInMemoryPool()
123602 : {
123603 : // ------------ checking pointers of SgAwaitExpression -------------------
123604 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
123605 :
123606 0 : if ( p_value != NULL )
123607 : {
123608 0 : if ( p_value->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123609 : {
123610 0 : if ( p_value->isInMemoryPool() == false )
123611 : {
123612 0 : std::cout << "SgAwaitExpression :: ";
123613 0 : std::cout << " p_value is not in memory pool of ";
123614 0 : std::cout << p_value->class_name() << std::endl;
123615 : }
123616 : }
123617 : else
123618 : {
123619 0 : std::cout << "SgAwaitExpression :: " << std::flush;
123620 0 : std::cout << "SgExpression* p_value = " << p_value << " --> " << std::flush;
123621 0 : std::cout << " not valid " << std::endl;
123622 : }
123623 : }
123624 :
123625 0 : if ( p_operatorPosition != NULL )
123626 : {
123627 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123628 : {
123629 0 : if ( p_operatorPosition->isInMemoryPool() == false )
123630 : {
123631 0 : std::cout << "SgAwaitExpression :: ";
123632 0 : std::cout << " p_operatorPosition is not in memory pool of ";
123633 0 : std::cout << p_operatorPosition->class_name() << std::endl;
123634 : }
123635 : }
123636 : else
123637 : {
123638 0 : std::cout << "SgAwaitExpression :: " << std::flush;
123639 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
123640 0 : std::cout << " not valid " << std::endl;
123641 : }
123642 : }
123643 :
123644 0 : if ( p_startOfConstruct != NULL )
123645 : {
123646 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123647 : {
123648 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
123649 : {
123650 0 : std::cout << "SgAwaitExpression :: ";
123651 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
123652 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
123653 : }
123654 : }
123655 : else
123656 : {
123657 0 : std::cout << "SgAwaitExpression :: " << std::flush;
123658 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
123659 0 : std::cout << " not valid " << std::endl;
123660 : }
123661 : }
123662 :
123663 0 : if ( p_endOfConstruct != NULL )
123664 : {
123665 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123666 : {
123667 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
123668 : {
123669 0 : std::cout << "SgAwaitExpression :: ";
123670 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
123671 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
123672 : }
123673 : }
123674 : else
123675 : {
123676 0 : std::cout << "SgAwaitExpression :: " << std::flush;
123677 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
123678 0 : std::cout << " not valid " << std::endl;
123679 : }
123680 : }
123681 :
123682 0 : if ( p_parent != NULL )
123683 : {
123684 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123685 : {
123686 0 : if ( p_parent->isInMemoryPool() == false )
123687 : {
123688 0 : std::cout << "SgAwaitExpression :: ";
123689 0 : std::cout << " p_parent is not in memory pool of ";
123690 0 : std::cout << p_parent->class_name() << std::endl;
123691 : }
123692 : }
123693 : else
123694 : {
123695 0 : std::cout << "SgAwaitExpression :: " << std::flush;
123696 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
123697 0 : std::cout << " not valid " << std::endl;
123698 : }
123699 : }
123700 :
123701 :
123702 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123703 :
123704 0 : }
123705 :
123706 :
123707 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
123708 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
123709 : bool
123710 0 : SgAwaitExpression::isInMemoryPool ()
123711 : {
123712 0 : typedef unsigned char* TestType;
123713 :
123714 0 : bool found = false;
123715 :
123716 0 : ROSE_ASSERT(this != NULL);
123717 :
123718 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
123719 :
123720 0 : TestType tested = (TestType) ( this ) ;
123721 :
123722 0 : std::vector < unsigned char* > :: const_iterator block = SgAwaitExpression::pools.begin();
123723 :
123724 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
123725 : // while (found == false && block < Memory_Block_List.end())
123726 0 : while ( (found == false) && (block != SgAwaitExpression::pools.end()) )
123727 : {
123728 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAwaitExpression::pool_size * sizeof(SgAwaitExpression) ) ) ;
123729 0 : ++block;
123730 : }
123731 :
123732 : // Special handling for static data
123733 :
123734 :
123735 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
123736 0 : ROSE_ASSERT(found == true);
123737 :
123738 0 : return found;
123739 : }
123740 : /* #line 123741 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
123741 :
123742 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
123743 :
123744 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123745 :
123746 : /* #line 123747 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
123747 :
123748 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123749 :
123750 : void
123751 0 : SgChooseExpression::checkDataMemberPointersIfInMemoryPool()
123752 : {
123753 : // ------------ checking pointers of SgChooseExpression -------------------
123754 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
123755 :
123756 0 : if ( p_value != NULL )
123757 : {
123758 0 : if ( p_value->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123759 : {
123760 0 : if ( p_value->isInMemoryPool() == false )
123761 : {
123762 0 : std::cout << "SgChooseExpression :: ";
123763 0 : std::cout << " p_value is not in memory pool of ";
123764 0 : std::cout << p_value->class_name() << std::endl;
123765 : }
123766 : }
123767 : else
123768 : {
123769 0 : std::cout << "SgChooseExpression :: " << std::flush;
123770 0 : std::cout << "SgExpression* p_value = " << p_value << " --> " << std::flush;
123771 0 : std::cout << " not valid " << std::endl;
123772 : }
123773 : }
123774 :
123775 0 : if ( p_operatorPosition != NULL )
123776 : {
123777 0 : if ( p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123778 : {
123779 0 : if ( p_operatorPosition->isInMemoryPool() == false )
123780 : {
123781 0 : std::cout << "SgChooseExpression :: ";
123782 0 : std::cout << " p_operatorPosition is not in memory pool of ";
123783 0 : std::cout << p_operatorPosition->class_name() << std::endl;
123784 : }
123785 : }
123786 : else
123787 : {
123788 0 : std::cout << "SgChooseExpression :: " << std::flush;
123789 0 : std::cout << "Sg_File_Info* p_operatorPosition = " << p_operatorPosition << " --> " << std::flush;
123790 0 : std::cout << " not valid " << std::endl;
123791 : }
123792 : }
123793 :
123794 0 : if ( p_startOfConstruct != NULL )
123795 : {
123796 0 : if ( p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123797 : {
123798 0 : if ( p_startOfConstruct->isInMemoryPool() == false )
123799 : {
123800 0 : std::cout << "SgChooseExpression :: ";
123801 0 : std::cout << " p_startOfConstruct is not in memory pool of ";
123802 0 : std::cout << p_startOfConstruct->class_name() << std::endl;
123803 : }
123804 : }
123805 : else
123806 : {
123807 0 : std::cout << "SgChooseExpression :: " << std::flush;
123808 0 : std::cout << "Sg_File_Info* p_startOfConstruct = " << p_startOfConstruct << " --> " << std::flush;
123809 0 : std::cout << " not valid " << std::endl;
123810 : }
123811 : }
123812 :
123813 0 : if ( p_endOfConstruct != NULL )
123814 : {
123815 0 : if ( p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123816 : {
123817 0 : if ( p_endOfConstruct->isInMemoryPool() == false )
123818 : {
123819 0 : std::cout << "SgChooseExpression :: ";
123820 0 : std::cout << " p_endOfConstruct is not in memory pool of ";
123821 0 : std::cout << p_endOfConstruct->class_name() << std::endl;
123822 : }
123823 : }
123824 : else
123825 : {
123826 0 : std::cout << "SgChooseExpression :: " << std::flush;
123827 0 : std::cout << "Sg_File_Info* p_endOfConstruct = " << p_endOfConstruct << " --> " << std::flush;
123828 0 : std::cout << " not valid " << std::endl;
123829 : }
123830 : }
123831 :
123832 0 : if ( p_parent != NULL )
123833 : {
123834 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123835 : {
123836 0 : if ( p_parent->isInMemoryPool() == false )
123837 : {
123838 0 : std::cout << "SgChooseExpression :: ";
123839 0 : std::cout << " p_parent is not in memory pool of ";
123840 0 : std::cout << p_parent->class_name() << std::endl;
123841 : }
123842 : }
123843 : else
123844 : {
123845 0 : std::cout << "SgChooseExpression :: " << std::flush;
123846 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
123847 0 : std::cout << " not valid " << std::endl;
123848 : }
123849 : }
123850 :
123851 :
123852 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123853 :
123854 0 : }
123855 :
123856 :
123857 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
123858 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
123859 : bool
123860 0 : SgChooseExpression::isInMemoryPool ()
123861 : {
123862 0 : typedef unsigned char* TestType;
123863 :
123864 0 : bool found = false;
123865 :
123866 0 : ROSE_ASSERT(this != NULL);
123867 :
123868 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
123869 :
123870 0 : TestType tested = (TestType) ( this ) ;
123871 :
123872 0 : std::vector < unsigned char* > :: const_iterator block = SgChooseExpression::pools.begin();
123873 :
123874 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
123875 : // while (found == false && block < Memory_Block_List.end())
123876 0 : while ( (found == false) && (block != SgChooseExpression::pools.end()) )
123877 : {
123878 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgChooseExpression::pool_size * sizeof(SgChooseExpression) ) ) ;
123879 0 : ++block;
123880 : }
123881 :
123882 : // Special handling for static data
123883 :
123884 :
123885 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
123886 0 : ROSE_ASSERT(found == true);
123887 :
123888 0 : return found;
123889 : }
123890 : /* #line 123891 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
123891 :
123892 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
123893 :
123894 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123895 :
123896 : /* #line 123897 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
123897 :
123898 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123899 :
123900 : void
123901 0 : SgSymbol::checkDataMemberPointersIfInMemoryPool()
123902 : {
123903 : // ------------ checking pointers of SgSymbol -------------------
123904 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
123905 :
123906 0 : if ( p_parent != NULL )
123907 : {
123908 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123909 : {
123910 0 : if ( p_parent->isInMemoryPool() == false )
123911 : {
123912 0 : std::cout << "SgSymbol :: ";
123913 0 : std::cout << " p_parent is not in memory pool of ";
123914 0 : std::cout << p_parent->class_name() << std::endl;
123915 : }
123916 : }
123917 : else
123918 : {
123919 0 : std::cout << "SgSymbol :: " << std::flush;
123920 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
123921 0 : std::cout << " not valid " << std::endl;
123922 : }
123923 : }
123924 :
123925 :
123926 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123927 :
123928 0 : }
123929 :
123930 :
123931 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
123932 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
123933 : bool
123934 0 : SgSymbol::isInMemoryPool ()
123935 : {
123936 0 : typedef unsigned char* TestType;
123937 :
123938 0 : bool found = false;
123939 :
123940 0 : ROSE_ASSERT(this != NULL);
123941 :
123942 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
123943 :
123944 0 : TestType tested = (TestType) ( this ) ;
123945 :
123946 0 : std::vector < unsigned char* > :: const_iterator block = SgSymbol::pools.begin();
123947 :
123948 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
123949 : // while (found == false && block < Memory_Block_List.end())
123950 0 : while ( (found == false) && (block != SgSymbol::pools.end()) )
123951 : {
123952 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgSymbol::pool_size * sizeof(SgSymbol) ) ) ;
123953 0 : ++block;
123954 : }
123955 :
123956 : // Special handling for static data
123957 :
123958 :
123959 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
123960 0 : ROSE_ASSERT(found == true);
123961 :
123962 0 : return found;
123963 : }
123964 : /* #line 123965 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
123965 :
123966 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
123967 :
123968 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123969 :
123970 : /* #line 123971 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
123971 :
123972 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
123973 :
123974 : void
123975 0 : SgVariableSymbol::checkDataMemberPointersIfInMemoryPool()
123976 : {
123977 : // ------------ checking pointers of SgVariableSymbol -------------------
123978 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
123979 :
123980 0 : if ( p_declaration != NULL )
123981 : {
123982 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
123983 : {
123984 0 : if ( p_declaration->isInMemoryPool() == false )
123985 : {
123986 0 : std::cout << "SgVariableSymbol :: ";
123987 0 : std::cout << " p_declaration is not in memory pool of ";
123988 0 : std::cout << p_declaration->class_name() << std::endl;
123989 : }
123990 : }
123991 : else
123992 : {
123993 0 : std::cout << "SgVariableSymbol :: " << std::flush;
123994 0 : std::cout << "SgInitializedName* p_declaration = " << p_declaration << " --> " << std::flush;
123995 0 : std::cout << " not valid " << std::endl;
123996 : }
123997 : }
123998 :
123999 0 : if ( p_parent != NULL )
124000 : {
124001 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124002 : {
124003 0 : if ( p_parent->isInMemoryPool() == false )
124004 : {
124005 0 : std::cout << "SgVariableSymbol :: ";
124006 0 : std::cout << " p_parent is not in memory pool of ";
124007 0 : std::cout << p_parent->class_name() << std::endl;
124008 : }
124009 : }
124010 : else
124011 : {
124012 0 : std::cout << "SgVariableSymbol :: " << std::flush;
124013 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
124014 0 : std::cout << " not valid " << std::endl;
124015 : }
124016 : }
124017 :
124018 :
124019 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124020 :
124021 0 : }
124022 :
124023 :
124024 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
124025 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
124026 : bool
124027 0 : SgVariableSymbol::isInMemoryPool ()
124028 : {
124029 0 : typedef unsigned char* TestType;
124030 :
124031 0 : bool found = false;
124032 :
124033 0 : ROSE_ASSERT(this != NULL);
124034 :
124035 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
124036 :
124037 0 : TestType tested = (TestType) ( this ) ;
124038 :
124039 0 : std::vector < unsigned char* > :: const_iterator block = SgVariableSymbol::pools.begin();
124040 :
124041 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
124042 : // while (found == false && block < Memory_Block_List.end())
124043 0 : while ( (found == false) && (block != SgVariableSymbol::pools.end()) )
124044 : {
124045 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgVariableSymbol::pool_size * sizeof(SgVariableSymbol) ) ) ;
124046 0 : ++block;
124047 : }
124048 :
124049 : // Special handling for static data
124050 :
124051 :
124052 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
124053 0 : ROSE_ASSERT(found == true);
124054 :
124055 0 : return found;
124056 : }
124057 : /* #line 124058 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124058 :
124059 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
124060 :
124061 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124062 :
124063 : /* #line 124064 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124064 :
124065 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124066 :
124067 : void
124068 0 : SgTemplateVariableSymbol::checkDataMemberPointersIfInMemoryPool()
124069 : {
124070 : // ------------ checking pointers of SgTemplateVariableSymbol -------------------
124071 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
124072 :
124073 0 : if ( p_declaration != NULL )
124074 : {
124075 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124076 : {
124077 0 : if ( p_declaration->isInMemoryPool() == false )
124078 : {
124079 0 : std::cout << "SgTemplateVariableSymbol :: ";
124080 0 : std::cout << " p_declaration is not in memory pool of ";
124081 0 : std::cout << p_declaration->class_name() << std::endl;
124082 : }
124083 : }
124084 : else
124085 : {
124086 0 : std::cout << "SgTemplateVariableSymbol :: " << std::flush;
124087 0 : std::cout << "SgInitializedName* p_declaration = " << p_declaration << " --> " << std::flush;
124088 0 : std::cout << " not valid " << std::endl;
124089 : }
124090 : }
124091 :
124092 0 : if ( p_parent != NULL )
124093 : {
124094 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124095 : {
124096 0 : if ( p_parent->isInMemoryPool() == false )
124097 : {
124098 0 : std::cout << "SgTemplateVariableSymbol :: ";
124099 0 : std::cout << " p_parent is not in memory pool of ";
124100 0 : std::cout << p_parent->class_name() << std::endl;
124101 : }
124102 : }
124103 : else
124104 : {
124105 0 : std::cout << "SgTemplateVariableSymbol :: " << std::flush;
124106 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
124107 0 : std::cout << " not valid " << std::endl;
124108 : }
124109 : }
124110 :
124111 :
124112 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124113 :
124114 0 : }
124115 :
124116 :
124117 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
124118 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
124119 : bool
124120 0 : SgTemplateVariableSymbol::isInMemoryPool ()
124121 : {
124122 0 : typedef unsigned char* TestType;
124123 :
124124 0 : bool found = false;
124125 :
124126 0 : ROSE_ASSERT(this != NULL);
124127 :
124128 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
124129 :
124130 0 : TestType tested = (TestType) ( this ) ;
124131 :
124132 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateVariableSymbol::pools.begin();
124133 :
124134 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
124135 : // while (found == false && block < Memory_Block_List.end())
124136 0 : while ( (found == false) && (block != SgTemplateVariableSymbol::pools.end()) )
124137 : {
124138 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateVariableSymbol::pool_size * sizeof(SgTemplateVariableSymbol) ) ) ;
124139 0 : ++block;
124140 : }
124141 :
124142 : // Special handling for static data
124143 :
124144 :
124145 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
124146 0 : ROSE_ASSERT(found == true);
124147 :
124148 0 : return found;
124149 : }
124150 : /* #line 124151 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124151 :
124152 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
124153 :
124154 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124155 :
124156 : /* #line 124157 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124157 :
124158 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124159 :
124160 : void
124161 0 : SgNonrealSymbol::checkDataMemberPointersIfInMemoryPool()
124162 : {
124163 : // ------------ checking pointers of SgNonrealSymbol -------------------
124164 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
124165 :
124166 0 : if ( p_declaration != NULL )
124167 : {
124168 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124169 : {
124170 0 : if ( p_declaration->isInMemoryPool() == false )
124171 : {
124172 0 : std::cout << "SgNonrealSymbol :: ";
124173 0 : std::cout << " p_declaration is not in memory pool of ";
124174 0 : std::cout << p_declaration->class_name() << std::endl;
124175 : }
124176 : }
124177 : else
124178 : {
124179 0 : std::cout << "SgNonrealSymbol :: " << std::flush;
124180 0 : std::cout << "SgNonrealDecl* p_declaration = " << p_declaration << " --> " << std::flush;
124181 0 : std::cout << " not valid " << std::endl;
124182 : }
124183 : }
124184 :
124185 0 : if ( p_parent != NULL )
124186 : {
124187 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124188 : {
124189 0 : if ( p_parent->isInMemoryPool() == false )
124190 : {
124191 0 : std::cout << "SgNonrealSymbol :: ";
124192 0 : std::cout << " p_parent is not in memory pool of ";
124193 0 : std::cout << p_parent->class_name() << std::endl;
124194 : }
124195 : }
124196 : else
124197 : {
124198 0 : std::cout << "SgNonrealSymbol :: " << std::flush;
124199 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
124200 0 : std::cout << " not valid " << std::endl;
124201 : }
124202 : }
124203 :
124204 :
124205 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124206 :
124207 0 : }
124208 :
124209 :
124210 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
124211 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
124212 : bool
124213 0 : SgNonrealSymbol::isInMemoryPool ()
124214 : {
124215 0 : typedef unsigned char* TestType;
124216 :
124217 0 : bool found = false;
124218 :
124219 0 : ROSE_ASSERT(this != NULL);
124220 :
124221 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
124222 :
124223 0 : TestType tested = (TestType) ( this ) ;
124224 :
124225 0 : std::vector < unsigned char* > :: const_iterator block = SgNonrealSymbol::pools.begin();
124226 :
124227 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
124228 : // while (found == false && block < Memory_Block_List.end())
124229 0 : while ( (found == false) && (block != SgNonrealSymbol::pools.end()) )
124230 : {
124231 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNonrealSymbol::pool_size * sizeof(SgNonrealSymbol) ) ) ;
124232 0 : ++block;
124233 : }
124234 :
124235 : // Special handling for static data
124236 :
124237 :
124238 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
124239 0 : ROSE_ASSERT(found == true);
124240 :
124241 0 : return found;
124242 : }
124243 : /* #line 124244 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124244 :
124245 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
124246 :
124247 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124248 :
124249 : /* #line 124250 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124250 :
124251 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124252 :
124253 : void
124254 0 : SgFunctionSymbol::checkDataMemberPointersIfInMemoryPool()
124255 : {
124256 : // ------------ checking pointers of SgFunctionSymbol -------------------
124257 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
124258 :
124259 0 : if ( p_declaration != NULL )
124260 : {
124261 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124262 : {
124263 0 : if ( p_declaration->isInMemoryPool() == false )
124264 : {
124265 0 : std::cout << "SgFunctionSymbol :: ";
124266 0 : std::cout << " p_declaration is not in memory pool of ";
124267 0 : std::cout << p_declaration->class_name() << std::endl;
124268 : }
124269 : }
124270 : else
124271 : {
124272 0 : std::cout << "SgFunctionSymbol :: " << std::flush;
124273 0 : std::cout << "SgFunctionDeclaration* p_declaration = " << p_declaration << " --> " << std::flush;
124274 0 : std::cout << " not valid " << std::endl;
124275 : }
124276 : }
124277 :
124278 0 : if ( p_parent != NULL )
124279 : {
124280 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124281 : {
124282 0 : if ( p_parent->isInMemoryPool() == false )
124283 : {
124284 0 : std::cout << "SgFunctionSymbol :: ";
124285 0 : std::cout << " p_parent is not in memory pool of ";
124286 0 : std::cout << p_parent->class_name() << std::endl;
124287 : }
124288 : }
124289 : else
124290 : {
124291 0 : std::cout << "SgFunctionSymbol :: " << std::flush;
124292 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
124293 0 : std::cout << " not valid " << std::endl;
124294 : }
124295 : }
124296 :
124297 :
124298 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124299 :
124300 0 : }
124301 :
124302 :
124303 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
124304 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
124305 : bool
124306 0 : SgFunctionSymbol::isInMemoryPool ()
124307 : {
124308 0 : typedef unsigned char* TestType;
124309 :
124310 0 : bool found = false;
124311 :
124312 0 : ROSE_ASSERT(this != NULL);
124313 :
124314 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
124315 :
124316 0 : TestType tested = (TestType) ( this ) ;
124317 :
124318 0 : std::vector < unsigned char* > :: const_iterator block = SgFunctionSymbol::pools.begin();
124319 :
124320 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
124321 : // while (found == false && block < Memory_Block_List.end())
124322 0 : while ( (found == false) && (block != SgFunctionSymbol::pools.end()) )
124323 : {
124324 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFunctionSymbol::pool_size * sizeof(SgFunctionSymbol) ) ) ;
124325 0 : ++block;
124326 : }
124327 :
124328 : // Special handling for static data
124329 :
124330 :
124331 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
124332 0 : ROSE_ASSERT(found == true);
124333 :
124334 0 : return found;
124335 : }
124336 : /* #line 124337 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124337 :
124338 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
124339 :
124340 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124341 :
124342 : /* #line 124343 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124343 :
124344 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124345 :
124346 : void
124347 0 : SgMemberFunctionSymbol::checkDataMemberPointersIfInMemoryPool()
124348 : {
124349 : // ------------ checking pointers of SgMemberFunctionSymbol -------------------
124350 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
124351 :
124352 0 : if ( p_declaration != NULL )
124353 : {
124354 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124355 : {
124356 0 : if ( p_declaration->isInMemoryPool() == false )
124357 : {
124358 0 : std::cout << "SgMemberFunctionSymbol :: ";
124359 0 : std::cout << " p_declaration is not in memory pool of ";
124360 0 : std::cout << p_declaration->class_name() << std::endl;
124361 : }
124362 : }
124363 : else
124364 : {
124365 0 : std::cout << "SgMemberFunctionSymbol :: " << std::flush;
124366 0 : std::cout << "SgFunctionDeclaration* p_declaration = " << p_declaration << " --> " << std::flush;
124367 0 : std::cout << " not valid " << std::endl;
124368 : }
124369 : }
124370 :
124371 0 : if ( p_parent != NULL )
124372 : {
124373 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124374 : {
124375 0 : if ( p_parent->isInMemoryPool() == false )
124376 : {
124377 0 : std::cout << "SgMemberFunctionSymbol :: ";
124378 0 : std::cout << " p_parent is not in memory pool of ";
124379 0 : std::cout << p_parent->class_name() << std::endl;
124380 : }
124381 : }
124382 : else
124383 : {
124384 0 : std::cout << "SgMemberFunctionSymbol :: " << std::flush;
124385 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
124386 0 : std::cout << " not valid " << std::endl;
124387 : }
124388 : }
124389 :
124390 :
124391 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124392 :
124393 0 : }
124394 :
124395 :
124396 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
124397 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
124398 : bool
124399 0 : SgMemberFunctionSymbol::isInMemoryPool ()
124400 : {
124401 0 : typedef unsigned char* TestType;
124402 :
124403 0 : bool found = false;
124404 :
124405 0 : ROSE_ASSERT(this != NULL);
124406 :
124407 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
124408 :
124409 0 : TestType tested = (TestType) ( this ) ;
124410 :
124411 0 : std::vector < unsigned char* > :: const_iterator block = SgMemberFunctionSymbol::pools.begin();
124412 :
124413 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
124414 : // while (found == false && block < Memory_Block_List.end())
124415 0 : while ( (found == false) && (block != SgMemberFunctionSymbol::pools.end()) )
124416 : {
124417 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgMemberFunctionSymbol::pool_size * sizeof(SgMemberFunctionSymbol) ) ) ;
124418 0 : ++block;
124419 : }
124420 :
124421 : // Special handling for static data
124422 :
124423 :
124424 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
124425 0 : ROSE_ASSERT(found == true);
124426 :
124427 0 : return found;
124428 : }
124429 : /* #line 124430 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124430 :
124431 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
124432 :
124433 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124434 :
124435 : /* #line 124436 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124436 :
124437 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124438 :
124439 : void
124440 0 : SgTemplateMemberFunctionSymbol::checkDataMemberPointersIfInMemoryPool()
124441 : {
124442 : // ------------ checking pointers of SgTemplateMemberFunctionSymbol -------------------
124443 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
124444 :
124445 0 : if ( p_declaration != NULL )
124446 : {
124447 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124448 : {
124449 0 : if ( p_declaration->isInMemoryPool() == false )
124450 : {
124451 0 : std::cout << "SgTemplateMemberFunctionSymbol :: ";
124452 0 : std::cout << " p_declaration is not in memory pool of ";
124453 0 : std::cout << p_declaration->class_name() << std::endl;
124454 : }
124455 : }
124456 : else
124457 : {
124458 0 : std::cout << "SgTemplateMemberFunctionSymbol :: " << std::flush;
124459 0 : std::cout << "SgFunctionDeclaration* p_declaration = " << p_declaration << " --> " << std::flush;
124460 0 : std::cout << " not valid " << std::endl;
124461 : }
124462 : }
124463 :
124464 0 : if ( p_parent != NULL )
124465 : {
124466 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124467 : {
124468 0 : if ( p_parent->isInMemoryPool() == false )
124469 : {
124470 0 : std::cout << "SgTemplateMemberFunctionSymbol :: ";
124471 0 : std::cout << " p_parent is not in memory pool of ";
124472 0 : std::cout << p_parent->class_name() << std::endl;
124473 : }
124474 : }
124475 : else
124476 : {
124477 0 : std::cout << "SgTemplateMemberFunctionSymbol :: " << std::flush;
124478 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
124479 0 : std::cout << " not valid " << std::endl;
124480 : }
124481 : }
124482 :
124483 :
124484 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124485 :
124486 0 : }
124487 :
124488 :
124489 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
124490 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
124491 : bool
124492 0 : SgTemplateMemberFunctionSymbol::isInMemoryPool ()
124493 : {
124494 0 : typedef unsigned char* TestType;
124495 :
124496 0 : bool found = false;
124497 :
124498 0 : ROSE_ASSERT(this != NULL);
124499 :
124500 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
124501 :
124502 0 : TestType tested = (TestType) ( this ) ;
124503 :
124504 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateMemberFunctionSymbol::pools.begin();
124505 :
124506 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
124507 : // while (found == false && block < Memory_Block_List.end())
124508 0 : while ( (found == false) && (block != SgTemplateMemberFunctionSymbol::pools.end()) )
124509 : {
124510 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateMemberFunctionSymbol::pool_size * sizeof(SgTemplateMemberFunctionSymbol) ) ) ;
124511 0 : ++block;
124512 : }
124513 :
124514 : // Special handling for static data
124515 :
124516 :
124517 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
124518 0 : ROSE_ASSERT(found == true);
124519 :
124520 0 : return found;
124521 : }
124522 : /* #line 124523 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124523 :
124524 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
124525 :
124526 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124527 :
124528 : /* #line 124529 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124529 :
124530 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124531 :
124532 : void
124533 0 : SgTemplateFunctionSymbol::checkDataMemberPointersIfInMemoryPool()
124534 : {
124535 : // ------------ checking pointers of SgTemplateFunctionSymbol -------------------
124536 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
124537 :
124538 0 : if ( p_declaration != NULL )
124539 : {
124540 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124541 : {
124542 0 : if ( p_declaration->isInMemoryPool() == false )
124543 : {
124544 0 : std::cout << "SgTemplateFunctionSymbol :: ";
124545 0 : std::cout << " p_declaration is not in memory pool of ";
124546 0 : std::cout << p_declaration->class_name() << std::endl;
124547 : }
124548 : }
124549 : else
124550 : {
124551 0 : std::cout << "SgTemplateFunctionSymbol :: " << std::flush;
124552 0 : std::cout << "SgFunctionDeclaration* p_declaration = " << p_declaration << " --> " << std::flush;
124553 0 : std::cout << " not valid " << std::endl;
124554 : }
124555 : }
124556 :
124557 0 : if ( p_parent != NULL )
124558 : {
124559 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124560 : {
124561 0 : if ( p_parent->isInMemoryPool() == false )
124562 : {
124563 0 : std::cout << "SgTemplateFunctionSymbol :: ";
124564 0 : std::cout << " p_parent is not in memory pool of ";
124565 0 : std::cout << p_parent->class_name() << std::endl;
124566 : }
124567 : }
124568 : else
124569 : {
124570 0 : std::cout << "SgTemplateFunctionSymbol :: " << std::flush;
124571 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
124572 0 : std::cout << " not valid " << std::endl;
124573 : }
124574 : }
124575 :
124576 :
124577 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124578 :
124579 0 : }
124580 :
124581 :
124582 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
124583 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
124584 : bool
124585 0 : SgTemplateFunctionSymbol::isInMemoryPool ()
124586 : {
124587 0 : typedef unsigned char* TestType;
124588 :
124589 0 : bool found = false;
124590 :
124591 0 : ROSE_ASSERT(this != NULL);
124592 :
124593 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
124594 :
124595 0 : TestType tested = (TestType) ( this ) ;
124596 :
124597 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateFunctionSymbol::pools.begin();
124598 :
124599 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
124600 : // while (found == false && block < Memory_Block_List.end())
124601 0 : while ( (found == false) && (block != SgTemplateFunctionSymbol::pools.end()) )
124602 : {
124603 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateFunctionSymbol::pool_size * sizeof(SgTemplateFunctionSymbol) ) ) ;
124604 0 : ++block;
124605 : }
124606 :
124607 : // Special handling for static data
124608 :
124609 :
124610 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
124611 0 : ROSE_ASSERT(found == true);
124612 :
124613 0 : return found;
124614 : }
124615 : /* #line 124616 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124616 :
124617 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
124618 :
124619 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124620 :
124621 : /* #line 124622 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124622 :
124623 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124624 :
124625 : void
124626 0 : SgRenameSymbol::checkDataMemberPointersIfInMemoryPool()
124627 : {
124628 : // ------------ checking pointers of SgRenameSymbol -------------------
124629 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
124630 :
124631 0 : if ( p_original_symbol != NULL )
124632 : {
124633 0 : if ( p_original_symbol->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124634 : {
124635 0 : if ( p_original_symbol->isInMemoryPool() == false )
124636 : {
124637 0 : std::cout << "SgRenameSymbol :: ";
124638 0 : std::cout << " p_original_symbol is not in memory pool of ";
124639 0 : std::cout << p_original_symbol->class_name() << std::endl;
124640 : }
124641 : }
124642 : else
124643 : {
124644 0 : std::cout << "SgRenameSymbol :: " << std::flush;
124645 0 : std::cout << "SgSymbol* p_original_symbol = " << p_original_symbol << " --> " << std::flush;
124646 0 : std::cout << " not valid " << std::endl;
124647 : }
124648 : }
124649 :
124650 0 : if ( p_declaration != NULL )
124651 : {
124652 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124653 : {
124654 0 : if ( p_declaration->isInMemoryPool() == false )
124655 : {
124656 0 : std::cout << "SgRenameSymbol :: ";
124657 0 : std::cout << " p_declaration is not in memory pool of ";
124658 0 : std::cout << p_declaration->class_name() << std::endl;
124659 : }
124660 : }
124661 : else
124662 : {
124663 0 : std::cout << "SgRenameSymbol :: " << std::flush;
124664 0 : std::cout << "SgFunctionDeclaration* p_declaration = " << p_declaration << " --> " << std::flush;
124665 0 : std::cout << " not valid " << std::endl;
124666 : }
124667 : }
124668 :
124669 0 : if ( p_parent != NULL )
124670 : {
124671 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124672 : {
124673 0 : if ( p_parent->isInMemoryPool() == false )
124674 : {
124675 0 : std::cout << "SgRenameSymbol :: ";
124676 0 : std::cout << " p_parent is not in memory pool of ";
124677 0 : std::cout << p_parent->class_name() << std::endl;
124678 : }
124679 : }
124680 : else
124681 : {
124682 0 : std::cout << "SgRenameSymbol :: " << std::flush;
124683 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
124684 0 : std::cout << " not valid " << std::endl;
124685 : }
124686 : }
124687 :
124688 :
124689 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124690 :
124691 0 : }
124692 :
124693 :
124694 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
124695 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
124696 : bool
124697 0 : SgRenameSymbol::isInMemoryPool ()
124698 : {
124699 0 : typedef unsigned char* TestType;
124700 :
124701 0 : bool found = false;
124702 :
124703 0 : ROSE_ASSERT(this != NULL);
124704 :
124705 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
124706 :
124707 0 : TestType tested = (TestType) ( this ) ;
124708 :
124709 0 : std::vector < unsigned char* > :: const_iterator block = SgRenameSymbol::pools.begin();
124710 :
124711 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
124712 : // while (found == false && block < Memory_Block_List.end())
124713 0 : while ( (found == false) && (block != SgRenameSymbol::pools.end()) )
124714 : {
124715 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgRenameSymbol::pool_size * sizeof(SgRenameSymbol) ) ) ;
124716 0 : ++block;
124717 : }
124718 :
124719 : // Special handling for static data
124720 :
124721 :
124722 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
124723 0 : ROSE_ASSERT(found == true);
124724 :
124725 0 : return found;
124726 : }
124727 : /* #line 124728 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124728 :
124729 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
124730 :
124731 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124732 :
124733 : /* #line 124734 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124734 :
124735 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124736 :
124737 : void
124738 0 : SgFunctionTypeSymbol::checkDataMemberPointersIfInMemoryPool()
124739 : {
124740 : // ------------ checking pointers of SgFunctionTypeSymbol -------------------
124741 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
124742 :
124743 0 : if ( p_type != NULL )
124744 : {
124745 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124746 : {
124747 0 : if ( p_type->isInMemoryPool() == false )
124748 : {
124749 0 : std::cout << "SgFunctionTypeSymbol :: ";
124750 0 : std::cout << " p_type is not in memory pool of ";
124751 0 : std::cout << p_type->class_name() << std::endl;
124752 : }
124753 : }
124754 : else
124755 : {
124756 0 : std::cout << "SgFunctionTypeSymbol :: " << std::flush;
124757 0 : std::cout << "SgType* p_type = " << p_type << " --> " << std::flush;
124758 0 : std::cout << " not valid " << std::endl;
124759 : }
124760 : }
124761 :
124762 0 : if ( p_parent != NULL )
124763 : {
124764 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124765 : {
124766 0 : if ( p_parent->isInMemoryPool() == false )
124767 : {
124768 0 : std::cout << "SgFunctionTypeSymbol :: ";
124769 0 : std::cout << " p_parent is not in memory pool of ";
124770 0 : std::cout << p_parent->class_name() << std::endl;
124771 : }
124772 : }
124773 : else
124774 : {
124775 0 : std::cout << "SgFunctionTypeSymbol :: " << std::flush;
124776 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
124777 0 : std::cout << " not valid " << std::endl;
124778 : }
124779 : }
124780 :
124781 :
124782 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124783 :
124784 0 : }
124785 :
124786 :
124787 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
124788 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
124789 : bool
124790 0 : SgFunctionTypeSymbol::isInMemoryPool ()
124791 : {
124792 0 : typedef unsigned char* TestType;
124793 :
124794 0 : bool found = false;
124795 :
124796 0 : ROSE_ASSERT(this != NULL);
124797 :
124798 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
124799 :
124800 0 : TestType tested = (TestType) ( this ) ;
124801 :
124802 0 : std::vector < unsigned char* > :: const_iterator block = SgFunctionTypeSymbol::pools.begin();
124803 :
124804 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
124805 : // while (found == false && block < Memory_Block_List.end())
124806 0 : while ( (found == false) && (block != SgFunctionTypeSymbol::pools.end()) )
124807 : {
124808 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgFunctionTypeSymbol::pool_size * sizeof(SgFunctionTypeSymbol) ) ) ;
124809 0 : ++block;
124810 : }
124811 :
124812 : // Special handling for static data
124813 :
124814 :
124815 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
124816 0 : ROSE_ASSERT(found == true);
124817 :
124818 0 : return found;
124819 : }
124820 : /* #line 124821 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124821 :
124822 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
124823 :
124824 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124825 :
124826 : /* #line 124827 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124827 :
124828 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124829 :
124830 : void
124831 0 : SgClassSymbol::checkDataMemberPointersIfInMemoryPool()
124832 : {
124833 : // ------------ checking pointers of SgClassSymbol -------------------
124834 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
124835 :
124836 0 : if ( p_declaration != NULL )
124837 : {
124838 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124839 : {
124840 0 : if ( p_declaration->isInMemoryPool() == false )
124841 : {
124842 0 : std::cout << "SgClassSymbol :: ";
124843 0 : std::cout << " p_declaration is not in memory pool of ";
124844 0 : std::cout << p_declaration->class_name() << std::endl;
124845 : }
124846 : }
124847 : else
124848 : {
124849 0 : std::cout << "SgClassSymbol :: " << std::flush;
124850 0 : std::cout << "SgClassDeclaration* p_declaration = " << p_declaration << " --> " << std::flush;
124851 0 : std::cout << " not valid " << std::endl;
124852 : }
124853 : }
124854 :
124855 0 : if ( p_parent != NULL )
124856 : {
124857 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124858 : {
124859 0 : if ( p_parent->isInMemoryPool() == false )
124860 : {
124861 0 : std::cout << "SgClassSymbol :: ";
124862 0 : std::cout << " p_parent is not in memory pool of ";
124863 0 : std::cout << p_parent->class_name() << std::endl;
124864 : }
124865 : }
124866 : else
124867 : {
124868 0 : std::cout << "SgClassSymbol :: " << std::flush;
124869 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
124870 0 : std::cout << " not valid " << std::endl;
124871 : }
124872 : }
124873 :
124874 :
124875 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124876 :
124877 0 : }
124878 :
124879 :
124880 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
124881 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
124882 : bool
124883 0 : SgClassSymbol::isInMemoryPool ()
124884 : {
124885 0 : typedef unsigned char* TestType;
124886 :
124887 0 : bool found = false;
124888 :
124889 0 : ROSE_ASSERT(this != NULL);
124890 :
124891 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
124892 :
124893 0 : TestType tested = (TestType) ( this ) ;
124894 :
124895 0 : std::vector < unsigned char* > :: const_iterator block = SgClassSymbol::pools.begin();
124896 :
124897 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
124898 : // while (found == false && block < Memory_Block_List.end())
124899 0 : while ( (found == false) && (block != SgClassSymbol::pools.end()) )
124900 : {
124901 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgClassSymbol::pool_size * sizeof(SgClassSymbol) ) ) ;
124902 0 : ++block;
124903 : }
124904 :
124905 : // Special handling for static data
124906 :
124907 :
124908 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
124909 0 : ROSE_ASSERT(found == true);
124910 :
124911 0 : return found;
124912 : }
124913 : /* #line 124914 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124914 :
124915 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
124916 :
124917 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124918 :
124919 : /* #line 124920 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
124920 :
124921 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124922 :
124923 : void
124924 0 : SgTemplateClassSymbol::checkDataMemberPointersIfInMemoryPool()
124925 : {
124926 : // ------------ checking pointers of SgTemplateClassSymbol -------------------
124927 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
124928 :
124929 0 : if ( p_declaration != NULL )
124930 : {
124931 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124932 : {
124933 0 : if ( p_declaration->isInMemoryPool() == false )
124934 : {
124935 0 : std::cout << "SgTemplateClassSymbol :: ";
124936 0 : std::cout << " p_declaration is not in memory pool of ";
124937 0 : std::cout << p_declaration->class_name() << std::endl;
124938 : }
124939 : }
124940 : else
124941 : {
124942 0 : std::cout << "SgTemplateClassSymbol :: " << std::flush;
124943 0 : std::cout << "SgClassDeclaration* p_declaration = " << p_declaration << " --> " << std::flush;
124944 0 : std::cout << " not valid " << std::endl;
124945 : }
124946 : }
124947 :
124948 0 : if ( p_parent != NULL )
124949 : {
124950 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
124951 : {
124952 0 : if ( p_parent->isInMemoryPool() == false )
124953 : {
124954 0 : std::cout << "SgTemplateClassSymbol :: ";
124955 0 : std::cout << " p_parent is not in memory pool of ";
124956 0 : std::cout << p_parent->class_name() << std::endl;
124957 : }
124958 : }
124959 : else
124960 : {
124961 0 : std::cout << "SgTemplateClassSymbol :: " << std::flush;
124962 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
124963 0 : std::cout << " not valid " << std::endl;
124964 : }
124965 : }
124966 :
124967 :
124968 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
124969 :
124970 0 : }
124971 :
124972 :
124973 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
124974 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
124975 : bool
124976 0 : SgTemplateClassSymbol::isInMemoryPool ()
124977 : {
124978 0 : typedef unsigned char* TestType;
124979 :
124980 0 : bool found = false;
124981 :
124982 0 : ROSE_ASSERT(this != NULL);
124983 :
124984 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
124985 :
124986 0 : TestType tested = (TestType) ( this ) ;
124987 :
124988 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateClassSymbol::pools.begin();
124989 :
124990 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
124991 : // while (found == false && block < Memory_Block_List.end())
124992 0 : while ( (found == false) && (block != SgTemplateClassSymbol::pools.end()) )
124993 : {
124994 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateClassSymbol::pool_size * sizeof(SgTemplateClassSymbol) ) ) ;
124995 0 : ++block;
124996 : }
124997 :
124998 : // Special handling for static data
124999 :
125000 :
125001 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
125002 0 : ROSE_ASSERT(found == true);
125003 :
125004 0 : return found;
125005 : }
125006 : /* #line 125007 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125007 :
125008 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
125009 :
125010 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125011 :
125012 : /* #line 125013 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125013 :
125014 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125015 :
125016 : void
125017 0 : SgTemplateSymbol::checkDataMemberPointersIfInMemoryPool()
125018 : {
125019 : // ------------ checking pointers of SgTemplateSymbol -------------------
125020 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
125021 :
125022 0 : if ( p_declaration != NULL )
125023 : {
125024 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125025 : {
125026 0 : if ( p_declaration->isInMemoryPool() == false )
125027 : {
125028 0 : std::cout << "SgTemplateSymbol :: ";
125029 0 : std::cout << " p_declaration is not in memory pool of ";
125030 0 : std::cout << p_declaration->class_name() << std::endl;
125031 : }
125032 : }
125033 : else
125034 : {
125035 0 : std::cout << "SgTemplateSymbol :: " << std::flush;
125036 0 : std::cout << "SgTemplateDeclaration* p_declaration = " << p_declaration << " --> " << std::flush;
125037 0 : std::cout << " not valid " << std::endl;
125038 : }
125039 : }
125040 :
125041 0 : if ( p_parent != NULL )
125042 : {
125043 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125044 : {
125045 0 : if ( p_parent->isInMemoryPool() == false )
125046 : {
125047 0 : std::cout << "SgTemplateSymbol :: ";
125048 0 : std::cout << " p_parent is not in memory pool of ";
125049 0 : std::cout << p_parent->class_name() << std::endl;
125050 : }
125051 : }
125052 : else
125053 : {
125054 0 : std::cout << "SgTemplateSymbol :: " << std::flush;
125055 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
125056 0 : std::cout << " not valid " << std::endl;
125057 : }
125058 : }
125059 :
125060 :
125061 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125062 :
125063 0 : }
125064 :
125065 :
125066 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
125067 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
125068 : bool
125069 0 : SgTemplateSymbol::isInMemoryPool ()
125070 : {
125071 0 : typedef unsigned char* TestType;
125072 :
125073 0 : bool found = false;
125074 :
125075 0 : ROSE_ASSERT(this != NULL);
125076 :
125077 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
125078 :
125079 0 : TestType tested = (TestType) ( this ) ;
125080 :
125081 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateSymbol::pools.begin();
125082 :
125083 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
125084 : // while (found == false && block < Memory_Block_List.end())
125085 0 : while ( (found == false) && (block != SgTemplateSymbol::pools.end()) )
125086 : {
125087 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateSymbol::pool_size * sizeof(SgTemplateSymbol) ) ) ;
125088 0 : ++block;
125089 : }
125090 :
125091 : // Special handling for static data
125092 :
125093 :
125094 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
125095 0 : ROSE_ASSERT(found == true);
125096 :
125097 0 : return found;
125098 : }
125099 : /* #line 125100 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125100 :
125101 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
125102 :
125103 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125104 :
125105 : /* #line 125106 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125106 :
125107 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125108 :
125109 : void
125110 0 : SgEnumSymbol::checkDataMemberPointersIfInMemoryPool()
125111 : {
125112 : // ------------ checking pointers of SgEnumSymbol -------------------
125113 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
125114 :
125115 0 : if ( p_declaration != NULL )
125116 : {
125117 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125118 : {
125119 0 : if ( p_declaration->isInMemoryPool() == false )
125120 : {
125121 0 : std::cout << "SgEnumSymbol :: ";
125122 0 : std::cout << " p_declaration is not in memory pool of ";
125123 0 : std::cout << p_declaration->class_name() << std::endl;
125124 : }
125125 : }
125126 : else
125127 : {
125128 0 : std::cout << "SgEnumSymbol :: " << std::flush;
125129 0 : std::cout << "SgEnumDeclaration* p_declaration = " << p_declaration << " --> " << std::flush;
125130 0 : std::cout << " not valid " << std::endl;
125131 : }
125132 : }
125133 :
125134 0 : if ( p_parent != NULL )
125135 : {
125136 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125137 : {
125138 0 : if ( p_parent->isInMemoryPool() == false )
125139 : {
125140 0 : std::cout << "SgEnumSymbol :: ";
125141 0 : std::cout << " p_parent is not in memory pool of ";
125142 0 : std::cout << p_parent->class_name() << std::endl;
125143 : }
125144 : }
125145 : else
125146 : {
125147 0 : std::cout << "SgEnumSymbol :: " << std::flush;
125148 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
125149 0 : std::cout << " not valid " << std::endl;
125150 : }
125151 : }
125152 :
125153 :
125154 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125155 :
125156 0 : }
125157 :
125158 :
125159 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
125160 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
125161 : bool
125162 0 : SgEnumSymbol::isInMemoryPool ()
125163 : {
125164 0 : typedef unsigned char* TestType;
125165 :
125166 0 : bool found = false;
125167 :
125168 0 : ROSE_ASSERT(this != NULL);
125169 :
125170 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
125171 :
125172 0 : TestType tested = (TestType) ( this ) ;
125173 :
125174 0 : std::vector < unsigned char* > :: const_iterator block = SgEnumSymbol::pools.begin();
125175 :
125176 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
125177 : // while (found == false && block < Memory_Block_List.end())
125178 0 : while ( (found == false) && (block != SgEnumSymbol::pools.end()) )
125179 : {
125180 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgEnumSymbol::pool_size * sizeof(SgEnumSymbol) ) ) ;
125181 0 : ++block;
125182 : }
125183 :
125184 : // Special handling for static data
125185 :
125186 :
125187 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
125188 0 : ROSE_ASSERT(found == true);
125189 :
125190 0 : return found;
125191 : }
125192 : /* #line 125193 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125193 :
125194 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
125195 :
125196 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125197 :
125198 : /* #line 125199 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125199 :
125200 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125201 :
125202 : void
125203 0 : SgEnumFieldSymbol::checkDataMemberPointersIfInMemoryPool()
125204 : {
125205 : // ------------ checking pointers of SgEnumFieldSymbol -------------------
125206 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
125207 :
125208 0 : if ( p_declaration != NULL )
125209 : {
125210 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125211 : {
125212 0 : if ( p_declaration->isInMemoryPool() == false )
125213 : {
125214 0 : std::cout << "SgEnumFieldSymbol :: ";
125215 0 : std::cout << " p_declaration is not in memory pool of ";
125216 0 : std::cout << p_declaration->class_name() << std::endl;
125217 : }
125218 : }
125219 : else
125220 : {
125221 0 : std::cout << "SgEnumFieldSymbol :: " << std::flush;
125222 0 : std::cout << "SgInitializedName* p_declaration = " << p_declaration << " --> " << std::flush;
125223 0 : std::cout << " not valid " << std::endl;
125224 : }
125225 : }
125226 :
125227 0 : if ( p_parent != NULL )
125228 : {
125229 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125230 : {
125231 0 : if ( p_parent->isInMemoryPool() == false )
125232 : {
125233 0 : std::cout << "SgEnumFieldSymbol :: ";
125234 0 : std::cout << " p_parent is not in memory pool of ";
125235 0 : std::cout << p_parent->class_name() << std::endl;
125236 : }
125237 : }
125238 : else
125239 : {
125240 0 : std::cout << "SgEnumFieldSymbol :: " << std::flush;
125241 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
125242 0 : std::cout << " not valid " << std::endl;
125243 : }
125244 : }
125245 :
125246 :
125247 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125248 :
125249 0 : }
125250 :
125251 :
125252 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
125253 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
125254 : bool
125255 0 : SgEnumFieldSymbol::isInMemoryPool ()
125256 : {
125257 0 : typedef unsigned char* TestType;
125258 :
125259 0 : bool found = false;
125260 :
125261 0 : ROSE_ASSERT(this != NULL);
125262 :
125263 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
125264 :
125265 0 : TestType tested = (TestType) ( this ) ;
125266 :
125267 0 : std::vector < unsigned char* > :: const_iterator block = SgEnumFieldSymbol::pools.begin();
125268 :
125269 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
125270 : // while (found == false && block < Memory_Block_List.end())
125271 0 : while ( (found == false) && (block != SgEnumFieldSymbol::pools.end()) )
125272 : {
125273 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgEnumFieldSymbol::pool_size * sizeof(SgEnumFieldSymbol) ) ) ;
125274 0 : ++block;
125275 : }
125276 :
125277 : // Special handling for static data
125278 :
125279 :
125280 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
125281 0 : ROSE_ASSERT(found == true);
125282 :
125283 0 : return found;
125284 : }
125285 : /* #line 125286 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125286 :
125287 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
125288 :
125289 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125290 :
125291 : /* #line 125292 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125292 :
125293 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125294 :
125295 : void
125296 0 : SgTypedefSymbol::checkDataMemberPointersIfInMemoryPool()
125297 : {
125298 : // ------------ checking pointers of SgTypedefSymbol -------------------
125299 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
125300 :
125301 0 : if ( p_declaration != NULL )
125302 : {
125303 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125304 : {
125305 0 : if ( p_declaration->isInMemoryPool() == false )
125306 : {
125307 0 : std::cout << "SgTypedefSymbol :: ";
125308 0 : std::cout << " p_declaration is not in memory pool of ";
125309 0 : std::cout << p_declaration->class_name() << std::endl;
125310 : }
125311 : }
125312 : else
125313 : {
125314 0 : std::cout << "SgTypedefSymbol :: " << std::flush;
125315 0 : std::cout << "SgTypedefDeclaration* p_declaration = " << p_declaration << " --> " << std::flush;
125316 0 : std::cout << " not valid " << std::endl;
125317 : }
125318 : }
125319 :
125320 0 : if ( p_parent != NULL )
125321 : {
125322 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125323 : {
125324 0 : if ( p_parent->isInMemoryPool() == false )
125325 : {
125326 0 : std::cout << "SgTypedefSymbol :: ";
125327 0 : std::cout << " p_parent is not in memory pool of ";
125328 0 : std::cout << p_parent->class_name() << std::endl;
125329 : }
125330 : }
125331 : else
125332 : {
125333 0 : std::cout << "SgTypedefSymbol :: " << std::flush;
125334 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
125335 0 : std::cout << " not valid " << std::endl;
125336 : }
125337 : }
125338 :
125339 :
125340 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125341 :
125342 0 : }
125343 :
125344 :
125345 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
125346 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
125347 : bool
125348 0 : SgTypedefSymbol::isInMemoryPool ()
125349 : {
125350 0 : typedef unsigned char* TestType;
125351 :
125352 0 : bool found = false;
125353 :
125354 0 : ROSE_ASSERT(this != NULL);
125355 :
125356 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
125357 :
125358 0 : TestType tested = (TestType) ( this ) ;
125359 :
125360 0 : std::vector < unsigned char* > :: const_iterator block = SgTypedefSymbol::pools.begin();
125361 :
125362 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
125363 : // while (found == false && block < Memory_Block_List.end())
125364 0 : while ( (found == false) && (block != SgTypedefSymbol::pools.end()) )
125365 : {
125366 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTypedefSymbol::pool_size * sizeof(SgTypedefSymbol) ) ) ;
125367 0 : ++block;
125368 : }
125369 :
125370 : // Special handling for static data
125371 :
125372 :
125373 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
125374 0 : ROSE_ASSERT(found == true);
125375 :
125376 0 : return found;
125377 : }
125378 : /* #line 125379 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125379 :
125380 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
125381 :
125382 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125383 :
125384 : /* #line 125385 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125385 :
125386 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125387 :
125388 : void
125389 0 : SgTemplateTypedefSymbol::checkDataMemberPointersIfInMemoryPool()
125390 : {
125391 : // ------------ checking pointers of SgTemplateTypedefSymbol -------------------
125392 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
125393 :
125394 0 : if ( p_declaration != NULL )
125395 : {
125396 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125397 : {
125398 0 : if ( p_declaration->isInMemoryPool() == false )
125399 : {
125400 0 : std::cout << "SgTemplateTypedefSymbol :: ";
125401 0 : std::cout << " p_declaration is not in memory pool of ";
125402 0 : std::cout << p_declaration->class_name() << std::endl;
125403 : }
125404 : }
125405 : else
125406 : {
125407 0 : std::cout << "SgTemplateTypedefSymbol :: " << std::flush;
125408 0 : std::cout << "SgTypedefDeclaration* p_declaration = " << p_declaration << " --> " << std::flush;
125409 0 : std::cout << " not valid " << std::endl;
125410 : }
125411 : }
125412 :
125413 0 : if ( p_parent != NULL )
125414 : {
125415 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125416 : {
125417 0 : if ( p_parent->isInMemoryPool() == false )
125418 : {
125419 0 : std::cout << "SgTemplateTypedefSymbol :: ";
125420 0 : std::cout << " p_parent is not in memory pool of ";
125421 0 : std::cout << p_parent->class_name() << std::endl;
125422 : }
125423 : }
125424 : else
125425 : {
125426 0 : std::cout << "SgTemplateTypedefSymbol :: " << std::flush;
125427 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
125428 0 : std::cout << " not valid " << std::endl;
125429 : }
125430 : }
125431 :
125432 :
125433 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125434 :
125435 0 : }
125436 :
125437 :
125438 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
125439 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
125440 : bool
125441 0 : SgTemplateTypedefSymbol::isInMemoryPool ()
125442 : {
125443 0 : typedef unsigned char* TestType;
125444 :
125445 0 : bool found = false;
125446 :
125447 0 : ROSE_ASSERT(this != NULL);
125448 :
125449 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
125450 :
125451 0 : TestType tested = (TestType) ( this ) ;
125452 :
125453 0 : std::vector < unsigned char* > :: const_iterator block = SgTemplateTypedefSymbol::pools.begin();
125454 :
125455 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
125456 : // while (found == false && block < Memory_Block_List.end())
125457 0 : while ( (found == false) && (block != SgTemplateTypedefSymbol::pools.end()) )
125458 : {
125459 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgTemplateTypedefSymbol::pool_size * sizeof(SgTemplateTypedefSymbol) ) ) ;
125460 0 : ++block;
125461 : }
125462 :
125463 : // Special handling for static data
125464 :
125465 :
125466 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
125467 0 : ROSE_ASSERT(found == true);
125468 :
125469 0 : return found;
125470 : }
125471 : /* #line 125472 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125472 :
125473 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
125474 :
125475 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125476 :
125477 : /* #line 125478 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125478 :
125479 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125480 :
125481 : void
125482 0 : SgLabelSymbol::checkDataMemberPointersIfInMemoryPool()
125483 : {
125484 : // ------------ checking pointers of SgLabelSymbol -------------------
125485 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
125486 :
125487 0 : if ( p_declaration != NULL )
125488 : {
125489 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125490 : {
125491 0 : if ( p_declaration->isInMemoryPool() == false )
125492 : {
125493 0 : std::cout << "SgLabelSymbol :: ";
125494 0 : std::cout << " p_declaration is not in memory pool of ";
125495 0 : std::cout << p_declaration->class_name() << std::endl;
125496 : }
125497 : }
125498 : else
125499 : {
125500 0 : std::cout << "SgLabelSymbol :: " << std::flush;
125501 0 : std::cout << "SgLabelStatement* p_declaration = " << p_declaration << " --> " << std::flush;
125502 0 : std::cout << " not valid " << std::endl;
125503 : }
125504 : }
125505 :
125506 0 : if ( p_fortran_statement != NULL )
125507 : {
125508 0 : if ( p_fortran_statement->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125509 : {
125510 0 : if ( p_fortran_statement->isInMemoryPool() == false )
125511 : {
125512 0 : std::cout << "SgLabelSymbol :: ";
125513 0 : std::cout << " p_fortran_statement is not in memory pool of ";
125514 0 : std::cout << p_fortran_statement->class_name() << std::endl;
125515 : }
125516 : }
125517 : else
125518 : {
125519 0 : std::cout << "SgLabelSymbol :: " << std::flush;
125520 0 : std::cout << "SgStatement* p_fortran_statement = " << p_fortran_statement << " --> " << std::flush;
125521 0 : std::cout << " not valid " << std::endl;
125522 : }
125523 : }
125524 :
125525 0 : if ( p_fortran_alternate_return_parameter != NULL )
125526 : {
125527 0 : if ( p_fortran_alternate_return_parameter->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125528 : {
125529 0 : if ( p_fortran_alternate_return_parameter->isInMemoryPool() == false )
125530 : {
125531 0 : std::cout << "SgLabelSymbol :: ";
125532 0 : std::cout << " p_fortran_alternate_return_parameter is not in memory pool of ";
125533 0 : std::cout << p_fortran_alternate_return_parameter->class_name() << std::endl;
125534 : }
125535 : }
125536 : else
125537 : {
125538 0 : std::cout << "SgLabelSymbol :: " << std::flush;
125539 0 : std::cout << "SgInitializedName* p_fortran_alternate_return_parameter = " << p_fortran_alternate_return_parameter << " --> " << std::flush;
125540 0 : std::cout << " not valid " << std::endl;
125541 : }
125542 : }
125543 :
125544 0 : if ( p_parent != NULL )
125545 : {
125546 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125547 : {
125548 0 : if ( p_parent->isInMemoryPool() == false )
125549 : {
125550 0 : std::cout << "SgLabelSymbol :: ";
125551 0 : std::cout << " p_parent is not in memory pool of ";
125552 0 : std::cout << p_parent->class_name() << std::endl;
125553 : }
125554 : }
125555 : else
125556 : {
125557 0 : std::cout << "SgLabelSymbol :: " << std::flush;
125558 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
125559 0 : std::cout << " not valid " << std::endl;
125560 : }
125561 : }
125562 :
125563 :
125564 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125565 :
125566 0 : }
125567 :
125568 :
125569 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
125570 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
125571 : bool
125572 0 : SgLabelSymbol::isInMemoryPool ()
125573 : {
125574 0 : typedef unsigned char* TestType;
125575 :
125576 0 : bool found = false;
125577 :
125578 0 : ROSE_ASSERT(this != NULL);
125579 :
125580 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
125581 :
125582 0 : TestType tested = (TestType) ( this ) ;
125583 :
125584 0 : std::vector < unsigned char* > :: const_iterator block = SgLabelSymbol::pools.begin();
125585 :
125586 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
125587 : // while (found == false && block < Memory_Block_List.end())
125588 0 : while ( (found == false) && (block != SgLabelSymbol::pools.end()) )
125589 : {
125590 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgLabelSymbol::pool_size * sizeof(SgLabelSymbol) ) ) ;
125591 0 : ++block;
125592 : }
125593 :
125594 : // Special handling for static data
125595 :
125596 :
125597 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
125598 0 : ROSE_ASSERT(found == true);
125599 :
125600 0 : return found;
125601 : }
125602 : /* #line 125603 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125603 :
125604 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
125605 :
125606 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125607 :
125608 : /* #line 125609 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125609 :
125610 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125611 :
125612 : void
125613 0 : SgDefaultSymbol::checkDataMemberPointersIfInMemoryPool()
125614 : {
125615 : // ------------ checking pointers of SgDefaultSymbol -------------------
125616 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
125617 :
125618 0 : if ( p_type != NULL )
125619 : {
125620 0 : if ( p_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125621 : {
125622 0 : if ( p_type->isInMemoryPool() == false )
125623 : {
125624 0 : std::cout << "SgDefaultSymbol :: ";
125625 0 : std::cout << " p_type is not in memory pool of ";
125626 0 : std::cout << p_type->class_name() << std::endl;
125627 : }
125628 : }
125629 : else
125630 : {
125631 0 : std::cout << "SgDefaultSymbol :: " << std::flush;
125632 0 : std::cout << "SgType* p_type = " << p_type << " --> " << std::flush;
125633 0 : std::cout << " not valid " << std::endl;
125634 : }
125635 : }
125636 :
125637 0 : if ( p_parent != NULL )
125638 : {
125639 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125640 : {
125641 0 : if ( p_parent->isInMemoryPool() == false )
125642 : {
125643 0 : std::cout << "SgDefaultSymbol :: ";
125644 0 : std::cout << " p_parent is not in memory pool of ";
125645 0 : std::cout << p_parent->class_name() << std::endl;
125646 : }
125647 : }
125648 : else
125649 : {
125650 0 : std::cout << "SgDefaultSymbol :: " << std::flush;
125651 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
125652 0 : std::cout << " not valid " << std::endl;
125653 : }
125654 : }
125655 :
125656 :
125657 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125658 :
125659 0 : }
125660 :
125661 :
125662 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
125663 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
125664 : bool
125665 0 : SgDefaultSymbol::isInMemoryPool ()
125666 : {
125667 0 : typedef unsigned char* TestType;
125668 :
125669 0 : bool found = false;
125670 :
125671 0 : ROSE_ASSERT(this != NULL);
125672 :
125673 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
125674 :
125675 0 : TestType tested = (TestType) ( this ) ;
125676 :
125677 0 : std::vector < unsigned char* > :: const_iterator block = SgDefaultSymbol::pools.begin();
125678 :
125679 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
125680 : // while (found == false && block < Memory_Block_List.end())
125681 0 : while ( (found == false) && (block != SgDefaultSymbol::pools.end()) )
125682 : {
125683 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgDefaultSymbol::pool_size * sizeof(SgDefaultSymbol) ) ) ;
125684 0 : ++block;
125685 : }
125686 :
125687 : // Special handling for static data
125688 :
125689 :
125690 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
125691 0 : ROSE_ASSERT(found == true);
125692 :
125693 0 : return found;
125694 : }
125695 : /* #line 125696 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125696 :
125697 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
125698 :
125699 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125700 :
125701 : /* #line 125702 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125702 :
125703 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125704 :
125705 : void
125706 0 : SgNamespaceSymbol::checkDataMemberPointersIfInMemoryPool()
125707 : {
125708 : // ------------ checking pointers of SgNamespaceSymbol -------------------
125709 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
125710 :
125711 0 : if ( p_declaration != NULL )
125712 : {
125713 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125714 : {
125715 0 : if ( p_declaration->isInMemoryPool() == false )
125716 : {
125717 0 : std::cout << "SgNamespaceSymbol :: ";
125718 0 : std::cout << " p_declaration is not in memory pool of ";
125719 0 : std::cout << p_declaration->class_name() << std::endl;
125720 : }
125721 : }
125722 : else
125723 : {
125724 0 : std::cout << "SgNamespaceSymbol :: " << std::flush;
125725 0 : std::cout << "SgNamespaceDeclarationStatement* p_declaration = " << p_declaration << " --> " << std::flush;
125726 0 : std::cout << " not valid " << std::endl;
125727 : }
125728 : }
125729 :
125730 0 : if ( p_aliasDeclaration != NULL )
125731 : {
125732 0 : if ( p_aliasDeclaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125733 : {
125734 0 : if ( p_aliasDeclaration->isInMemoryPool() == false )
125735 : {
125736 0 : std::cout << "SgNamespaceSymbol :: ";
125737 0 : std::cout << " p_aliasDeclaration is not in memory pool of ";
125738 0 : std::cout << p_aliasDeclaration->class_name() << std::endl;
125739 : }
125740 : }
125741 : else
125742 : {
125743 0 : std::cout << "SgNamespaceSymbol :: " << std::flush;
125744 0 : std::cout << "SgNamespaceAliasDeclarationStatement* p_aliasDeclaration = " << p_aliasDeclaration << " --> " << std::flush;
125745 0 : std::cout << " not valid " << std::endl;
125746 : }
125747 : }
125748 :
125749 0 : if ( p_parent != NULL )
125750 : {
125751 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125752 : {
125753 0 : if ( p_parent->isInMemoryPool() == false )
125754 : {
125755 0 : std::cout << "SgNamespaceSymbol :: ";
125756 0 : std::cout << " p_parent is not in memory pool of ";
125757 0 : std::cout << p_parent->class_name() << std::endl;
125758 : }
125759 : }
125760 : else
125761 : {
125762 0 : std::cout << "SgNamespaceSymbol :: " << std::flush;
125763 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
125764 0 : std::cout << " not valid " << std::endl;
125765 : }
125766 : }
125767 :
125768 :
125769 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125770 :
125771 0 : }
125772 :
125773 :
125774 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
125775 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
125776 : bool
125777 0 : SgNamespaceSymbol::isInMemoryPool ()
125778 : {
125779 0 : typedef unsigned char* TestType;
125780 :
125781 0 : bool found = false;
125782 :
125783 0 : ROSE_ASSERT(this != NULL);
125784 :
125785 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
125786 :
125787 0 : TestType tested = (TestType) ( this ) ;
125788 :
125789 0 : std::vector < unsigned char* > :: const_iterator block = SgNamespaceSymbol::pools.begin();
125790 :
125791 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
125792 : // while (found == false && block < Memory_Block_List.end())
125793 0 : while ( (found == false) && (block != SgNamespaceSymbol::pools.end()) )
125794 : {
125795 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgNamespaceSymbol::pool_size * sizeof(SgNamespaceSymbol) ) ) ;
125796 0 : ++block;
125797 : }
125798 :
125799 : // Special handling for static data
125800 :
125801 :
125802 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
125803 0 : ROSE_ASSERT(found == true);
125804 :
125805 0 : return found;
125806 : }
125807 : /* #line 125808 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125808 :
125809 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
125810 :
125811 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125812 :
125813 : /* #line 125814 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125814 :
125815 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125816 :
125817 : void
125818 0 : SgIntrinsicSymbol::checkDataMemberPointersIfInMemoryPool()
125819 : {
125820 : // ------------ checking pointers of SgIntrinsicSymbol -------------------
125821 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
125822 :
125823 0 : if ( p_declaration != NULL )
125824 : {
125825 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125826 : {
125827 0 : if ( p_declaration->isInMemoryPool() == false )
125828 : {
125829 0 : std::cout << "SgIntrinsicSymbol :: ";
125830 0 : std::cout << " p_declaration is not in memory pool of ";
125831 0 : std::cout << p_declaration->class_name() << std::endl;
125832 : }
125833 : }
125834 : else
125835 : {
125836 0 : std::cout << "SgIntrinsicSymbol :: " << std::flush;
125837 0 : std::cout << "SgInitializedName* p_declaration = " << p_declaration << " --> " << std::flush;
125838 0 : std::cout << " not valid " << std::endl;
125839 : }
125840 : }
125841 :
125842 0 : if ( p_parent != NULL )
125843 : {
125844 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125845 : {
125846 0 : if ( p_parent->isInMemoryPool() == false )
125847 : {
125848 0 : std::cout << "SgIntrinsicSymbol :: ";
125849 0 : std::cout << " p_parent is not in memory pool of ";
125850 0 : std::cout << p_parent->class_name() << std::endl;
125851 : }
125852 : }
125853 : else
125854 : {
125855 0 : std::cout << "SgIntrinsicSymbol :: " << std::flush;
125856 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
125857 0 : std::cout << " not valid " << std::endl;
125858 : }
125859 : }
125860 :
125861 :
125862 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125863 :
125864 0 : }
125865 :
125866 :
125867 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
125868 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
125869 : bool
125870 0 : SgIntrinsicSymbol::isInMemoryPool ()
125871 : {
125872 0 : typedef unsigned char* TestType;
125873 :
125874 0 : bool found = false;
125875 :
125876 0 : ROSE_ASSERT(this != NULL);
125877 :
125878 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
125879 :
125880 0 : TestType tested = (TestType) ( this ) ;
125881 :
125882 0 : std::vector < unsigned char* > :: const_iterator block = SgIntrinsicSymbol::pools.begin();
125883 :
125884 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
125885 : // while (found == false && block < Memory_Block_List.end())
125886 0 : while ( (found == false) && (block != SgIntrinsicSymbol::pools.end()) )
125887 : {
125888 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgIntrinsicSymbol::pool_size * sizeof(SgIntrinsicSymbol) ) ) ;
125889 0 : ++block;
125890 : }
125891 :
125892 : // Special handling for static data
125893 :
125894 :
125895 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
125896 0 : ROSE_ASSERT(found == true);
125897 :
125898 0 : return found;
125899 : }
125900 : /* #line 125901 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125901 :
125902 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
125903 :
125904 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125905 :
125906 : /* #line 125907 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125907 :
125908 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125909 :
125910 : void
125911 0 : SgModuleSymbol::checkDataMemberPointersIfInMemoryPool()
125912 : {
125913 : // ------------ checking pointers of SgModuleSymbol -------------------
125914 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
125915 :
125916 0 : if ( p_declaration != NULL )
125917 : {
125918 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125919 : {
125920 0 : if ( p_declaration->isInMemoryPool() == false )
125921 : {
125922 0 : std::cout << "SgModuleSymbol :: ";
125923 0 : std::cout << " p_declaration is not in memory pool of ";
125924 0 : std::cout << p_declaration->class_name() << std::endl;
125925 : }
125926 : }
125927 : else
125928 : {
125929 0 : std::cout << "SgModuleSymbol :: " << std::flush;
125930 0 : std::cout << "SgModuleStatement* p_declaration = " << p_declaration << " --> " << std::flush;
125931 0 : std::cout << " not valid " << std::endl;
125932 : }
125933 : }
125934 :
125935 0 : if ( p_parent != NULL )
125936 : {
125937 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
125938 : {
125939 0 : if ( p_parent->isInMemoryPool() == false )
125940 : {
125941 0 : std::cout << "SgModuleSymbol :: ";
125942 0 : std::cout << " p_parent is not in memory pool of ";
125943 0 : std::cout << p_parent->class_name() << std::endl;
125944 : }
125945 : }
125946 : else
125947 : {
125948 0 : std::cout << "SgModuleSymbol :: " << std::flush;
125949 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
125950 0 : std::cout << " not valid " << std::endl;
125951 : }
125952 : }
125953 :
125954 :
125955 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125956 :
125957 0 : }
125958 :
125959 :
125960 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
125961 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
125962 : bool
125963 0 : SgModuleSymbol::isInMemoryPool ()
125964 : {
125965 0 : typedef unsigned char* TestType;
125966 :
125967 0 : bool found = false;
125968 :
125969 0 : ROSE_ASSERT(this != NULL);
125970 :
125971 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
125972 :
125973 0 : TestType tested = (TestType) ( this ) ;
125974 :
125975 0 : std::vector < unsigned char* > :: const_iterator block = SgModuleSymbol::pools.begin();
125976 :
125977 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
125978 : // while (found == false && block < Memory_Block_List.end())
125979 0 : while ( (found == false) && (block != SgModuleSymbol::pools.end()) )
125980 : {
125981 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgModuleSymbol::pool_size * sizeof(SgModuleSymbol) ) ) ;
125982 0 : ++block;
125983 : }
125984 :
125985 : // Special handling for static data
125986 :
125987 :
125988 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
125989 0 : ROSE_ASSERT(found == true);
125990 :
125991 0 : return found;
125992 : }
125993 : /* #line 125994 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
125994 :
125995 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
125996 :
125997 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
125998 :
125999 : /* #line 126000 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
126000 :
126001 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
126002 :
126003 : void
126004 0 : SgInterfaceSymbol::checkDataMemberPointersIfInMemoryPool()
126005 : {
126006 : // ------------ checking pointers of SgInterfaceSymbol -------------------
126007 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
126008 :
126009 0 : if ( p_declaration != NULL )
126010 : {
126011 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
126012 : {
126013 0 : if ( p_declaration->isInMemoryPool() == false )
126014 : {
126015 0 : std::cout << "SgInterfaceSymbol :: ";
126016 0 : std::cout << " p_declaration is not in memory pool of ";
126017 0 : std::cout << p_declaration->class_name() << std::endl;
126018 : }
126019 : }
126020 : else
126021 : {
126022 0 : std::cout << "SgInterfaceSymbol :: " << std::flush;
126023 0 : std::cout << "SgInterfaceStatement* p_declaration = " << p_declaration << " --> " << std::flush;
126024 0 : std::cout << " not valid " << std::endl;
126025 : }
126026 : }
126027 :
126028 0 : if ( p_parent != NULL )
126029 : {
126030 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
126031 : {
126032 0 : if ( p_parent->isInMemoryPool() == false )
126033 : {
126034 0 : std::cout << "SgInterfaceSymbol :: ";
126035 0 : std::cout << " p_parent is not in memory pool of ";
126036 0 : std::cout << p_parent->class_name() << std::endl;
126037 : }
126038 : }
126039 : else
126040 : {
126041 0 : std::cout << "SgInterfaceSymbol :: " << std::flush;
126042 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
126043 0 : std::cout << " not valid " << std::endl;
126044 : }
126045 : }
126046 :
126047 :
126048 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
126049 :
126050 0 : }
126051 :
126052 :
126053 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
126054 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
126055 : bool
126056 0 : SgInterfaceSymbol::isInMemoryPool ()
126057 : {
126058 0 : typedef unsigned char* TestType;
126059 :
126060 0 : bool found = false;
126061 :
126062 0 : ROSE_ASSERT(this != NULL);
126063 :
126064 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
126065 :
126066 0 : TestType tested = (TestType) ( this ) ;
126067 :
126068 0 : std::vector < unsigned char* > :: const_iterator block = SgInterfaceSymbol::pools.begin();
126069 :
126070 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
126071 : // while (found == false && block < Memory_Block_List.end())
126072 0 : while ( (found == false) && (block != SgInterfaceSymbol::pools.end()) )
126073 : {
126074 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgInterfaceSymbol::pool_size * sizeof(SgInterfaceSymbol) ) ) ;
126075 0 : ++block;
126076 : }
126077 :
126078 : // Special handling for static data
126079 :
126080 :
126081 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
126082 0 : ROSE_ASSERT(found == true);
126083 :
126084 0 : return found;
126085 : }
126086 : /* #line 126087 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
126087 :
126088 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
126089 :
126090 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
126091 :
126092 : /* #line 126093 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
126093 :
126094 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
126095 :
126096 : void
126097 0 : SgCommonSymbol::checkDataMemberPointersIfInMemoryPool()
126098 : {
126099 : // ------------ checking pointers of SgCommonSymbol -------------------
126100 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
126101 :
126102 0 : if ( p_declaration != NULL )
126103 : {
126104 0 : if ( p_declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
126105 : {
126106 0 : if ( p_declaration->isInMemoryPool() == false )
126107 : {
126108 0 : std::cout << "SgCommonSymbol :: ";
126109 0 : std::cout << " p_declaration is not in memory pool of ";
126110 0 : std::cout << p_declaration->class_name() << std::endl;
126111 : }
126112 : }
126113 : else
126114 : {
126115 0 : std::cout << "SgCommonSymbol :: " << std::flush;
126116 0 : std::cout << "SgInitializedName* p_declaration = " << p_declaration << " --> " << std::flush;
126117 0 : std::cout << " not valid " << std::endl;
126118 : }
126119 : }
126120 :
126121 0 : if ( p_parent != NULL )
126122 : {
126123 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
126124 : {
126125 0 : if ( p_parent->isInMemoryPool() == false )
126126 : {
126127 0 : std::cout << "SgCommonSymbol :: ";
126128 0 : std::cout << " p_parent is not in memory pool of ";
126129 0 : std::cout << p_parent->class_name() << std::endl;
126130 : }
126131 : }
126132 : else
126133 : {
126134 0 : std::cout << "SgCommonSymbol :: " << std::flush;
126135 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
126136 0 : std::cout << " not valid " << std::endl;
126137 : }
126138 : }
126139 :
126140 :
126141 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
126142 :
126143 0 : }
126144 :
126145 :
126146 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
126147 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
126148 : bool
126149 0 : SgCommonSymbol::isInMemoryPool ()
126150 : {
126151 0 : typedef unsigned char* TestType;
126152 :
126153 0 : bool found = false;
126154 :
126155 0 : ROSE_ASSERT(this != NULL);
126156 :
126157 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
126158 :
126159 0 : TestType tested = (TestType) ( this ) ;
126160 :
126161 0 : std::vector < unsigned char* > :: const_iterator block = SgCommonSymbol::pools.begin();
126162 :
126163 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
126164 : // while (found == false && block < Memory_Block_List.end())
126165 0 : while ( (found == false) && (block != SgCommonSymbol::pools.end()) )
126166 : {
126167 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgCommonSymbol::pool_size * sizeof(SgCommonSymbol) ) ) ;
126168 0 : ++block;
126169 : }
126170 :
126171 : // Special handling for static data
126172 :
126173 :
126174 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
126175 0 : ROSE_ASSERT(found == true);
126176 :
126177 0 : return found;
126178 : }
126179 : /* #line 126180 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
126180 :
126181 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
126182 :
126183 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
126184 :
126185 : /* #line 126186 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
126186 :
126187 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
126188 :
126189 : void
126190 0 : SgAliasSymbol::checkDataMemberPointersIfInMemoryPool()
126191 : {
126192 : // ------------ checking pointers of SgAliasSymbol -------------------
126193 0 : ROSE_ASSERT ( p_freepointer == AST_FileIO::IS_VALID_POINTER() );
126194 :
126195 0 : if ( p_alias != NULL )
126196 : {
126197 0 : if ( p_alias->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
126198 : {
126199 0 : if ( p_alias->isInMemoryPool() == false )
126200 : {
126201 0 : std::cout << "SgAliasSymbol :: ";
126202 0 : std::cout << " p_alias is not in memory pool of ";
126203 0 : std::cout << p_alias->class_name() << std::endl;
126204 : }
126205 : }
126206 : else
126207 : {
126208 0 : std::cout << "SgAliasSymbol :: " << std::flush;
126209 0 : std::cout << "SgSymbol* p_alias = " << p_alias << " --> " << std::flush;
126210 0 : std::cout << " not valid " << std::endl;
126211 : }
126212 : }
126213 :
126214 0 : SgNodePtrList::iterator i_causal_nodes = p_causal_nodes.begin() ;
126215 0 : for ( ; i_causal_nodes != p_causal_nodes.end(); ++i_causal_nodes )
126216 : {
126217 0 : if ( (*i_causal_nodes) != NULL )
126218 : {
126219 0 : if ( (*i_causal_nodes)->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
126220 : {
126221 0 : if ( (*i_causal_nodes)->isInMemoryPool() == false )
126222 : {
126223 0 : std::cout << "SgAliasSymbol :: ";
126224 0 : std::cout << " p_causal_nodes ( list of poitners to IR nodes ), entry is not in memory pool of ";
126225 0 : std::cout << (*i_causal_nodes)->class_name() << std::endl;
126226 : }
126227 : }
126228 : else
126229 : {
126230 0 : std::cout << "SgAliasSymbol :: " << std::flush;
126231 0 : std::cout << "SgNodePtrList p_causal_nodes --> " << std::flush;
126232 0 : std::cout << " entry not valid " << std::endl;
126233 : }
126234 : }
126235 : else
126236 : {
126237 0 : std::cout << "SgNodePtrList p_causal_nodes --> NULL " << std::endl;
126238 : }
126239 : }
126240 :
126241 0 : if ( p_parent != NULL )
126242 : {
126243 0 : if ( p_parent->get_freepointer() == AST_FileIO::IS_VALID_POINTER() )
126244 : {
126245 0 : if ( p_parent->isInMemoryPool() == false )
126246 : {
126247 0 : std::cout << "SgAliasSymbol :: ";
126248 0 : std::cout << " p_parent is not in memory pool of ";
126249 0 : std::cout << p_parent->class_name() << std::endl;
126250 : }
126251 : }
126252 : else
126253 : {
126254 0 : std::cout << "SgAliasSymbol :: " << std::flush;
126255 0 : std::cout << "SgNode* p_parent = " << p_parent << " --> " << std::flush;
126256 0 : std::cout << " not valid " << std::endl;
126257 : }
126258 : }
126259 :
126260 :
126261 : /* #line 9 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
126262 :
126263 0 : }
126264 :
126265 :
126266 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarTestPointerForContainmentInMemoryPool.macro" */
126267 : // DQ And JH (1/17/2006): Example of code to be produced by ROSETTA
126268 : bool
126269 0 : SgAliasSymbol::isInMemoryPool ()
126270 : {
126271 0 : typedef unsigned char* TestType;
126272 :
126273 0 : bool found = false;
126274 :
126275 0 : ROSE_ASSERT(this != NULL);
126276 :
126277 0 : ROSE_ASSERT(p_freepointer == AST_FileIO::IS_VALID_POINTER());
126278 :
126279 0 : TestType tested = (TestType) ( this ) ;
126280 :
126281 0 : std::vector < unsigned char* > :: const_iterator block = SgAliasSymbol::pools.begin();
126282 :
126283 : // DQ (1/17/2006): Modified conditional test to use "!=" instead of "<"
126284 : // while (found == false && block < Memory_Block_List.end())
126285 0 : while ( (found == false) && (block != SgAliasSymbol::pools.end()) )
126286 : {
126287 0 : found = ( ( (*block) <= tested ) && ( tested < (*block) + SgAliasSymbol::pool_size * sizeof(SgAliasSymbol) ) ) ;
126288 0 : ++block;
126289 : }
126290 :
126291 : // Special handling for static data
126292 :
126293 :
126294 : // DQ (1/17/2006): Make it an error to not find a pointers value somewhere in the memory pools
126295 0 : ROSE_ASSERT(found == true);
126296 :
126297 0 : return found;
126298 : }
126299 : /* #line 126300 "../../../src/frontend/SageIII//Cxx_GrammarCheckingIfDataMembersAreInMemoryPool.C" */
126300 :
126301 : /* #line 12 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro after subst for $ASSOCIATED_MEMORY_POOL_TEST" */
126302 :
126303 : /* #line 13 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarCheckingIfDataMembersAreInMemoryPool.macro" */
126304 :
126305 :
|
