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 : // Simplify code by using std namespace (never put into header files since it effects users)
23 : using namespace std;
24 :
25 : vector<SgNode*>
26 0 : SgNode::get_traversalSuccessorContainer() {
27 0 : vector<SgNode*> traversalSuccessorContainer;
28 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
29 0 : << "static: SgNode" << endl << "dynamic: " << this->sage_class_name() << endl;
30 0 : cerr << "Aborting ..." << endl;
31 0 : ROSE_ASSERT(false);
32 : return traversalSuccessorContainer;
33 : }
34 :
35 : vector<string>
36 0 : SgNode::get_traversalSuccessorNamesContainer() {
37 0 : vector<string> traversalSuccessorContainer;
38 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
39 0 : << "static: SgNode" << endl << "dynamic: " << this->sage_class_name() << endl;
40 0 : cerr << "Aborting ..." << endl;
41 0 : ROSE_ASSERT(false);
42 : return traversalSuccessorContainer;
43 : }
44 :
45 : size_t
46 0 : SgNode::get_numberOfTraversalSuccessors() {
47 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
48 0 : << "static: SgNode" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
49 0 : cerr << "Aborting ..." << endl;
50 0 : ROSE_ASSERT(false);
51 : return 42;
52 : }
53 :
54 : SgNode*
55 0 : SgNode::get_traversalSuccessorByIndex(size_t) {
56 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
57 0 : << "static: SgNode" << endl << "dynamic: " << this->sage_class_name() << endl;
58 0 : cerr << "Aborting ..." << endl;
59 0 : ROSE_ASSERT(false);
60 : return NULL;
61 : }
62 :
63 : size_t
64 0 : SgNode::get_childIndex(SgNode *) {
65 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
66 0 : << "static: SgNode" << endl << "dynamic: " << this->sage_class_name() << endl;
67 0 : cerr << "Aborting ..." << endl;
68 0 : ROSE_ASSERT(false);
69 : return 42;
70 : }
71 :
72 : vector<SgNode*>
73 0 : SgSupport::get_traversalSuccessorContainer() {
74 0 : vector<SgNode*> traversalSuccessorContainer;
75 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
76 0 : << "static: SgSupport" << endl << "dynamic: " << this->sage_class_name() << endl;
77 0 : cerr << "Aborting ..." << endl;
78 0 : ROSE_ASSERT(false);
79 : return traversalSuccessorContainer;
80 : }
81 :
82 : vector<string>
83 0 : SgSupport::get_traversalSuccessorNamesContainer() {
84 0 : vector<string> traversalSuccessorContainer;
85 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
86 0 : << "static: SgSupport" << endl << "dynamic: " << this->sage_class_name() << endl;
87 0 : cerr << "Aborting ..." << endl;
88 0 : ROSE_ASSERT(false);
89 : return traversalSuccessorContainer;
90 : }
91 :
92 : size_t
93 0 : SgSupport::get_numberOfTraversalSuccessors() {
94 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
95 0 : << "static: SgSupport" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
96 0 : cerr << "Aborting ..." << endl;
97 0 : ROSE_ASSERT(false);
98 : return 42;
99 : }
100 :
101 : SgNode*
102 0 : SgSupport::get_traversalSuccessorByIndex(size_t) {
103 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
104 0 : << "static: SgSupport" << endl << "dynamic: " << this->sage_class_name() << endl;
105 0 : cerr << "Aborting ..." << endl;
106 0 : ROSE_ASSERT(false);
107 : return NULL;
108 : }
109 :
110 : size_t
111 0 : SgSupport::get_childIndex(SgNode *) {
112 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
113 0 : << "static: SgSupport" << endl << "dynamic: " << this->sage_class_name() << endl;
114 0 : cerr << "Aborting ..." << endl;
115 0 : ROSE_ASSERT(false);
116 : return 42;
117 : }
118 :
119 : vector<SgNode*>
120 0 : SgModifier::get_traversalSuccessorContainer() {
121 0 : vector<SgNode*> traversalSuccessorContainer;
122 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
123 0 : << "static: SgModifier" << endl << "dynamic: " << this->sage_class_name() << endl;
124 0 : cerr << "Aborting ..." << endl;
125 0 : ROSE_ASSERT(false);
126 : return traversalSuccessorContainer;
127 : }
128 :
129 : vector<string>
130 0 : SgModifier::get_traversalSuccessorNamesContainer() {
131 0 : vector<string> traversalSuccessorContainer;
132 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
133 0 : << "static: SgModifier" << endl << "dynamic: " << this->sage_class_name() << endl;
134 0 : cerr << "Aborting ..." << endl;
135 0 : ROSE_ASSERT(false);
136 : return traversalSuccessorContainer;
137 : }
138 :
139 : size_t
140 0 : SgModifier::get_numberOfTraversalSuccessors() {
141 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
142 0 : << "static: SgModifier" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
143 0 : cerr << "Aborting ..." << endl;
144 0 : ROSE_ASSERT(false);
145 : return 42;
146 : }
147 :
148 : SgNode*
149 0 : SgModifier::get_traversalSuccessorByIndex(size_t) {
150 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
151 0 : << "static: SgModifier" << endl << "dynamic: " << this->sage_class_name() << endl;
152 0 : cerr << "Aborting ..." << endl;
153 0 : ROSE_ASSERT(false);
154 : return NULL;
155 : }
156 :
157 : size_t
158 0 : SgModifier::get_childIndex(SgNode *) {
159 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
160 0 : << "static: SgModifier" << endl << "dynamic: " << this->sage_class_name() << endl;
161 0 : cerr << "Aborting ..." << endl;
162 0 : ROSE_ASSERT(false);
163 : return 42;
164 : }
165 :
166 : vector<SgNode*>
167 0 : SgModifierNodes::get_traversalSuccessorContainer() {
168 0 : vector<SgNode*> traversalSuccessorContainer;
169 0 : return traversalSuccessorContainer;
170 : }
171 : vector<string>
172 0 : SgModifierNodes::get_traversalSuccessorNamesContainer() {
173 0 : vector<string> traversalSuccessorContainer;
174 0 : return traversalSuccessorContainer;
175 : }
176 : size_t
177 0 : SgModifierNodes::get_numberOfTraversalSuccessors() {
178 0 : return 0;
179 : }
180 : SgNode *
181 0 : SgModifierNodes::get_traversalSuccessorByIndex(size_t idx) {
182 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgModifierNodes" << " that has no successors!" << endl;
183 0 : ROSE_ASSERT(false);
184 : return NULL;
185 : }
186 : size_t
187 0 : SgModifierNodes::get_childIndex(SgNode *child) {
188 0 : cout << "error: get_childIndex called on node of type " << "SgModifierNodes" << " that has no successors!" << endl;
189 0 : ROSE_ASSERT(false);
190 : return 0;
191 : }
192 : vector<SgNode*>
193 0 : SgConstVolatileModifier::get_traversalSuccessorContainer() {
194 0 : vector<SgNode*> traversalSuccessorContainer;
195 0 : return traversalSuccessorContainer;
196 : }
197 : vector<string>
198 0 : SgConstVolatileModifier::get_traversalSuccessorNamesContainer() {
199 0 : vector<string> traversalSuccessorContainer;
200 0 : return traversalSuccessorContainer;
201 : }
202 : size_t
203 0 : SgConstVolatileModifier::get_numberOfTraversalSuccessors() {
204 0 : return 0;
205 : }
206 : SgNode *
207 0 : SgConstVolatileModifier::get_traversalSuccessorByIndex(size_t idx) {
208 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgConstVolatileModifier" << " that has no successors!" << endl;
209 0 : ROSE_ASSERT(false);
210 : return NULL;
211 : }
212 : size_t
213 0 : SgConstVolatileModifier::get_childIndex(SgNode *child) {
214 0 : cout << "error: get_childIndex called on node of type " << "SgConstVolatileModifier" << " that has no successors!" << endl;
215 0 : ROSE_ASSERT(false);
216 : return 0;
217 : }
218 : vector<SgNode*>
219 0 : SgStorageModifier::get_traversalSuccessorContainer() {
220 0 : vector<SgNode*> traversalSuccessorContainer;
221 0 : return traversalSuccessorContainer;
222 : }
223 : vector<string>
224 0 : SgStorageModifier::get_traversalSuccessorNamesContainer() {
225 0 : vector<string> traversalSuccessorContainer;
226 0 : return traversalSuccessorContainer;
227 : }
228 : size_t
229 0 : SgStorageModifier::get_numberOfTraversalSuccessors() {
230 0 : return 0;
231 : }
232 : SgNode *
233 0 : SgStorageModifier::get_traversalSuccessorByIndex(size_t idx) {
234 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgStorageModifier" << " that has no successors!" << endl;
235 0 : ROSE_ASSERT(false);
236 : return NULL;
237 : }
238 : size_t
239 0 : SgStorageModifier::get_childIndex(SgNode *child) {
240 0 : cout << "error: get_childIndex called on node of type " << "SgStorageModifier" << " that has no successors!" << endl;
241 0 : ROSE_ASSERT(false);
242 : return 0;
243 : }
244 : vector<SgNode*>
245 0 : SgAccessModifier::get_traversalSuccessorContainer() {
246 0 : vector<SgNode*> traversalSuccessorContainer;
247 0 : return traversalSuccessorContainer;
248 : }
249 : vector<string>
250 0 : SgAccessModifier::get_traversalSuccessorNamesContainer() {
251 0 : vector<string> traversalSuccessorContainer;
252 0 : return traversalSuccessorContainer;
253 : }
254 : size_t
255 0 : SgAccessModifier::get_numberOfTraversalSuccessors() {
256 0 : return 0;
257 : }
258 : SgNode *
259 0 : SgAccessModifier::get_traversalSuccessorByIndex(size_t idx) {
260 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgAccessModifier" << " that has no successors!" << endl;
261 0 : ROSE_ASSERT(false);
262 : return NULL;
263 : }
264 : size_t
265 0 : SgAccessModifier::get_childIndex(SgNode *child) {
266 0 : cout << "error: get_childIndex called on node of type " << "SgAccessModifier" << " that has no successors!" << endl;
267 0 : ROSE_ASSERT(false);
268 : return 0;
269 : }
270 : vector<SgNode*>
271 0 : SgFunctionModifier::get_traversalSuccessorContainer() {
272 0 : vector<SgNode*> traversalSuccessorContainer;
273 0 : return traversalSuccessorContainer;
274 : }
275 : vector<string>
276 0 : SgFunctionModifier::get_traversalSuccessorNamesContainer() {
277 0 : vector<string> traversalSuccessorContainer;
278 0 : return traversalSuccessorContainer;
279 : }
280 : size_t
281 0 : SgFunctionModifier::get_numberOfTraversalSuccessors() {
282 0 : return 0;
283 : }
284 : SgNode *
285 0 : SgFunctionModifier::get_traversalSuccessorByIndex(size_t idx) {
286 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgFunctionModifier" << " that has no successors!" << endl;
287 0 : ROSE_ASSERT(false);
288 : return NULL;
289 : }
290 : size_t
291 0 : SgFunctionModifier::get_childIndex(SgNode *child) {
292 0 : cout << "error: get_childIndex called on node of type " << "SgFunctionModifier" << " that has no successors!" << endl;
293 0 : ROSE_ASSERT(false);
294 : return 0;
295 : }
296 : vector<SgNode*>
297 0 : SgUPC_AccessModifier::get_traversalSuccessorContainer() {
298 0 : vector<SgNode*> traversalSuccessorContainer;
299 0 : return traversalSuccessorContainer;
300 : }
301 : vector<string>
302 0 : SgUPC_AccessModifier::get_traversalSuccessorNamesContainer() {
303 0 : vector<string> traversalSuccessorContainer;
304 0 : return traversalSuccessorContainer;
305 : }
306 : size_t
307 0 : SgUPC_AccessModifier::get_numberOfTraversalSuccessors() {
308 0 : return 0;
309 : }
310 : SgNode *
311 0 : SgUPC_AccessModifier::get_traversalSuccessorByIndex(size_t idx) {
312 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUPC_AccessModifier" << " that has no successors!" << endl;
313 0 : ROSE_ASSERT(false);
314 : return NULL;
315 : }
316 : size_t
317 0 : SgUPC_AccessModifier::get_childIndex(SgNode *child) {
318 0 : cout << "error: get_childIndex called on node of type " << "SgUPC_AccessModifier" << " that has no successors!" << endl;
319 0 : ROSE_ASSERT(false);
320 : return 0;
321 : }
322 : vector<SgNode*>
323 0 : SgSpecialFunctionModifier::get_traversalSuccessorContainer() {
324 0 : vector<SgNode*> traversalSuccessorContainer;
325 0 : return traversalSuccessorContainer;
326 : }
327 : vector<string>
328 0 : SgSpecialFunctionModifier::get_traversalSuccessorNamesContainer() {
329 0 : vector<string> traversalSuccessorContainer;
330 0 : return traversalSuccessorContainer;
331 : }
332 : size_t
333 0 : SgSpecialFunctionModifier::get_numberOfTraversalSuccessors() {
334 0 : return 0;
335 : }
336 : SgNode *
337 0 : SgSpecialFunctionModifier::get_traversalSuccessorByIndex(size_t idx) {
338 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgSpecialFunctionModifier" << " that has no successors!" << endl;
339 0 : ROSE_ASSERT(false);
340 : return NULL;
341 : }
342 : size_t
343 0 : SgSpecialFunctionModifier::get_childIndex(SgNode *child) {
344 0 : cout << "error: get_childIndex called on node of type " << "SgSpecialFunctionModifier" << " that has no successors!" << endl;
345 0 : ROSE_ASSERT(false);
346 : return 0;
347 : }
348 : vector<SgNode*>
349 0 : SgElaboratedTypeModifier::get_traversalSuccessorContainer() {
350 0 : vector<SgNode*> traversalSuccessorContainer;
351 0 : return traversalSuccessorContainer;
352 : }
353 : vector<string>
354 0 : SgElaboratedTypeModifier::get_traversalSuccessorNamesContainer() {
355 0 : vector<string> traversalSuccessorContainer;
356 0 : return traversalSuccessorContainer;
357 : }
358 : size_t
359 0 : SgElaboratedTypeModifier::get_numberOfTraversalSuccessors() {
360 0 : return 0;
361 : }
362 : SgNode *
363 0 : SgElaboratedTypeModifier::get_traversalSuccessorByIndex(size_t idx) {
364 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgElaboratedTypeModifier" << " that has no successors!" << endl;
365 0 : ROSE_ASSERT(false);
366 : return NULL;
367 : }
368 : size_t
369 0 : SgElaboratedTypeModifier::get_childIndex(SgNode *child) {
370 0 : cout << "error: get_childIndex called on node of type " << "SgElaboratedTypeModifier" << " that has no successors!" << endl;
371 0 : ROSE_ASSERT(false);
372 : return 0;
373 : }
374 : vector<SgNode*>
375 0 : SgLinkageModifier::get_traversalSuccessorContainer() {
376 0 : vector<SgNode*> traversalSuccessorContainer;
377 0 : return traversalSuccessorContainer;
378 : }
379 : vector<string>
380 0 : SgLinkageModifier::get_traversalSuccessorNamesContainer() {
381 0 : vector<string> traversalSuccessorContainer;
382 0 : return traversalSuccessorContainer;
383 : }
384 : size_t
385 0 : SgLinkageModifier::get_numberOfTraversalSuccessors() {
386 0 : return 0;
387 : }
388 : SgNode *
389 0 : SgLinkageModifier::get_traversalSuccessorByIndex(size_t idx) {
390 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgLinkageModifier" << " that has no successors!" << endl;
391 0 : ROSE_ASSERT(false);
392 : return NULL;
393 : }
394 : size_t
395 0 : SgLinkageModifier::get_childIndex(SgNode *child) {
396 0 : cout << "error: get_childIndex called on node of type " << "SgLinkageModifier" << " that has no successors!" << endl;
397 0 : ROSE_ASSERT(false);
398 : return 0;
399 : }
400 : vector<SgNode*>
401 0 : SgBaseClassModifier::get_traversalSuccessorContainer() {
402 0 : vector<SgNode*> traversalSuccessorContainer;
403 0 : return traversalSuccessorContainer;
404 : }
405 : vector<string>
406 0 : SgBaseClassModifier::get_traversalSuccessorNamesContainer() {
407 0 : vector<string> traversalSuccessorContainer;
408 0 : return traversalSuccessorContainer;
409 : }
410 : size_t
411 0 : SgBaseClassModifier::get_numberOfTraversalSuccessors() {
412 0 : return 0;
413 : }
414 : SgNode *
415 0 : SgBaseClassModifier::get_traversalSuccessorByIndex(size_t idx) {
416 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgBaseClassModifier" << " that has no successors!" << endl;
417 0 : ROSE_ASSERT(false);
418 : return NULL;
419 : }
420 : size_t
421 0 : SgBaseClassModifier::get_childIndex(SgNode *child) {
422 0 : cout << "error: get_childIndex called on node of type " << "SgBaseClassModifier" << " that has no successors!" << endl;
423 0 : ROSE_ASSERT(false);
424 : return 0;
425 : }
426 : vector<SgNode*>
427 0 : SgStructureModifier::get_traversalSuccessorContainer() {
428 0 : vector<SgNode*> traversalSuccessorContainer;
429 0 : return traversalSuccessorContainer;
430 : }
431 : vector<string>
432 0 : SgStructureModifier::get_traversalSuccessorNamesContainer() {
433 0 : vector<string> traversalSuccessorContainer;
434 0 : return traversalSuccessorContainer;
435 : }
436 : size_t
437 0 : SgStructureModifier::get_numberOfTraversalSuccessors() {
438 0 : return 0;
439 : }
440 : SgNode *
441 0 : SgStructureModifier::get_traversalSuccessorByIndex(size_t idx) {
442 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgStructureModifier" << " that has no successors!" << endl;
443 0 : ROSE_ASSERT(false);
444 : return NULL;
445 : }
446 : size_t
447 0 : SgStructureModifier::get_childIndex(SgNode *child) {
448 0 : cout << "error: get_childIndex called on node of type " << "SgStructureModifier" << " that has no successors!" << endl;
449 0 : ROSE_ASSERT(false);
450 : return 0;
451 : }
452 : vector<SgNode*>
453 0 : SgTypeModifier::get_traversalSuccessorContainer() {
454 0 : vector<SgNode*> traversalSuccessorContainer;
455 0 : return traversalSuccessorContainer;
456 : }
457 : vector<string>
458 0 : SgTypeModifier::get_traversalSuccessorNamesContainer() {
459 0 : vector<string> traversalSuccessorContainer;
460 0 : return traversalSuccessorContainer;
461 : }
462 : size_t
463 0 : SgTypeModifier::get_numberOfTraversalSuccessors() {
464 0 : return 0;
465 : }
466 : SgNode *
467 0 : SgTypeModifier::get_traversalSuccessorByIndex(size_t idx) {
468 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgTypeModifier" << " that has no successors!" << endl;
469 0 : ROSE_ASSERT(false);
470 : return NULL;
471 : }
472 : size_t
473 0 : SgTypeModifier::get_childIndex(SgNode *child) {
474 0 : cout << "error: get_childIndex called on node of type " << "SgTypeModifier" << " that has no successors!" << endl;
475 0 : ROSE_ASSERT(false);
476 : return 0;
477 : }
478 : vector<SgNode*>
479 0 : SgDeclarationModifier::get_traversalSuccessorContainer() {
480 0 : vector<SgNode*> traversalSuccessorContainer;
481 0 : return traversalSuccessorContainer;
482 : }
483 : vector<string>
484 0 : SgDeclarationModifier::get_traversalSuccessorNamesContainer() {
485 0 : vector<string> traversalSuccessorContainer;
486 0 : return traversalSuccessorContainer;
487 : }
488 : size_t
489 0 : SgDeclarationModifier::get_numberOfTraversalSuccessors() {
490 0 : return 0;
491 : }
492 : SgNode *
493 0 : SgDeclarationModifier::get_traversalSuccessorByIndex(size_t idx) {
494 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgDeclarationModifier" << " that has no successors!" << endl;
495 0 : ROSE_ASSERT(false);
496 : return NULL;
497 : }
498 : size_t
499 0 : SgDeclarationModifier::get_childIndex(SgNode *child) {
500 0 : cout << "error: get_childIndex called on node of type " << "SgDeclarationModifier" << " that has no successors!" << endl;
501 0 : ROSE_ASSERT(false);
502 : return 0;
503 : }
504 : vector<SgNode*>
505 0 : SgOpenclAccessModeModifier::get_traversalSuccessorContainer() {
506 0 : vector<SgNode*> traversalSuccessorContainer;
507 0 : return traversalSuccessorContainer;
508 : }
509 : vector<string>
510 0 : SgOpenclAccessModeModifier::get_traversalSuccessorNamesContainer() {
511 0 : vector<string> traversalSuccessorContainer;
512 0 : return traversalSuccessorContainer;
513 : }
514 : size_t
515 0 : SgOpenclAccessModeModifier::get_numberOfTraversalSuccessors() {
516 0 : return 0;
517 : }
518 : SgNode *
519 0 : SgOpenclAccessModeModifier::get_traversalSuccessorByIndex(size_t idx) {
520 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOpenclAccessModeModifier" << " that has no successors!" << endl;
521 0 : ROSE_ASSERT(false);
522 : return NULL;
523 : }
524 : size_t
525 0 : SgOpenclAccessModeModifier::get_childIndex(SgNode *child) {
526 0 : cout << "error: get_childIndex called on node of type " << "SgOpenclAccessModeModifier" << " that has no successors!" << endl;
527 0 : ROSE_ASSERT(false);
528 : return 0;
529 : }
530 : vector<SgNode*>
531 0 : SgName::get_traversalSuccessorContainer() {
532 0 : vector<SgNode*> traversalSuccessorContainer;
533 0 : return traversalSuccessorContainer;
534 : }
535 : vector<string>
536 0 : SgName::get_traversalSuccessorNamesContainer() {
537 0 : vector<string> traversalSuccessorContainer;
538 0 : return traversalSuccessorContainer;
539 : }
540 : size_t
541 0 : SgName::get_numberOfTraversalSuccessors() {
542 0 : return 0;
543 : }
544 : SgNode *
545 0 : SgName::get_traversalSuccessorByIndex(size_t idx) {
546 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgName" << " that has no successors!" << endl;
547 0 : ROSE_ASSERT(false);
548 : return NULL;
549 : }
550 : size_t
551 0 : SgName::get_childIndex(SgNode *child) {
552 0 : cout << "error: get_childIndex called on node of type " << "SgName" << " that has no successors!" << endl;
553 0 : ROSE_ASSERT(false);
554 : return 0;
555 : }
556 : vector<SgNode*>
557 0 : SgSymbolTable::get_traversalSuccessorContainer() {
558 0 : vector<SgNode*> traversalSuccessorContainer;
559 0 : return traversalSuccessorContainer;
560 : }
561 : vector<string>
562 0 : SgSymbolTable::get_traversalSuccessorNamesContainer() {
563 0 : vector<string> traversalSuccessorContainer;
564 0 : return traversalSuccessorContainer;
565 : }
566 : size_t
567 0 : SgSymbolTable::get_numberOfTraversalSuccessors() {
568 0 : return 0;
569 : }
570 : SgNode *
571 0 : SgSymbolTable::get_traversalSuccessorByIndex(size_t idx) {
572 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgSymbolTable" << " that has no successors!" << endl;
573 0 : ROSE_ASSERT(false);
574 : return NULL;
575 : }
576 : size_t
577 0 : SgSymbolTable::get_childIndex(SgNode *child) {
578 0 : cout << "error: get_childIndex called on node of type " << "SgSymbolTable" << " that has no successors!" << endl;
579 0 : ROSE_ASSERT(false);
580 : return 0;
581 : }
582 : vector<SgNode*>
583 0 : SgAttribute::get_traversalSuccessorContainer() {
584 0 : vector<SgNode*> traversalSuccessorContainer;
585 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
586 0 : << "static: SgAttribute" << endl << "dynamic: " << this->sage_class_name() << endl;
587 0 : cerr << "Aborting ..." << endl;
588 0 : ROSE_ASSERT(false);
589 : return traversalSuccessorContainer;
590 : }
591 :
592 : vector<string>
593 0 : SgAttribute::get_traversalSuccessorNamesContainer() {
594 0 : vector<string> traversalSuccessorContainer;
595 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
596 0 : << "static: SgAttribute" << endl << "dynamic: " << this->sage_class_name() << endl;
597 0 : cerr << "Aborting ..." << endl;
598 0 : ROSE_ASSERT(false);
599 : return traversalSuccessorContainer;
600 : }
601 :
602 : size_t
603 0 : SgAttribute::get_numberOfTraversalSuccessors() {
604 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
605 0 : << "static: SgAttribute" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
606 0 : cerr << "Aborting ..." << endl;
607 0 : ROSE_ASSERT(false);
608 : return 42;
609 : }
610 :
611 : SgNode*
612 0 : SgAttribute::get_traversalSuccessorByIndex(size_t) {
613 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
614 0 : << "static: SgAttribute" << endl << "dynamic: " << this->sage_class_name() << endl;
615 0 : cerr << "Aborting ..." << endl;
616 0 : ROSE_ASSERT(false);
617 : return NULL;
618 : }
619 :
620 : size_t
621 0 : SgAttribute::get_childIndex(SgNode *) {
622 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
623 0 : << "static: SgAttribute" << endl << "dynamic: " << this->sage_class_name() << endl;
624 0 : cerr << "Aborting ..." << endl;
625 0 : ROSE_ASSERT(false);
626 : return 42;
627 : }
628 :
629 : vector<SgNode*>
630 28584 : SgPragma::get_traversalSuccessorContainer() {
631 28584 : vector<SgNode*> traversalSuccessorContainer;
632 28584 : return traversalSuccessorContainer;
633 : }
634 : vector<string>
635 1276 : SgPragma::get_traversalSuccessorNamesContainer() {
636 1276 : vector<string> traversalSuccessorContainer;
637 1276 : return traversalSuccessorContainer;
638 : }
639 : size_t
640 77046 : SgPragma::get_numberOfTraversalSuccessors() {
641 77046 : return 0;
642 : }
643 : SgNode *
644 0 : SgPragma::get_traversalSuccessorByIndex(size_t idx) {
645 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgPragma" << " that has no successors!" << endl;
646 0 : ROSE_ASSERT(false);
647 : return NULL;
648 : }
649 : size_t
650 0 : SgPragma::get_childIndex(SgNode *child) {
651 0 : cout << "error: get_childIndex called on node of type " << "SgPragma" << " that has no successors!" << endl;
652 0 : ROSE_ASSERT(false);
653 : return 0;
654 : }
655 : vector<SgNode*>
656 0 : SgBitAttribute::get_traversalSuccessorContainer() {
657 0 : vector<SgNode*> traversalSuccessorContainer;
658 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
659 0 : << "static: SgBitAttribute" << endl << "dynamic: " << this->sage_class_name() << endl;
660 0 : cerr << "Aborting ..." << endl;
661 0 : ROSE_ASSERT(false);
662 : return traversalSuccessorContainer;
663 : }
664 :
665 : vector<string>
666 0 : SgBitAttribute::get_traversalSuccessorNamesContainer() {
667 0 : vector<string> traversalSuccessorContainer;
668 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
669 0 : << "static: SgBitAttribute" << endl << "dynamic: " << this->sage_class_name() << endl;
670 0 : cerr << "Aborting ..." << endl;
671 0 : ROSE_ASSERT(false);
672 : return traversalSuccessorContainer;
673 : }
674 :
675 : size_t
676 0 : SgBitAttribute::get_numberOfTraversalSuccessors() {
677 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
678 0 : << "static: SgBitAttribute" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
679 0 : cerr << "Aborting ..." << endl;
680 0 : ROSE_ASSERT(false);
681 : return 42;
682 : }
683 :
684 : SgNode*
685 0 : SgBitAttribute::get_traversalSuccessorByIndex(size_t) {
686 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
687 0 : << "static: SgBitAttribute" << endl << "dynamic: " << this->sage_class_name() << endl;
688 0 : cerr << "Aborting ..." << endl;
689 0 : ROSE_ASSERT(false);
690 : return NULL;
691 : }
692 :
693 : size_t
694 0 : SgBitAttribute::get_childIndex(SgNode *) {
695 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
696 0 : << "static: SgBitAttribute" << endl << "dynamic: " << this->sage_class_name() << endl;
697 0 : cerr << "Aborting ..." << endl;
698 0 : ROSE_ASSERT(false);
699 : return 42;
700 : }
701 :
702 : vector<SgNode*>
703 0 : SgFuncDecl_attr::get_traversalSuccessorContainer() {
704 0 : vector<SgNode*> traversalSuccessorContainer;
705 0 : return traversalSuccessorContainer;
706 : }
707 : vector<string>
708 0 : SgFuncDecl_attr::get_traversalSuccessorNamesContainer() {
709 0 : vector<string> traversalSuccessorContainer;
710 0 : return traversalSuccessorContainer;
711 : }
712 : size_t
713 0 : SgFuncDecl_attr::get_numberOfTraversalSuccessors() {
714 0 : return 0;
715 : }
716 : SgNode *
717 0 : SgFuncDecl_attr::get_traversalSuccessorByIndex(size_t idx) {
718 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgFuncDecl_attr" << " that has no successors!" << endl;
719 0 : ROSE_ASSERT(false);
720 : return NULL;
721 : }
722 : size_t
723 0 : SgFuncDecl_attr::get_childIndex(SgNode *child) {
724 0 : cout << "error: get_childIndex called on node of type " << "SgFuncDecl_attr" << " that has no successors!" << endl;
725 0 : ROSE_ASSERT(false);
726 : return 0;
727 : }
728 : vector<SgNode*>
729 0 : SgClassDecl_attr::get_traversalSuccessorContainer() {
730 0 : vector<SgNode*> traversalSuccessorContainer;
731 0 : return traversalSuccessorContainer;
732 : }
733 : vector<string>
734 0 : SgClassDecl_attr::get_traversalSuccessorNamesContainer() {
735 0 : vector<string> traversalSuccessorContainer;
736 0 : return traversalSuccessorContainer;
737 : }
738 : size_t
739 0 : SgClassDecl_attr::get_numberOfTraversalSuccessors() {
740 0 : return 0;
741 : }
742 : SgNode *
743 0 : SgClassDecl_attr::get_traversalSuccessorByIndex(size_t idx) {
744 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgClassDecl_attr" << " that has no successors!" << endl;
745 0 : ROSE_ASSERT(false);
746 : return NULL;
747 : }
748 : size_t
749 0 : SgClassDecl_attr::get_childIndex(SgNode *child) {
750 0 : cout << "error: get_childIndex called on node of type " << "SgClassDecl_attr" << " that has no successors!" << endl;
751 0 : ROSE_ASSERT(false);
752 : return 0;
753 : }
754 : vector<SgNode*>
755 34146 : Sg_File_Info::get_traversalSuccessorContainer() {
756 34146 : vector<SgNode*> traversalSuccessorContainer;
757 34146 : return traversalSuccessorContainer;
758 : }
759 : vector<string>
760 0 : Sg_File_Info::get_traversalSuccessorNamesContainer() {
761 0 : vector<string> traversalSuccessorContainer;
762 0 : return traversalSuccessorContainer;
763 : }
764 : size_t
765 34146 : Sg_File_Info::get_numberOfTraversalSuccessors() {
766 34146 : return 0;
767 : }
768 : SgNode *
769 0 : Sg_File_Info::get_traversalSuccessorByIndex(size_t idx) {
770 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "Sg_File_Info" << " that has no successors!" << endl;
771 0 : ROSE_ASSERT(false);
772 : return NULL;
773 : }
774 : size_t
775 0 : Sg_File_Info::get_childIndex(SgNode *child) {
776 0 : cout << "error: get_childIndex called on node of type " << "Sg_File_Info" << " that has no successors!" << endl;
777 0 : ROSE_ASSERT(false);
778 : return 0;
779 : }
780 : vector<SgNode*>
781 0 : SgFile::get_traversalSuccessorContainer() {
782 0 : vector<SgNode*> traversalSuccessorContainer;
783 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
784 0 : << "static: SgFile" << endl << "dynamic: " << this->sage_class_name() << endl;
785 0 : cerr << "Aborting ..." << endl;
786 0 : ROSE_ASSERT(false);
787 : return traversalSuccessorContainer;
788 : }
789 :
790 : vector<string>
791 0 : SgFile::get_traversalSuccessorNamesContainer() {
792 0 : vector<string> traversalSuccessorContainer;
793 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
794 0 : << "static: SgFile" << endl << "dynamic: " << this->sage_class_name() << endl;
795 0 : cerr << "Aborting ..." << endl;
796 0 : ROSE_ASSERT(false);
797 : return traversalSuccessorContainer;
798 : }
799 :
800 : size_t
801 0 : SgFile::get_numberOfTraversalSuccessors() {
802 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
803 0 : << "static: SgFile" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
804 0 : cerr << "Aborting ..." << endl;
805 0 : ROSE_ASSERT(false);
806 : return 42;
807 : }
808 :
809 : SgNode*
810 0 : SgFile::get_traversalSuccessorByIndex(size_t) {
811 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
812 0 : << "static: SgFile" << endl << "dynamic: " << this->sage_class_name() << endl;
813 0 : cerr << "Aborting ..." << endl;
814 0 : ROSE_ASSERT(false);
815 : return NULL;
816 : }
817 :
818 : size_t
819 0 : SgFile::get_childIndex(SgNode *) {
820 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
821 0 : << "static: SgFile" << endl << "dynamic: " << this->sage_class_name() << endl;
822 0 : cerr << "Aborting ..." << endl;
823 0 : ROSE_ASSERT(false);
824 : return 42;
825 : }
826 :
827 : vector<SgNode*>
828 1108 : SgSourceFile::get_traversalSuccessorContainer() {
829 1108 : vector<SgNode*> traversalSuccessorContainer;
830 1108 : traversalSuccessorContainer.reserve(1);
831 1108 : traversalSuccessorContainer.push_back(p_globalScope);
832 1108 : return traversalSuccessorContainer;
833 : }
834 : vector<string>
835 664 : SgSourceFile::get_traversalSuccessorNamesContainer() {
836 664 : vector<string> traversalSuccessorContainer;
837 1328 : traversalSuccessorContainer.push_back("p_globalScope");
838 664 : return traversalSuccessorContainer;
839 : }
840 : size_t
841 13005 : SgSourceFile::get_numberOfTraversalSuccessors() {
842 13005 : return 1;
843 : }
844 : SgNode *
845 13004 : SgSourceFile::get_traversalSuccessorByIndex(size_t idx) {
846 13004 : switch (idx) {
847 13004 : case 0: ROSE_ASSERT(p_globalScope == NULL || p_globalScope != NULL); return p_globalScope;
848 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
849 0 : ROSE_ASSERT(false);
850 : return NULL;
851 : }
852 : }
853 : size_t
854 0 : SgSourceFile::get_childIndex(SgNode *child) {
855 0 : if (child == p_globalScope) return 0;
856 0 : else return (size_t) -1;
857 : }
858 : vector<SgNode*>
859 0 : SgUnknownFile::get_traversalSuccessorContainer() {
860 0 : vector<SgNode*> traversalSuccessorContainer;
861 0 : traversalSuccessorContainer.reserve(1);
862 0 : traversalSuccessorContainer.push_back(p_globalScope);
863 0 : return traversalSuccessorContainer;
864 : }
865 : vector<string>
866 0 : SgUnknownFile::get_traversalSuccessorNamesContainer() {
867 0 : vector<string> traversalSuccessorContainer;
868 0 : traversalSuccessorContainer.push_back("p_globalScope");
869 0 : return traversalSuccessorContainer;
870 : }
871 : size_t
872 0 : SgUnknownFile::get_numberOfTraversalSuccessors() {
873 0 : return 1;
874 : }
875 : SgNode *
876 0 : SgUnknownFile::get_traversalSuccessorByIndex(size_t idx) {
877 0 : switch (idx) {
878 0 : case 0: ROSE_ASSERT(p_globalScope == NULL || p_globalScope != NULL); return p_globalScope;
879 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
880 0 : ROSE_ASSERT(false);
881 : return NULL;
882 : }
883 : }
884 : size_t
885 0 : SgUnknownFile::get_childIndex(SgNode *child) {
886 0 : if (child == p_globalScope) return 0;
887 0 : else return (size_t) -1;
888 : }
889 : vector<SgNode*>
890 733 : SgProject::get_traversalSuccessorContainer() {
891 733 : vector<SgNode*> traversalSuccessorContainer;
892 733 : traversalSuccessorContainer.reserve(1);
893 733 : traversalSuccessorContainer.push_back(p_fileList_ptr);
894 733 : return traversalSuccessorContainer;
895 : }
896 : vector<string>
897 658 : SgProject::get_traversalSuccessorNamesContainer() {
898 658 : vector<string> traversalSuccessorContainer;
899 1316 : traversalSuccessorContainer.push_back("p_fileList_ptr");
900 658 : return traversalSuccessorContainer;
901 : }
902 : size_t
903 10399 : SgProject::get_numberOfTraversalSuccessors() {
904 10399 : return 1;
905 : }
906 : SgNode *
907 10397 : SgProject::get_traversalSuccessorByIndex(size_t idx) {
908 10397 : switch (idx) {
909 10397 : case 0: ROSE_ASSERT(p_fileList_ptr == NULL || p_fileList_ptr != NULL); return p_fileList_ptr;
910 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
911 0 : ROSE_ASSERT(false);
912 : return NULL;
913 : }
914 : }
915 : size_t
916 0 : SgProject::get_childIndex(SgNode *child) {
917 0 : if (child == p_fileList_ptr) return 0;
918 0 : else return (size_t) -1;
919 : }
920 : vector<SgNode*>
921 0 : SgOptions::get_traversalSuccessorContainer() {
922 0 : vector<SgNode*> traversalSuccessorContainer;
923 0 : return traversalSuccessorContainer;
924 : }
925 : vector<string>
926 0 : SgOptions::get_traversalSuccessorNamesContainer() {
927 0 : vector<string> traversalSuccessorContainer;
928 0 : return traversalSuccessorContainer;
929 : }
930 : size_t
931 0 : SgOptions::get_numberOfTraversalSuccessors() {
932 0 : return 0;
933 : }
934 : SgNode *
935 0 : SgOptions::get_traversalSuccessorByIndex(size_t idx) {
936 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOptions" << " that has no successors!" << endl;
937 0 : ROSE_ASSERT(false);
938 : return NULL;
939 : }
940 : size_t
941 0 : SgOptions::get_childIndex(SgNode *child) {
942 0 : cout << "error: get_childIndex called on node of type " << "SgOptions" << " that has no successors!" << endl;
943 0 : ROSE_ASSERT(false);
944 : return 0;
945 : }
946 : vector<SgNode*>
947 0 : SgUnparse_Info::get_traversalSuccessorContainer() {
948 0 : vector<SgNode*> traversalSuccessorContainer;
949 0 : return traversalSuccessorContainer;
950 : }
951 : vector<string>
952 0 : SgUnparse_Info::get_traversalSuccessorNamesContainer() {
953 0 : vector<string> traversalSuccessorContainer;
954 0 : return traversalSuccessorContainer;
955 : }
956 : size_t
957 0 : SgUnparse_Info::get_numberOfTraversalSuccessors() {
958 0 : return 0;
959 : }
960 : SgNode *
961 0 : SgUnparse_Info::get_traversalSuccessorByIndex(size_t idx) {
962 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUnparse_Info" << " that has no successors!" << endl;
963 0 : ROSE_ASSERT(false);
964 : return NULL;
965 : }
966 : size_t
967 0 : SgUnparse_Info::get_childIndex(SgNode *child) {
968 0 : cout << "error: get_childIndex called on node of type " << "SgUnparse_Info" << " that has no successors!" << endl;
969 0 : ROSE_ASSERT(false);
970 : return 0;
971 : }
972 : vector<SgNode*>
973 0 : SgBaseClass::get_traversalSuccessorContainer() {
974 0 : vector<SgNode*> traversalSuccessorContainer;
975 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
976 0 : << "static: SgBaseClass" << endl << "dynamic: " << this->sage_class_name() << endl;
977 0 : cerr << "Aborting ..." << endl;
978 0 : ROSE_ASSERT(false);
979 : return traversalSuccessorContainer;
980 : }
981 :
982 : vector<string>
983 0 : SgBaseClass::get_traversalSuccessorNamesContainer() {
984 0 : vector<string> traversalSuccessorContainer;
985 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
986 0 : << "static: SgBaseClass" << endl << "dynamic: " << this->sage_class_name() << endl;
987 0 : cerr << "Aborting ..." << endl;
988 0 : ROSE_ASSERT(false);
989 : return traversalSuccessorContainer;
990 : }
991 :
992 : size_t
993 0 : SgBaseClass::get_numberOfTraversalSuccessors() {
994 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
995 0 : << "static: SgBaseClass" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
996 0 : cerr << "Aborting ..." << endl;
997 0 : ROSE_ASSERT(false);
998 : return 42;
999 : }
1000 :
1001 : SgNode*
1002 0 : SgBaseClass::get_traversalSuccessorByIndex(size_t) {
1003 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1004 0 : << "static: SgBaseClass" << endl << "dynamic: " << this->sage_class_name() << endl;
1005 0 : cerr << "Aborting ..." << endl;
1006 0 : ROSE_ASSERT(false);
1007 : return NULL;
1008 : }
1009 :
1010 : size_t
1011 0 : SgBaseClass::get_childIndex(SgNode *) {
1012 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1013 0 : << "static: SgBaseClass" << endl << "dynamic: " << this->sage_class_name() << endl;
1014 0 : cerr << "Aborting ..." << endl;
1015 0 : ROSE_ASSERT(false);
1016 : return 42;
1017 : }
1018 :
1019 : vector<SgNode*>
1020 0 : SgExpBaseClass::get_traversalSuccessorContainer() {
1021 0 : vector<SgNode*> traversalSuccessorContainer;
1022 0 : traversalSuccessorContainer.reserve(2);
1023 0 : traversalSuccessorContainer.push_back(p_base_class);
1024 0 : traversalSuccessorContainer.push_back(p_base_class_exp);
1025 0 : return traversalSuccessorContainer;
1026 : }
1027 : vector<string>
1028 0 : SgExpBaseClass::get_traversalSuccessorNamesContainer() {
1029 0 : vector<string> traversalSuccessorContainer;
1030 0 : traversalSuccessorContainer.push_back("p_base_class");
1031 0 : traversalSuccessorContainer.push_back("p_base_class_exp");
1032 0 : return traversalSuccessorContainer;
1033 : }
1034 : size_t
1035 0 : SgExpBaseClass::get_numberOfTraversalSuccessors() {
1036 0 : return 2;
1037 : }
1038 : SgNode *
1039 0 : SgExpBaseClass::get_traversalSuccessorByIndex(size_t idx) {
1040 0 : switch (idx) {
1041 0 : case 0: ROSE_ASSERT(p_base_class == NULL || p_base_class != NULL); return p_base_class;
1042 0 : case 1: ROSE_ASSERT(p_base_class_exp == NULL || p_base_class_exp != NULL); return p_base_class_exp;
1043 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
1044 0 : ROSE_ASSERT(false);
1045 : return NULL;
1046 : }
1047 : }
1048 : size_t
1049 0 : SgExpBaseClass::get_childIndex(SgNode *child) {
1050 0 : if (child == p_base_class) return 0;
1051 0 : else if (child == p_base_class_exp) return 1;
1052 0 : else return (size_t) -1;
1053 : }
1054 : vector<SgNode*>
1055 0 : SgNonrealBaseClass::get_traversalSuccessorContainer() {
1056 0 : vector<SgNode*> traversalSuccessorContainer;
1057 0 : traversalSuccessorContainer.reserve(2);
1058 0 : traversalSuccessorContainer.push_back(p_base_class);
1059 0 : traversalSuccessorContainer.push_back(p_base_class_nonreal);
1060 0 : return traversalSuccessorContainer;
1061 : }
1062 : vector<string>
1063 0 : SgNonrealBaseClass::get_traversalSuccessorNamesContainer() {
1064 0 : vector<string> traversalSuccessorContainer;
1065 0 : traversalSuccessorContainer.push_back("p_base_class");
1066 0 : traversalSuccessorContainer.push_back("p_base_class_nonreal");
1067 0 : return traversalSuccessorContainer;
1068 : }
1069 : size_t
1070 0 : SgNonrealBaseClass::get_numberOfTraversalSuccessors() {
1071 0 : return 2;
1072 : }
1073 : SgNode *
1074 0 : SgNonrealBaseClass::get_traversalSuccessorByIndex(size_t idx) {
1075 0 : switch (idx) {
1076 0 : case 0: ROSE_ASSERT(p_base_class == NULL || p_base_class != NULL); return p_base_class;
1077 0 : case 1: ROSE_ASSERT(p_base_class_nonreal == NULL || p_base_class_nonreal != NULL); return p_base_class_nonreal;
1078 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
1079 0 : ROSE_ASSERT(false);
1080 : return NULL;
1081 : }
1082 : }
1083 : size_t
1084 0 : SgNonrealBaseClass::get_childIndex(SgNode *child) {
1085 0 : if (child == p_base_class) return 0;
1086 0 : else if (child == p_base_class_nonreal) return 1;
1087 0 : else return (size_t) -1;
1088 : }
1089 : vector<SgNode*>
1090 0 : SgTypedefSeq::get_traversalSuccessorContainer() {
1091 0 : vector<SgNode*> traversalSuccessorContainer;
1092 0 : return traversalSuccessorContainer;
1093 : }
1094 : vector<string>
1095 0 : SgTypedefSeq::get_traversalSuccessorNamesContainer() {
1096 0 : vector<string> traversalSuccessorContainer;
1097 0 : return traversalSuccessorContainer;
1098 : }
1099 : size_t
1100 0 : SgTypedefSeq::get_numberOfTraversalSuccessors() {
1101 0 : return 0;
1102 : }
1103 : SgNode *
1104 0 : SgTypedefSeq::get_traversalSuccessorByIndex(size_t idx) {
1105 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgTypedefSeq" << " that has no successors!" << endl;
1106 0 : ROSE_ASSERT(false);
1107 : return NULL;
1108 : }
1109 : size_t
1110 0 : SgTypedefSeq::get_childIndex(SgNode *child) {
1111 0 : cout << "error: get_childIndex called on node of type " << "SgTypedefSeq" << " that has no successors!" << endl;
1112 0 : ROSE_ASSERT(false);
1113 : return 0;
1114 : }
1115 : vector<SgNode*>
1116 0 : SgTemplateParameter::get_traversalSuccessorContainer() {
1117 0 : vector<SgNode*> traversalSuccessorContainer;
1118 0 : traversalSuccessorContainer.reserve(5);
1119 0 : traversalSuccessorContainer.push_back(p_expression);
1120 0 : traversalSuccessorContainer.push_back(p_defaultExpressionParameter);
1121 0 : traversalSuccessorContainer.push_back(p_templateDeclaration);
1122 0 : traversalSuccessorContainer.push_back(p_defaultTemplateDeclarationParameter);
1123 0 : traversalSuccessorContainer.push_back(p_initializedName);
1124 0 : return traversalSuccessorContainer;
1125 : }
1126 : vector<string>
1127 0 : SgTemplateParameter::get_traversalSuccessorNamesContainer() {
1128 0 : vector<string> traversalSuccessorContainer;
1129 0 : traversalSuccessorContainer.push_back("p_expression");
1130 0 : traversalSuccessorContainer.push_back("p_defaultExpressionParameter");
1131 0 : traversalSuccessorContainer.push_back("p_templateDeclaration");
1132 0 : traversalSuccessorContainer.push_back("p_defaultTemplateDeclarationParameter");
1133 0 : traversalSuccessorContainer.push_back("p_initializedName");
1134 0 : return traversalSuccessorContainer;
1135 : }
1136 : size_t
1137 0 : SgTemplateParameter::get_numberOfTraversalSuccessors() {
1138 0 : return 5;
1139 : }
1140 : SgNode *
1141 0 : SgTemplateParameter::get_traversalSuccessorByIndex(size_t idx) {
1142 0 : switch (idx) {
1143 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
1144 0 : case 1: ROSE_ASSERT(p_defaultExpressionParameter == NULL || p_defaultExpressionParameter != NULL); return p_defaultExpressionParameter;
1145 0 : case 2: ROSE_ASSERT(p_templateDeclaration == NULL || p_templateDeclaration != NULL); return p_templateDeclaration;
1146 0 : case 3: ROSE_ASSERT(p_defaultTemplateDeclarationParameter == NULL || p_defaultTemplateDeclarationParameter != NULL); return p_defaultTemplateDeclarationParameter;
1147 0 : case 4: ROSE_ASSERT(p_initializedName == NULL || p_initializedName != NULL); return p_initializedName;
1148 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
1149 0 : ROSE_ASSERT(false);
1150 : return NULL;
1151 : }
1152 : }
1153 : size_t
1154 0 : SgTemplateParameter::get_childIndex(SgNode *child) {
1155 0 : if (child == p_expression) return 0;
1156 0 : else if (child == p_defaultExpressionParameter) return 1;
1157 0 : else if (child == p_templateDeclaration) return 2;
1158 0 : else if (child == p_defaultTemplateDeclarationParameter) return 3;
1159 0 : else if (child == p_initializedName) return 4;
1160 0 : else return (size_t) -1;
1161 : }
1162 : vector<SgNode*>
1163 0 : SgTemplateArgument::get_traversalSuccessorContainer() {
1164 0 : vector<SgNode*> traversalSuccessorContainer;
1165 0 : traversalSuccessorContainer.reserve(3);
1166 0 : traversalSuccessorContainer.push_back(p_expression);
1167 0 : traversalSuccessorContainer.push_back(p_templateDeclaration);
1168 0 : traversalSuccessorContainer.push_back(p_initializedName);
1169 0 : return traversalSuccessorContainer;
1170 : }
1171 : vector<string>
1172 0 : SgTemplateArgument::get_traversalSuccessorNamesContainer() {
1173 0 : vector<string> traversalSuccessorContainer;
1174 0 : traversalSuccessorContainer.push_back("p_expression");
1175 0 : traversalSuccessorContainer.push_back("p_templateDeclaration");
1176 0 : traversalSuccessorContainer.push_back("p_initializedName");
1177 0 : return traversalSuccessorContainer;
1178 : }
1179 : size_t
1180 0 : SgTemplateArgument::get_numberOfTraversalSuccessors() {
1181 0 : return 3;
1182 : }
1183 : SgNode *
1184 0 : SgTemplateArgument::get_traversalSuccessorByIndex(size_t idx) {
1185 0 : switch (idx) {
1186 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
1187 0 : case 1: ROSE_ASSERT(p_templateDeclaration == NULL || p_templateDeclaration != NULL); return p_templateDeclaration;
1188 0 : case 2: ROSE_ASSERT(p_initializedName == NULL || p_initializedName != NULL); return p_initializedName;
1189 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
1190 0 : ROSE_ASSERT(false);
1191 : return NULL;
1192 : }
1193 : }
1194 : size_t
1195 0 : SgTemplateArgument::get_childIndex(SgNode *child) {
1196 0 : if (child == p_expression) return 0;
1197 0 : else if (child == p_templateDeclaration) return 1;
1198 0 : else if (child == p_initializedName) return 2;
1199 0 : else return (size_t) -1;
1200 : }
1201 : vector<SgNode*>
1202 0 : SgDirectory::get_traversalSuccessorContainer() {
1203 0 : vector<SgNode*> traversalSuccessorContainer;
1204 0 : traversalSuccessorContainer.reserve(2);
1205 0 : traversalSuccessorContainer.push_back(p_fileList);
1206 0 : traversalSuccessorContainer.push_back(p_directoryList);
1207 0 : return traversalSuccessorContainer;
1208 : }
1209 : vector<string>
1210 0 : SgDirectory::get_traversalSuccessorNamesContainer() {
1211 0 : vector<string> traversalSuccessorContainer;
1212 0 : traversalSuccessorContainer.push_back("p_fileList");
1213 0 : traversalSuccessorContainer.push_back("p_directoryList");
1214 0 : return traversalSuccessorContainer;
1215 : }
1216 : size_t
1217 0 : SgDirectory::get_numberOfTraversalSuccessors() {
1218 0 : return 2;
1219 : }
1220 : SgNode *
1221 0 : SgDirectory::get_traversalSuccessorByIndex(size_t idx) {
1222 0 : switch (idx) {
1223 0 : case 0: ROSE_ASSERT(p_fileList == NULL || p_fileList != NULL); return p_fileList;
1224 0 : case 1: ROSE_ASSERT(p_directoryList == NULL || p_directoryList != NULL); return p_directoryList;
1225 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
1226 0 : ROSE_ASSERT(false);
1227 : return NULL;
1228 : }
1229 : }
1230 : size_t
1231 0 : SgDirectory::get_childIndex(SgNode *child) {
1232 0 : if (child == p_fileList) return 0;
1233 0 : else if (child == p_directoryList) return 1;
1234 0 : else return (size_t) -1;
1235 : }
1236 : vector<SgNode*>
1237 733 : SgFileList::get_traversalSuccessorContainer() {
1238 733 : vector<SgNode*> traversalSuccessorContainer;
1239 733 : traversalSuccessorContainer.reserve(p_listOfFiles.size() + 0);
1240 733 : {
1241 733 : SgFilePtrList::iterator iter;
1242 1472 : for (iter = p_listOfFiles.begin(); iter != p_listOfFiles.end(); iter++)
1243 739 : traversalSuccessorContainer.push_back(*iter);
1244 : }
1245 733 : return traversalSuccessorContainer;
1246 : }
1247 : vector<string>
1248 986 : SgFileList::get_traversalSuccessorNamesContainer() {
1249 986 : vector<string> traversalSuccessorContainer;
1250 986 : int i = 0;
1251 986 : {
1252 986 : SgFilePtrList::iterator iter;
1253 1981 : for (iter = p_listOfFiles.begin(); iter != p_listOfFiles.end(); (iter++,i++)) {
1254 995 : char buf[20];
1255 995 : sprintf(buf,"*[%d]",i);
1256 1990 : traversalSuccessorContainer.push_back(buf);
1257 : }
1258 : }
1259 986 : return traversalSuccessorContainer;
1260 : }
1261 : size_t
1262 10398 : SgFileList::get_numberOfTraversalSuccessors() {
1263 10398 : return p_listOfFiles.size() + 0;
1264 : }
1265 : SgNode *
1266 10456 : SgFileList::get_traversalSuccessorByIndex(size_t idx) {
1267 10456 : ROSE_ASSERT(idx < p_listOfFiles.size());
1268 10456 : return p_listOfFiles[idx];
1269 : }
1270 : size_t
1271 0 : SgFileList::get_childIndex(SgNode *child) {
1272 0 : SgFilePtrList::iterator itr = find(p_listOfFiles.begin(), p_listOfFiles.end(), child);
1273 0 : if (itr != p_listOfFiles.end()) return itr - p_listOfFiles.begin();
1274 : else return (size_t) -1;
1275 : }
1276 : vector<SgNode*>
1277 0 : SgDirectoryList::get_traversalSuccessorContainer() {
1278 0 : vector<SgNode*> traversalSuccessorContainer;
1279 0 : traversalSuccessorContainer.reserve(p_listOfDirectories.size() + 0);
1280 0 : {
1281 0 : SgDirectoryPtrList::iterator iter;
1282 0 : for (iter = p_listOfDirectories.begin(); iter != p_listOfDirectories.end(); iter++)
1283 0 : traversalSuccessorContainer.push_back(*iter);
1284 : }
1285 0 : return traversalSuccessorContainer;
1286 : }
1287 : vector<string>
1288 0 : SgDirectoryList::get_traversalSuccessorNamesContainer() {
1289 0 : vector<string> traversalSuccessorContainer;
1290 0 : int i = 0;
1291 0 : {
1292 0 : SgDirectoryPtrList::iterator iter;
1293 0 : for (iter = p_listOfDirectories.begin(); iter != p_listOfDirectories.end(); (iter++,i++)) {
1294 0 : char buf[20];
1295 0 : sprintf(buf,"*[%d]",i);
1296 0 : traversalSuccessorContainer.push_back(buf);
1297 : }
1298 : }
1299 0 : return traversalSuccessorContainer;
1300 : }
1301 : size_t
1302 0 : SgDirectoryList::get_numberOfTraversalSuccessors() {
1303 0 : return p_listOfDirectories.size() + 0;
1304 : }
1305 : SgNode *
1306 0 : SgDirectoryList::get_traversalSuccessorByIndex(size_t idx) {
1307 0 : ROSE_ASSERT(idx < p_listOfDirectories.size());
1308 0 : return p_listOfDirectories[idx];
1309 : }
1310 : size_t
1311 0 : SgDirectoryList::get_childIndex(SgNode *child) {
1312 0 : SgDirectoryPtrList::iterator itr = find(p_listOfDirectories.begin(), p_listOfDirectories.end(), child);
1313 0 : if (itr != p_listOfDirectories.end()) return itr - p_listOfDirectories.begin();
1314 : else return (size_t) -1;
1315 : }
1316 : vector<SgNode*>
1317 1161220 : SgFunctionParameterTypeList::get_traversalSuccessorContainer() {
1318 1161220 : vector<SgNode*> traversalSuccessorContainer;
1319 1161220 : return traversalSuccessorContainer;
1320 : }
1321 : vector<string>
1322 0 : SgFunctionParameterTypeList::get_traversalSuccessorNamesContainer() {
1323 0 : vector<string> traversalSuccessorContainer;
1324 0 : return traversalSuccessorContainer;
1325 : }
1326 : size_t
1327 1161220 : SgFunctionParameterTypeList::get_numberOfTraversalSuccessors() {
1328 1161220 : return 0;
1329 : }
1330 : SgNode *
1331 0 : SgFunctionParameterTypeList::get_traversalSuccessorByIndex(size_t idx) {
1332 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgFunctionParameterTypeList" << " that has no successors!" << endl;
1333 0 : ROSE_ASSERT(false);
1334 : return NULL;
1335 : }
1336 : size_t
1337 0 : SgFunctionParameterTypeList::get_childIndex(SgNode *child) {
1338 0 : cout << "error: get_childIndex called on node of type " << "SgFunctionParameterTypeList" << " that has no successors!" << endl;
1339 0 : ROSE_ASSERT(false);
1340 : return 0;
1341 : }
1342 : vector<SgNode*>
1343 0 : SgQualifiedName::get_traversalSuccessorContainer() {
1344 0 : vector<SgNode*> traversalSuccessorContainer;
1345 0 : return traversalSuccessorContainer;
1346 : }
1347 : vector<string>
1348 0 : SgQualifiedName::get_traversalSuccessorNamesContainer() {
1349 0 : vector<string> traversalSuccessorContainer;
1350 0 : return traversalSuccessorContainer;
1351 : }
1352 : size_t
1353 0 : SgQualifiedName::get_numberOfTraversalSuccessors() {
1354 0 : return 0;
1355 : }
1356 : SgNode *
1357 0 : SgQualifiedName::get_traversalSuccessorByIndex(size_t idx) {
1358 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgQualifiedName" << " that has no successors!" << endl;
1359 0 : ROSE_ASSERT(false);
1360 : return NULL;
1361 : }
1362 : size_t
1363 0 : SgQualifiedName::get_childIndex(SgNode *child) {
1364 0 : cout << "error: get_childIndex called on node of type " << "SgQualifiedName" << " that has no successors!" << endl;
1365 0 : ROSE_ASSERT(false);
1366 : return 0;
1367 : }
1368 : vector<SgNode*>
1369 0 : SgTemplateArgumentList::get_traversalSuccessorContainer() {
1370 0 : vector<SgNode*> traversalSuccessorContainer;
1371 0 : traversalSuccessorContainer.reserve(p_args.size() + 0);
1372 0 : {
1373 0 : SgTemplateArgumentPtrList::iterator iter;
1374 0 : for (iter = p_args.begin(); iter != p_args.end(); iter++)
1375 0 : traversalSuccessorContainer.push_back(*iter);
1376 : }
1377 0 : return traversalSuccessorContainer;
1378 : }
1379 : vector<string>
1380 0 : SgTemplateArgumentList::get_traversalSuccessorNamesContainer() {
1381 0 : vector<string> traversalSuccessorContainer;
1382 0 : int i = 0;
1383 0 : {
1384 0 : SgTemplateArgumentPtrList::iterator iter;
1385 0 : for (iter = p_args.begin(); iter != p_args.end(); (iter++,i++)) {
1386 0 : char buf[20];
1387 0 : sprintf(buf,"*[%d]",i);
1388 0 : traversalSuccessorContainer.push_back(buf);
1389 : }
1390 : }
1391 0 : return traversalSuccessorContainer;
1392 : }
1393 : size_t
1394 0 : SgTemplateArgumentList::get_numberOfTraversalSuccessors() {
1395 0 : return p_args.size() + 0;
1396 : }
1397 : SgNode *
1398 0 : SgTemplateArgumentList::get_traversalSuccessorByIndex(size_t idx) {
1399 0 : ROSE_ASSERT(idx < p_args.size());
1400 0 : return p_args[idx];
1401 : }
1402 : size_t
1403 0 : SgTemplateArgumentList::get_childIndex(SgNode *child) {
1404 0 : SgTemplateArgumentPtrList::iterator itr = find(p_args.begin(), p_args.end(), child);
1405 0 : if (itr != p_args.end()) return itr - p_args.begin();
1406 : else return (size_t) -1;
1407 : }
1408 : vector<SgNode*>
1409 0 : SgTemplateParameterList::get_traversalSuccessorContainer() {
1410 0 : vector<SgNode*> traversalSuccessorContainer;
1411 0 : traversalSuccessorContainer.reserve(p_args.size() + 0);
1412 0 : {
1413 0 : SgTemplateParameterPtrList::iterator iter;
1414 0 : for (iter = p_args.begin(); iter != p_args.end(); iter++)
1415 0 : traversalSuccessorContainer.push_back(*iter);
1416 : }
1417 0 : return traversalSuccessorContainer;
1418 : }
1419 : vector<string>
1420 0 : SgTemplateParameterList::get_traversalSuccessorNamesContainer() {
1421 0 : vector<string> traversalSuccessorContainer;
1422 0 : int i = 0;
1423 0 : {
1424 0 : SgTemplateParameterPtrList::iterator iter;
1425 0 : for (iter = p_args.begin(); iter != p_args.end(); (iter++,i++)) {
1426 0 : char buf[20];
1427 0 : sprintf(buf,"*[%d]",i);
1428 0 : traversalSuccessorContainer.push_back(buf);
1429 : }
1430 : }
1431 0 : return traversalSuccessorContainer;
1432 : }
1433 : size_t
1434 0 : SgTemplateParameterList::get_numberOfTraversalSuccessors() {
1435 0 : return p_args.size() + 0;
1436 : }
1437 : SgNode *
1438 0 : SgTemplateParameterList::get_traversalSuccessorByIndex(size_t idx) {
1439 0 : ROSE_ASSERT(idx < p_args.size());
1440 0 : return p_args[idx];
1441 : }
1442 : size_t
1443 0 : SgTemplateParameterList::get_childIndex(SgNode *child) {
1444 0 : SgTemplateParameterPtrList::iterator itr = find(p_args.begin(), p_args.end(), child);
1445 0 : if (itr != p_args.end()) return itr - p_args.begin();
1446 : else return (size_t) -1;
1447 : }
1448 : vector<SgNode*>
1449 0 : SgGraph::get_traversalSuccessorContainer() {
1450 0 : vector<SgNode*> traversalSuccessorContainer;
1451 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1452 0 : << "static: SgGraph" << endl << "dynamic: " << this->sage_class_name() << endl;
1453 0 : cerr << "Aborting ..." << endl;
1454 0 : ROSE_ASSERT(false);
1455 : return traversalSuccessorContainer;
1456 : }
1457 :
1458 : vector<string>
1459 0 : SgGraph::get_traversalSuccessorNamesContainer() {
1460 0 : vector<string> traversalSuccessorContainer;
1461 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1462 0 : << "static: SgGraph" << endl << "dynamic: " << this->sage_class_name() << endl;
1463 0 : cerr << "Aborting ..." << endl;
1464 0 : ROSE_ASSERT(false);
1465 : return traversalSuccessorContainer;
1466 : }
1467 :
1468 : size_t
1469 0 : SgGraph::get_numberOfTraversalSuccessors() {
1470 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1471 0 : << "static: SgGraph" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
1472 0 : cerr << "Aborting ..." << endl;
1473 0 : ROSE_ASSERT(false);
1474 : return 42;
1475 : }
1476 :
1477 : SgNode*
1478 0 : SgGraph::get_traversalSuccessorByIndex(size_t) {
1479 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1480 0 : << "static: SgGraph" << endl << "dynamic: " << this->sage_class_name() << endl;
1481 0 : cerr << "Aborting ..." << endl;
1482 0 : ROSE_ASSERT(false);
1483 : return NULL;
1484 : }
1485 :
1486 : size_t
1487 0 : SgGraph::get_childIndex(SgNode *) {
1488 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1489 0 : << "static: SgGraph" << endl << "dynamic: " << this->sage_class_name() << endl;
1490 0 : cerr << "Aborting ..." << endl;
1491 0 : ROSE_ASSERT(false);
1492 : return 42;
1493 : }
1494 :
1495 : vector<SgNode*>
1496 0 : SgIncidenceDirectedGraph::get_traversalSuccessorContainer() {
1497 0 : vector<SgNode*> traversalSuccessorContainer;
1498 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1499 0 : << "static: SgIncidenceDirectedGraph" << endl << "dynamic: " << this->sage_class_name() << endl;
1500 0 : cerr << "Aborting ..." << endl;
1501 0 : ROSE_ASSERT(false);
1502 : return traversalSuccessorContainer;
1503 : }
1504 :
1505 : vector<string>
1506 0 : SgIncidenceDirectedGraph::get_traversalSuccessorNamesContainer() {
1507 0 : vector<string> traversalSuccessorContainer;
1508 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1509 0 : << "static: SgIncidenceDirectedGraph" << endl << "dynamic: " << this->sage_class_name() << endl;
1510 0 : cerr << "Aborting ..." << endl;
1511 0 : ROSE_ASSERT(false);
1512 : return traversalSuccessorContainer;
1513 : }
1514 :
1515 : size_t
1516 0 : SgIncidenceDirectedGraph::get_numberOfTraversalSuccessors() {
1517 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1518 0 : << "static: SgIncidenceDirectedGraph" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
1519 0 : cerr << "Aborting ..." << endl;
1520 0 : ROSE_ASSERT(false);
1521 : return 42;
1522 : }
1523 :
1524 : SgNode*
1525 0 : SgIncidenceDirectedGraph::get_traversalSuccessorByIndex(size_t) {
1526 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1527 0 : << "static: SgIncidenceDirectedGraph" << endl << "dynamic: " << this->sage_class_name() << endl;
1528 0 : cerr << "Aborting ..." << endl;
1529 0 : ROSE_ASSERT(false);
1530 : return NULL;
1531 : }
1532 :
1533 : size_t
1534 0 : SgIncidenceDirectedGraph::get_childIndex(SgNode *) {
1535 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1536 0 : << "static: SgIncidenceDirectedGraph" << endl << "dynamic: " << this->sage_class_name() << endl;
1537 0 : cerr << "Aborting ..." << endl;
1538 0 : ROSE_ASSERT(false);
1539 : return 42;
1540 : }
1541 :
1542 : vector<SgNode*>
1543 0 : SgBidirectionalGraph::get_traversalSuccessorContainer() {
1544 0 : vector<SgNode*> traversalSuccessorContainer;
1545 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1546 0 : << "static: SgBidirectionalGraph" << endl << "dynamic: " << this->sage_class_name() << endl;
1547 0 : cerr << "Aborting ..." << endl;
1548 0 : ROSE_ASSERT(false);
1549 : return traversalSuccessorContainer;
1550 : }
1551 :
1552 : vector<string>
1553 0 : SgBidirectionalGraph::get_traversalSuccessorNamesContainer() {
1554 0 : vector<string> traversalSuccessorContainer;
1555 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1556 0 : << "static: SgBidirectionalGraph" << endl << "dynamic: " << this->sage_class_name() << endl;
1557 0 : cerr << "Aborting ..." << endl;
1558 0 : ROSE_ASSERT(false);
1559 : return traversalSuccessorContainer;
1560 : }
1561 :
1562 : size_t
1563 0 : SgBidirectionalGraph::get_numberOfTraversalSuccessors() {
1564 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1565 0 : << "static: SgBidirectionalGraph" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
1566 0 : cerr << "Aborting ..." << endl;
1567 0 : ROSE_ASSERT(false);
1568 : return 42;
1569 : }
1570 :
1571 : SgNode*
1572 0 : SgBidirectionalGraph::get_traversalSuccessorByIndex(size_t) {
1573 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1574 0 : << "static: SgBidirectionalGraph" << endl << "dynamic: " << this->sage_class_name() << endl;
1575 0 : cerr << "Aborting ..." << endl;
1576 0 : ROSE_ASSERT(false);
1577 : return NULL;
1578 : }
1579 :
1580 : size_t
1581 0 : SgBidirectionalGraph::get_childIndex(SgNode *) {
1582 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1583 0 : << "static: SgBidirectionalGraph" << endl << "dynamic: " << this->sage_class_name() << endl;
1584 0 : cerr << "Aborting ..." << endl;
1585 0 : ROSE_ASSERT(false);
1586 : return 42;
1587 : }
1588 :
1589 : vector<SgNode*>
1590 0 : SgStringKeyedBidirectionalGraph::get_traversalSuccessorContainer() {
1591 0 : vector<SgNode*> traversalSuccessorContainer;
1592 0 : return traversalSuccessorContainer;
1593 : }
1594 : vector<string>
1595 0 : SgStringKeyedBidirectionalGraph::get_traversalSuccessorNamesContainer() {
1596 0 : vector<string> traversalSuccessorContainer;
1597 0 : return traversalSuccessorContainer;
1598 : }
1599 : size_t
1600 0 : SgStringKeyedBidirectionalGraph::get_numberOfTraversalSuccessors() {
1601 0 : return 0;
1602 : }
1603 : SgNode *
1604 0 : SgStringKeyedBidirectionalGraph::get_traversalSuccessorByIndex(size_t idx) {
1605 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgStringKeyedBidirectionalGraph" << " that has no successors!" << endl;
1606 0 : ROSE_ASSERT(false);
1607 : return NULL;
1608 : }
1609 : size_t
1610 0 : SgStringKeyedBidirectionalGraph::get_childIndex(SgNode *child) {
1611 0 : cout << "error: get_childIndex called on node of type " << "SgStringKeyedBidirectionalGraph" << " that has no successors!" << endl;
1612 0 : ROSE_ASSERT(false);
1613 : return 0;
1614 : }
1615 : vector<SgNode*>
1616 0 : SgIntKeyedBidirectionalGraph::get_traversalSuccessorContainer() {
1617 0 : vector<SgNode*> traversalSuccessorContainer;
1618 0 : return traversalSuccessorContainer;
1619 : }
1620 : vector<string>
1621 0 : SgIntKeyedBidirectionalGraph::get_traversalSuccessorNamesContainer() {
1622 0 : vector<string> traversalSuccessorContainer;
1623 0 : return traversalSuccessorContainer;
1624 : }
1625 : size_t
1626 0 : SgIntKeyedBidirectionalGraph::get_numberOfTraversalSuccessors() {
1627 0 : return 0;
1628 : }
1629 : SgNode *
1630 0 : SgIntKeyedBidirectionalGraph::get_traversalSuccessorByIndex(size_t idx) {
1631 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgIntKeyedBidirectionalGraph" << " that has no successors!" << endl;
1632 0 : ROSE_ASSERT(false);
1633 : return NULL;
1634 : }
1635 : size_t
1636 0 : SgIntKeyedBidirectionalGraph::get_childIndex(SgNode *child) {
1637 0 : cout << "error: get_childIndex called on node of type " << "SgIntKeyedBidirectionalGraph" << " that has no successors!" << endl;
1638 0 : ROSE_ASSERT(false);
1639 : return 0;
1640 : }
1641 : vector<SgNode*>
1642 0 : SgIncidenceUndirectedGraph::get_traversalSuccessorContainer() {
1643 0 : vector<SgNode*> traversalSuccessorContainer;
1644 0 : return traversalSuccessorContainer;
1645 : }
1646 : vector<string>
1647 0 : SgIncidenceUndirectedGraph::get_traversalSuccessorNamesContainer() {
1648 0 : vector<string> traversalSuccessorContainer;
1649 0 : return traversalSuccessorContainer;
1650 : }
1651 : size_t
1652 0 : SgIncidenceUndirectedGraph::get_numberOfTraversalSuccessors() {
1653 0 : return 0;
1654 : }
1655 : SgNode *
1656 0 : SgIncidenceUndirectedGraph::get_traversalSuccessorByIndex(size_t idx) {
1657 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgIncidenceUndirectedGraph" << " that has no successors!" << endl;
1658 0 : ROSE_ASSERT(false);
1659 : return NULL;
1660 : }
1661 : size_t
1662 0 : SgIncidenceUndirectedGraph::get_childIndex(SgNode *child) {
1663 0 : cout << "error: get_childIndex called on node of type " << "SgIncidenceUndirectedGraph" << " that has no successors!" << endl;
1664 0 : ROSE_ASSERT(false);
1665 : return 0;
1666 : }
1667 : vector<SgNode*>
1668 0 : SgGraphNode::get_traversalSuccessorContainer() {
1669 0 : vector<SgNode*> traversalSuccessorContainer;
1670 0 : return traversalSuccessorContainer;
1671 : }
1672 : vector<string>
1673 0 : SgGraphNode::get_traversalSuccessorNamesContainer() {
1674 0 : vector<string> traversalSuccessorContainer;
1675 0 : return traversalSuccessorContainer;
1676 : }
1677 : size_t
1678 0 : SgGraphNode::get_numberOfTraversalSuccessors() {
1679 0 : return 0;
1680 : }
1681 : SgNode *
1682 0 : SgGraphNode::get_traversalSuccessorByIndex(size_t idx) {
1683 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgGraphNode" << " that has no successors!" << endl;
1684 0 : ROSE_ASSERT(false);
1685 : return NULL;
1686 : }
1687 : size_t
1688 0 : SgGraphNode::get_childIndex(SgNode *child) {
1689 0 : cout << "error: get_childIndex called on node of type " << "SgGraphNode" << " that has no successors!" << endl;
1690 0 : ROSE_ASSERT(false);
1691 : return 0;
1692 : }
1693 : vector<SgNode*>
1694 0 : SgGraphEdge::get_traversalSuccessorContainer() {
1695 0 : vector<SgNode*> traversalSuccessorContainer;
1696 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1697 0 : << "static: SgGraphEdge" << endl << "dynamic: " << this->sage_class_name() << endl;
1698 0 : cerr << "Aborting ..." << endl;
1699 0 : ROSE_ASSERT(false);
1700 : return traversalSuccessorContainer;
1701 : }
1702 :
1703 : vector<string>
1704 0 : SgGraphEdge::get_traversalSuccessorNamesContainer() {
1705 0 : vector<string> traversalSuccessorContainer;
1706 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1707 0 : << "static: SgGraphEdge" << endl << "dynamic: " << this->sage_class_name() << endl;
1708 0 : cerr << "Aborting ..." << endl;
1709 0 : ROSE_ASSERT(false);
1710 : return traversalSuccessorContainer;
1711 : }
1712 :
1713 : size_t
1714 0 : SgGraphEdge::get_numberOfTraversalSuccessors() {
1715 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1716 0 : << "static: SgGraphEdge" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
1717 0 : cerr << "Aborting ..." << endl;
1718 0 : ROSE_ASSERT(false);
1719 : return 42;
1720 : }
1721 :
1722 : SgNode*
1723 0 : SgGraphEdge::get_traversalSuccessorByIndex(size_t) {
1724 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1725 0 : << "static: SgGraphEdge" << endl << "dynamic: " << this->sage_class_name() << endl;
1726 0 : cerr << "Aborting ..." << endl;
1727 0 : ROSE_ASSERT(false);
1728 : return NULL;
1729 : }
1730 :
1731 : size_t
1732 0 : SgGraphEdge::get_childIndex(SgNode *) {
1733 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
1734 0 : << "static: SgGraphEdge" << endl << "dynamic: " << this->sage_class_name() << endl;
1735 0 : cerr << "Aborting ..." << endl;
1736 0 : ROSE_ASSERT(false);
1737 : return 42;
1738 : }
1739 :
1740 : vector<SgNode*>
1741 0 : SgDirectedGraphEdge::get_traversalSuccessorContainer() {
1742 0 : vector<SgNode*> traversalSuccessorContainer;
1743 0 : return traversalSuccessorContainer;
1744 : }
1745 : vector<string>
1746 0 : SgDirectedGraphEdge::get_traversalSuccessorNamesContainer() {
1747 0 : vector<string> traversalSuccessorContainer;
1748 0 : return traversalSuccessorContainer;
1749 : }
1750 : size_t
1751 0 : SgDirectedGraphEdge::get_numberOfTraversalSuccessors() {
1752 0 : return 0;
1753 : }
1754 : SgNode *
1755 0 : SgDirectedGraphEdge::get_traversalSuccessorByIndex(size_t idx) {
1756 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgDirectedGraphEdge" << " that has no successors!" << endl;
1757 0 : ROSE_ASSERT(false);
1758 : return NULL;
1759 : }
1760 : size_t
1761 0 : SgDirectedGraphEdge::get_childIndex(SgNode *child) {
1762 0 : cout << "error: get_childIndex called on node of type " << "SgDirectedGraphEdge" << " that has no successors!" << endl;
1763 0 : ROSE_ASSERT(false);
1764 : return 0;
1765 : }
1766 : vector<SgNode*>
1767 0 : SgUndirectedGraphEdge::get_traversalSuccessorContainer() {
1768 0 : vector<SgNode*> traversalSuccessorContainer;
1769 0 : return traversalSuccessorContainer;
1770 : }
1771 : vector<string>
1772 0 : SgUndirectedGraphEdge::get_traversalSuccessorNamesContainer() {
1773 0 : vector<string> traversalSuccessorContainer;
1774 0 : return traversalSuccessorContainer;
1775 : }
1776 : size_t
1777 0 : SgUndirectedGraphEdge::get_numberOfTraversalSuccessors() {
1778 0 : return 0;
1779 : }
1780 : SgNode *
1781 0 : SgUndirectedGraphEdge::get_traversalSuccessorByIndex(size_t idx) {
1782 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUndirectedGraphEdge" << " that has no successors!" << endl;
1783 0 : ROSE_ASSERT(false);
1784 : return NULL;
1785 : }
1786 : size_t
1787 0 : SgUndirectedGraphEdge::get_childIndex(SgNode *child) {
1788 0 : cout << "error: get_childIndex called on node of type " << "SgUndirectedGraphEdge" << " that has no successors!" << endl;
1789 0 : ROSE_ASSERT(false);
1790 : return 0;
1791 : }
1792 : vector<SgNode*>
1793 0 : SgGraphNodeList::get_traversalSuccessorContainer() {
1794 0 : vector<SgNode*> traversalSuccessorContainer;
1795 0 : return traversalSuccessorContainer;
1796 : }
1797 : vector<string>
1798 0 : SgGraphNodeList::get_traversalSuccessorNamesContainer() {
1799 0 : vector<string> traversalSuccessorContainer;
1800 0 : return traversalSuccessorContainer;
1801 : }
1802 : size_t
1803 0 : SgGraphNodeList::get_numberOfTraversalSuccessors() {
1804 0 : return 0;
1805 : }
1806 : SgNode *
1807 0 : SgGraphNodeList::get_traversalSuccessorByIndex(size_t idx) {
1808 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgGraphNodeList" << " that has no successors!" << endl;
1809 0 : ROSE_ASSERT(false);
1810 : return NULL;
1811 : }
1812 : size_t
1813 0 : SgGraphNodeList::get_childIndex(SgNode *child) {
1814 0 : cout << "error: get_childIndex called on node of type " << "SgGraphNodeList" << " that has no successors!" << endl;
1815 0 : ROSE_ASSERT(false);
1816 : return 0;
1817 : }
1818 : vector<SgNode*>
1819 0 : SgGraphEdgeList::get_traversalSuccessorContainer() {
1820 0 : vector<SgNode*> traversalSuccessorContainer;
1821 0 : return traversalSuccessorContainer;
1822 : }
1823 : vector<string>
1824 0 : SgGraphEdgeList::get_traversalSuccessorNamesContainer() {
1825 0 : vector<string> traversalSuccessorContainer;
1826 0 : return traversalSuccessorContainer;
1827 : }
1828 : size_t
1829 0 : SgGraphEdgeList::get_numberOfTraversalSuccessors() {
1830 0 : return 0;
1831 : }
1832 : SgNode *
1833 0 : SgGraphEdgeList::get_traversalSuccessorByIndex(size_t idx) {
1834 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgGraphEdgeList" << " that has no successors!" << endl;
1835 0 : ROSE_ASSERT(false);
1836 : return NULL;
1837 : }
1838 : size_t
1839 0 : SgGraphEdgeList::get_childIndex(SgNode *child) {
1840 0 : cout << "error: get_childIndex called on node of type " << "SgGraphEdgeList" << " that has no successors!" << endl;
1841 0 : ROSE_ASSERT(false);
1842 : return 0;
1843 : }
1844 : vector<SgNode*>
1845 0 : SgTypeTable::get_traversalSuccessorContainer() {
1846 0 : vector<SgNode*> traversalSuccessorContainer;
1847 0 : return traversalSuccessorContainer;
1848 : }
1849 : vector<string>
1850 0 : SgTypeTable::get_traversalSuccessorNamesContainer() {
1851 0 : vector<string> traversalSuccessorContainer;
1852 0 : return traversalSuccessorContainer;
1853 : }
1854 : size_t
1855 0 : SgTypeTable::get_numberOfTraversalSuccessors() {
1856 0 : return 0;
1857 : }
1858 : SgNode *
1859 0 : SgTypeTable::get_traversalSuccessorByIndex(size_t idx) {
1860 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgTypeTable" << " that has no successors!" << endl;
1861 0 : ROSE_ASSERT(false);
1862 : return NULL;
1863 : }
1864 : size_t
1865 0 : SgTypeTable::get_childIndex(SgNode *child) {
1866 0 : cout << "error: get_childIndex called on node of type " << "SgTypeTable" << " that has no successors!" << endl;
1867 0 : ROSE_ASSERT(false);
1868 : return 0;
1869 : }
1870 : vector<SgNode*>
1871 0 : SgNameGroup::get_traversalSuccessorContainer() {
1872 0 : vector<SgNode*> traversalSuccessorContainer;
1873 0 : return traversalSuccessorContainer;
1874 : }
1875 : vector<string>
1876 0 : SgNameGroup::get_traversalSuccessorNamesContainer() {
1877 0 : vector<string> traversalSuccessorContainer;
1878 0 : return traversalSuccessorContainer;
1879 : }
1880 : size_t
1881 0 : SgNameGroup::get_numberOfTraversalSuccessors() {
1882 0 : return 0;
1883 : }
1884 : SgNode *
1885 0 : SgNameGroup::get_traversalSuccessorByIndex(size_t idx) {
1886 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgNameGroup" << " that has no successors!" << endl;
1887 0 : ROSE_ASSERT(false);
1888 : return NULL;
1889 : }
1890 : size_t
1891 0 : SgNameGroup::get_childIndex(SgNode *child) {
1892 0 : cout << "error: get_childIndex called on node of type " << "SgNameGroup" << " that has no successors!" << endl;
1893 0 : ROSE_ASSERT(false);
1894 : return 0;
1895 : }
1896 : vector<SgNode*>
1897 0 : SgDimensionObject::get_traversalSuccessorContainer() {
1898 0 : vector<SgNode*> traversalSuccessorContainer;
1899 0 : return traversalSuccessorContainer;
1900 : }
1901 : vector<string>
1902 0 : SgDimensionObject::get_traversalSuccessorNamesContainer() {
1903 0 : vector<string> traversalSuccessorContainer;
1904 0 : return traversalSuccessorContainer;
1905 : }
1906 : size_t
1907 0 : SgDimensionObject::get_numberOfTraversalSuccessors() {
1908 0 : return 0;
1909 : }
1910 : SgNode *
1911 0 : SgDimensionObject::get_traversalSuccessorByIndex(size_t idx) {
1912 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgDimensionObject" << " that has no successors!" << endl;
1913 0 : ROSE_ASSERT(false);
1914 : return NULL;
1915 : }
1916 : size_t
1917 0 : SgDimensionObject::get_childIndex(SgNode *child) {
1918 0 : cout << "error: get_childIndex called on node of type " << "SgDimensionObject" << " that has no successors!" << endl;
1919 0 : ROSE_ASSERT(false);
1920 : return 0;
1921 : }
1922 : vector<SgNode*>
1923 0 : SgFormatItem::get_traversalSuccessorContainer() {
1924 0 : vector<SgNode*> traversalSuccessorContainer;
1925 0 : return traversalSuccessorContainer;
1926 : }
1927 : vector<string>
1928 0 : SgFormatItem::get_traversalSuccessorNamesContainer() {
1929 0 : vector<string> traversalSuccessorContainer;
1930 0 : return traversalSuccessorContainer;
1931 : }
1932 : size_t
1933 0 : SgFormatItem::get_numberOfTraversalSuccessors() {
1934 0 : return 0;
1935 : }
1936 : SgNode *
1937 0 : SgFormatItem::get_traversalSuccessorByIndex(size_t idx) {
1938 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgFormatItem" << " that has no successors!" << endl;
1939 0 : ROSE_ASSERT(false);
1940 : return NULL;
1941 : }
1942 : size_t
1943 0 : SgFormatItem::get_childIndex(SgNode *child) {
1944 0 : cout << "error: get_childIndex called on node of type " << "SgFormatItem" << " that has no successors!" << endl;
1945 0 : ROSE_ASSERT(false);
1946 : return 0;
1947 : }
1948 : vector<SgNode*>
1949 0 : SgFormatItemList::get_traversalSuccessorContainer() {
1950 0 : vector<SgNode*> traversalSuccessorContainer;
1951 0 : return traversalSuccessorContainer;
1952 : }
1953 : vector<string>
1954 0 : SgFormatItemList::get_traversalSuccessorNamesContainer() {
1955 0 : vector<string> traversalSuccessorContainer;
1956 0 : return traversalSuccessorContainer;
1957 : }
1958 : size_t
1959 0 : SgFormatItemList::get_numberOfTraversalSuccessors() {
1960 0 : return 0;
1961 : }
1962 : SgNode *
1963 0 : SgFormatItemList::get_traversalSuccessorByIndex(size_t idx) {
1964 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgFormatItemList" << " that has no successors!" << endl;
1965 0 : ROSE_ASSERT(false);
1966 : return NULL;
1967 : }
1968 : size_t
1969 0 : SgFormatItemList::get_childIndex(SgNode *child) {
1970 0 : cout << "error: get_childIndex called on node of type " << "SgFormatItemList" << " that has no successors!" << endl;
1971 0 : ROSE_ASSERT(false);
1972 : return 0;
1973 : }
1974 : vector<SgNode*>
1975 0 : SgDataStatementGroup::get_traversalSuccessorContainer() {
1976 0 : vector<SgNode*> traversalSuccessorContainer;
1977 0 : return traversalSuccessorContainer;
1978 : }
1979 : vector<string>
1980 0 : SgDataStatementGroup::get_traversalSuccessorNamesContainer() {
1981 0 : vector<string> traversalSuccessorContainer;
1982 0 : return traversalSuccessorContainer;
1983 : }
1984 : size_t
1985 0 : SgDataStatementGroup::get_numberOfTraversalSuccessors() {
1986 0 : return 0;
1987 : }
1988 : SgNode *
1989 0 : SgDataStatementGroup::get_traversalSuccessorByIndex(size_t idx) {
1990 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgDataStatementGroup" << " that has no successors!" << endl;
1991 0 : ROSE_ASSERT(false);
1992 : return NULL;
1993 : }
1994 : size_t
1995 0 : SgDataStatementGroup::get_childIndex(SgNode *child) {
1996 0 : cout << "error: get_childIndex called on node of type " << "SgDataStatementGroup" << " that has no successors!" << endl;
1997 0 : ROSE_ASSERT(false);
1998 : return 0;
1999 : }
2000 : vector<SgNode*>
2001 0 : SgDataStatementObject::get_traversalSuccessorContainer() {
2002 0 : vector<SgNode*> traversalSuccessorContainer;
2003 0 : return traversalSuccessorContainer;
2004 : }
2005 : vector<string>
2006 0 : SgDataStatementObject::get_traversalSuccessorNamesContainer() {
2007 0 : vector<string> traversalSuccessorContainer;
2008 0 : return traversalSuccessorContainer;
2009 : }
2010 : size_t
2011 0 : SgDataStatementObject::get_numberOfTraversalSuccessors() {
2012 0 : return 0;
2013 : }
2014 : SgNode *
2015 0 : SgDataStatementObject::get_traversalSuccessorByIndex(size_t idx) {
2016 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgDataStatementObject" << " that has no successors!" << endl;
2017 0 : ROSE_ASSERT(false);
2018 : return NULL;
2019 : }
2020 : size_t
2021 0 : SgDataStatementObject::get_childIndex(SgNode *child) {
2022 0 : cout << "error: get_childIndex called on node of type " << "SgDataStatementObject" << " that has no successors!" << endl;
2023 0 : ROSE_ASSERT(false);
2024 : return 0;
2025 : }
2026 : vector<SgNode*>
2027 0 : SgIncludeFile::get_traversalSuccessorContainer() {
2028 0 : vector<SgNode*> traversalSuccessorContainer;
2029 0 : traversalSuccessorContainer.reserve(p_include_file_list.size() + 0);
2030 0 : {
2031 0 : SgIncludeFilePtrList::iterator iter;
2032 0 : for (iter = p_include_file_list.begin(); iter != p_include_file_list.end(); iter++)
2033 0 : traversalSuccessorContainer.push_back(*iter);
2034 : }
2035 0 : return traversalSuccessorContainer;
2036 : }
2037 : vector<string>
2038 0 : SgIncludeFile::get_traversalSuccessorNamesContainer() {
2039 0 : vector<string> traversalSuccessorContainer;
2040 0 : int i = 0;
2041 0 : {
2042 0 : SgIncludeFilePtrList::iterator iter;
2043 0 : for (iter = p_include_file_list.begin(); iter != p_include_file_list.end(); (iter++,i++)) {
2044 0 : char buf[20];
2045 0 : sprintf(buf,"*[%d]",i);
2046 0 : traversalSuccessorContainer.push_back(buf);
2047 : }
2048 : }
2049 0 : return traversalSuccessorContainer;
2050 : }
2051 : size_t
2052 0 : SgIncludeFile::get_numberOfTraversalSuccessors() {
2053 0 : return p_include_file_list.size() + 0;
2054 : }
2055 : SgNode *
2056 0 : SgIncludeFile::get_traversalSuccessorByIndex(size_t idx) {
2057 0 : ROSE_ASSERT(idx < p_include_file_list.size());
2058 0 : return p_include_file_list[idx];
2059 : }
2060 : size_t
2061 0 : SgIncludeFile::get_childIndex(SgNode *child) {
2062 0 : SgIncludeFilePtrList::iterator itr = find(p_include_file_list.begin(), p_include_file_list.end(), child);
2063 0 : if (itr != p_include_file_list.end()) return itr - p_include_file_list.begin();
2064 : else return (size_t) -1;
2065 : }
2066 : vector<SgNode*>
2067 0 : SgDataStatementValue::get_traversalSuccessorContainer() {
2068 0 : vector<SgNode*> traversalSuccessorContainer;
2069 0 : return traversalSuccessorContainer;
2070 : }
2071 : vector<string>
2072 0 : SgDataStatementValue::get_traversalSuccessorNamesContainer() {
2073 0 : vector<string> traversalSuccessorContainer;
2074 0 : return traversalSuccessorContainer;
2075 : }
2076 : size_t
2077 0 : SgDataStatementValue::get_numberOfTraversalSuccessors() {
2078 0 : return 0;
2079 : }
2080 : SgNode *
2081 0 : SgDataStatementValue::get_traversalSuccessorByIndex(size_t idx) {
2082 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgDataStatementValue" << " that has no successors!" << endl;
2083 0 : ROSE_ASSERT(false);
2084 : return NULL;
2085 : }
2086 : size_t
2087 0 : SgDataStatementValue::get_childIndex(SgNode *child) {
2088 0 : cout << "error: get_childIndex called on node of type " << "SgDataStatementValue" << " that has no successors!" << endl;
2089 0 : ROSE_ASSERT(false);
2090 : return 0;
2091 : }
2092 : vector<SgNode*>
2093 0 : SgHeaderFileReport::get_traversalSuccessorContainer() {
2094 0 : vector<SgNode*> traversalSuccessorContainer;
2095 0 : return traversalSuccessorContainer;
2096 : }
2097 : vector<string>
2098 0 : SgHeaderFileReport::get_traversalSuccessorNamesContainer() {
2099 0 : vector<string> traversalSuccessorContainer;
2100 0 : return traversalSuccessorContainer;
2101 : }
2102 : size_t
2103 0 : SgHeaderFileReport::get_numberOfTraversalSuccessors() {
2104 0 : return 0;
2105 : }
2106 : SgNode *
2107 0 : SgHeaderFileReport::get_traversalSuccessorByIndex(size_t idx) {
2108 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgHeaderFileReport" << " that has no successors!" << endl;
2109 0 : ROSE_ASSERT(false);
2110 : return NULL;
2111 : }
2112 : size_t
2113 0 : SgHeaderFileReport::get_childIndex(SgNode *child) {
2114 0 : cout << "error: get_childIndex called on node of type " << "SgHeaderFileReport" << " that has no successors!" << endl;
2115 0 : ROSE_ASSERT(false);
2116 : return 0;
2117 : }
2118 : vector<SgNode*>
2119 0 : SgType::get_traversalSuccessorContainer() {
2120 0 : vector<SgNode*> traversalSuccessorContainer;
2121 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
2122 0 : << "static: SgType" << endl << "dynamic: " << this->sage_class_name() << endl;
2123 0 : cerr << "Aborting ..." << endl;
2124 0 : ROSE_ASSERT(false);
2125 : return traversalSuccessorContainer;
2126 : }
2127 :
2128 : vector<string>
2129 0 : SgType::get_traversalSuccessorNamesContainer() {
2130 0 : vector<string> traversalSuccessorContainer;
2131 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
2132 0 : << "static: SgType" << endl << "dynamic: " << this->sage_class_name() << endl;
2133 0 : cerr << "Aborting ..." << endl;
2134 0 : ROSE_ASSERT(false);
2135 : return traversalSuccessorContainer;
2136 : }
2137 :
2138 : size_t
2139 0 : SgType::get_numberOfTraversalSuccessors() {
2140 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
2141 0 : << "static: SgType" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
2142 0 : cerr << "Aborting ..." << endl;
2143 0 : ROSE_ASSERT(false);
2144 : return 42;
2145 : }
2146 :
2147 : SgNode*
2148 0 : SgType::get_traversalSuccessorByIndex(size_t) {
2149 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
2150 0 : << "static: SgType" << endl << "dynamic: " << this->sage_class_name() << endl;
2151 0 : cerr << "Aborting ..." << endl;
2152 0 : ROSE_ASSERT(false);
2153 : return NULL;
2154 : }
2155 :
2156 : size_t
2157 0 : SgType::get_childIndex(SgNode *) {
2158 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
2159 0 : << "static: SgType" << endl << "dynamic: " << this->sage_class_name() << endl;
2160 0 : cerr << "Aborting ..." << endl;
2161 0 : ROSE_ASSERT(false);
2162 : return 42;
2163 : }
2164 :
2165 : vector<SgNode*>
2166 0 : SgTypeUnknown::get_traversalSuccessorContainer() {
2167 0 : vector<SgNode*> traversalSuccessorContainer;
2168 0 : traversalSuccessorContainer.reserve(2);
2169 0 : traversalSuccessorContainer.push_back(p_type_kind);
2170 : // suppress handling of builtin_type date members
2171 0 : return traversalSuccessorContainer;
2172 : }
2173 : vector<string>
2174 0 : SgTypeUnknown::get_traversalSuccessorNamesContainer() {
2175 0 : vector<string> traversalSuccessorContainer;
2176 0 : traversalSuccessorContainer.push_back("p_type_kind");
2177 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2178 0 : return traversalSuccessorContainer;
2179 : }
2180 : size_t
2181 0 : SgTypeUnknown::get_numberOfTraversalSuccessors() {
2182 0 : return 2;
2183 : }
2184 : SgNode *
2185 0 : SgTypeUnknown::get_traversalSuccessorByIndex(size_t idx) {
2186 0 : switch (idx) {
2187 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2188 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2189 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2190 0 : ROSE_ASSERT(false);
2191 : return NULL;
2192 : }
2193 : }
2194 : size_t
2195 0 : SgTypeUnknown::get_childIndex(SgNode *child) {
2196 0 : if (child == p_type_kind) return 0;
2197 0 : else if (child == p_builtin_type) return 1;
2198 0 : else return (size_t) -1;
2199 : }
2200 : vector<SgNode*>
2201 0 : SgTypeChar::get_traversalSuccessorContainer() {
2202 0 : vector<SgNode*> traversalSuccessorContainer;
2203 0 : traversalSuccessorContainer.reserve(2);
2204 0 : traversalSuccessorContainer.push_back(p_type_kind);
2205 : // suppress handling of builtin_type date members
2206 0 : return traversalSuccessorContainer;
2207 : }
2208 : vector<string>
2209 0 : SgTypeChar::get_traversalSuccessorNamesContainer() {
2210 0 : vector<string> traversalSuccessorContainer;
2211 0 : traversalSuccessorContainer.push_back("p_type_kind");
2212 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2213 0 : return traversalSuccessorContainer;
2214 : }
2215 : size_t
2216 0 : SgTypeChar::get_numberOfTraversalSuccessors() {
2217 0 : return 2;
2218 : }
2219 : SgNode *
2220 0 : SgTypeChar::get_traversalSuccessorByIndex(size_t idx) {
2221 0 : switch (idx) {
2222 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2223 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2224 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2225 0 : ROSE_ASSERT(false);
2226 : return NULL;
2227 : }
2228 : }
2229 : size_t
2230 0 : SgTypeChar::get_childIndex(SgNode *child) {
2231 0 : if (child == p_type_kind) return 0;
2232 0 : else if (child == p_builtin_type) return 1;
2233 0 : else return (size_t) -1;
2234 : }
2235 : vector<SgNode*>
2236 0 : SgTypeSignedChar::get_traversalSuccessorContainer() {
2237 0 : vector<SgNode*> traversalSuccessorContainer;
2238 0 : traversalSuccessorContainer.reserve(2);
2239 0 : traversalSuccessorContainer.push_back(p_type_kind);
2240 : // suppress handling of builtin_type date members
2241 0 : return traversalSuccessorContainer;
2242 : }
2243 : vector<string>
2244 0 : SgTypeSignedChar::get_traversalSuccessorNamesContainer() {
2245 0 : vector<string> traversalSuccessorContainer;
2246 0 : traversalSuccessorContainer.push_back("p_type_kind");
2247 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2248 0 : return traversalSuccessorContainer;
2249 : }
2250 : size_t
2251 0 : SgTypeSignedChar::get_numberOfTraversalSuccessors() {
2252 0 : return 2;
2253 : }
2254 : SgNode *
2255 0 : SgTypeSignedChar::get_traversalSuccessorByIndex(size_t idx) {
2256 0 : switch (idx) {
2257 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2258 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2259 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2260 0 : ROSE_ASSERT(false);
2261 : return NULL;
2262 : }
2263 : }
2264 : size_t
2265 0 : SgTypeSignedChar::get_childIndex(SgNode *child) {
2266 0 : if (child == p_type_kind) return 0;
2267 0 : else if (child == p_builtin_type) return 1;
2268 0 : else return (size_t) -1;
2269 : }
2270 : vector<SgNode*>
2271 0 : SgTypeUnsignedChar::get_traversalSuccessorContainer() {
2272 0 : vector<SgNode*> traversalSuccessorContainer;
2273 0 : traversalSuccessorContainer.reserve(2);
2274 0 : traversalSuccessorContainer.push_back(p_type_kind);
2275 : // suppress handling of builtin_type date members
2276 0 : return traversalSuccessorContainer;
2277 : }
2278 : vector<string>
2279 0 : SgTypeUnsignedChar::get_traversalSuccessorNamesContainer() {
2280 0 : vector<string> traversalSuccessorContainer;
2281 0 : traversalSuccessorContainer.push_back("p_type_kind");
2282 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2283 0 : return traversalSuccessorContainer;
2284 : }
2285 : size_t
2286 0 : SgTypeUnsignedChar::get_numberOfTraversalSuccessors() {
2287 0 : return 2;
2288 : }
2289 : SgNode *
2290 0 : SgTypeUnsignedChar::get_traversalSuccessorByIndex(size_t idx) {
2291 0 : switch (idx) {
2292 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2293 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2294 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2295 0 : ROSE_ASSERT(false);
2296 : return NULL;
2297 : }
2298 : }
2299 : size_t
2300 0 : SgTypeUnsignedChar::get_childIndex(SgNode *child) {
2301 0 : if (child == p_type_kind) return 0;
2302 0 : else if (child == p_builtin_type) return 1;
2303 0 : else return (size_t) -1;
2304 : }
2305 : vector<SgNode*>
2306 0 : SgTypeShort::get_traversalSuccessorContainer() {
2307 0 : vector<SgNode*> traversalSuccessorContainer;
2308 0 : traversalSuccessorContainer.reserve(2);
2309 0 : traversalSuccessorContainer.push_back(p_type_kind);
2310 : // suppress handling of builtin_type date members
2311 0 : return traversalSuccessorContainer;
2312 : }
2313 : vector<string>
2314 0 : SgTypeShort::get_traversalSuccessorNamesContainer() {
2315 0 : vector<string> traversalSuccessorContainer;
2316 0 : traversalSuccessorContainer.push_back("p_type_kind");
2317 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2318 0 : return traversalSuccessorContainer;
2319 : }
2320 : size_t
2321 0 : SgTypeShort::get_numberOfTraversalSuccessors() {
2322 0 : return 2;
2323 : }
2324 : SgNode *
2325 0 : SgTypeShort::get_traversalSuccessorByIndex(size_t idx) {
2326 0 : switch (idx) {
2327 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2328 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2329 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2330 0 : ROSE_ASSERT(false);
2331 : return NULL;
2332 : }
2333 : }
2334 : size_t
2335 0 : SgTypeShort::get_childIndex(SgNode *child) {
2336 0 : if (child == p_type_kind) return 0;
2337 0 : else if (child == p_builtin_type) return 1;
2338 0 : else return (size_t) -1;
2339 : }
2340 : vector<SgNode*>
2341 0 : SgTypeSignedShort::get_traversalSuccessorContainer() {
2342 0 : vector<SgNode*> traversalSuccessorContainer;
2343 0 : traversalSuccessorContainer.reserve(2);
2344 0 : traversalSuccessorContainer.push_back(p_type_kind);
2345 : // suppress handling of builtin_type date members
2346 0 : return traversalSuccessorContainer;
2347 : }
2348 : vector<string>
2349 0 : SgTypeSignedShort::get_traversalSuccessorNamesContainer() {
2350 0 : vector<string> traversalSuccessorContainer;
2351 0 : traversalSuccessorContainer.push_back("p_type_kind");
2352 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2353 0 : return traversalSuccessorContainer;
2354 : }
2355 : size_t
2356 0 : SgTypeSignedShort::get_numberOfTraversalSuccessors() {
2357 0 : return 2;
2358 : }
2359 : SgNode *
2360 0 : SgTypeSignedShort::get_traversalSuccessorByIndex(size_t idx) {
2361 0 : switch (idx) {
2362 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2363 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2364 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2365 0 : ROSE_ASSERT(false);
2366 : return NULL;
2367 : }
2368 : }
2369 : size_t
2370 0 : SgTypeSignedShort::get_childIndex(SgNode *child) {
2371 0 : if (child == p_type_kind) return 0;
2372 0 : else if (child == p_builtin_type) return 1;
2373 0 : else return (size_t) -1;
2374 : }
2375 : vector<SgNode*>
2376 0 : SgTypeUnsignedShort::get_traversalSuccessorContainer() {
2377 0 : vector<SgNode*> traversalSuccessorContainer;
2378 0 : traversalSuccessorContainer.reserve(2);
2379 0 : traversalSuccessorContainer.push_back(p_type_kind);
2380 : // suppress handling of builtin_type date members
2381 0 : return traversalSuccessorContainer;
2382 : }
2383 : vector<string>
2384 0 : SgTypeUnsignedShort::get_traversalSuccessorNamesContainer() {
2385 0 : vector<string> traversalSuccessorContainer;
2386 0 : traversalSuccessorContainer.push_back("p_type_kind");
2387 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2388 0 : return traversalSuccessorContainer;
2389 : }
2390 : size_t
2391 0 : SgTypeUnsignedShort::get_numberOfTraversalSuccessors() {
2392 0 : return 2;
2393 : }
2394 : SgNode *
2395 0 : SgTypeUnsignedShort::get_traversalSuccessorByIndex(size_t idx) {
2396 0 : switch (idx) {
2397 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2398 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2399 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2400 0 : ROSE_ASSERT(false);
2401 : return NULL;
2402 : }
2403 : }
2404 : size_t
2405 0 : SgTypeUnsignedShort::get_childIndex(SgNode *child) {
2406 0 : if (child == p_type_kind) return 0;
2407 0 : else if (child == p_builtin_type) return 1;
2408 0 : else return (size_t) -1;
2409 : }
2410 : vector<SgNode*>
2411 0 : SgTypeInt::get_traversalSuccessorContainer() {
2412 0 : vector<SgNode*> traversalSuccessorContainer;
2413 0 : traversalSuccessorContainer.reserve(2);
2414 0 : traversalSuccessorContainer.push_back(p_type_kind);
2415 : // suppress handling of builtin_type date members
2416 0 : return traversalSuccessorContainer;
2417 : }
2418 : vector<string>
2419 0 : SgTypeInt::get_traversalSuccessorNamesContainer() {
2420 0 : vector<string> traversalSuccessorContainer;
2421 0 : traversalSuccessorContainer.push_back("p_type_kind");
2422 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2423 0 : return traversalSuccessorContainer;
2424 : }
2425 : size_t
2426 0 : SgTypeInt::get_numberOfTraversalSuccessors() {
2427 0 : return 2;
2428 : }
2429 : SgNode *
2430 0 : SgTypeInt::get_traversalSuccessorByIndex(size_t idx) {
2431 0 : switch (idx) {
2432 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2433 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2434 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2435 0 : ROSE_ASSERT(false);
2436 : return NULL;
2437 : }
2438 : }
2439 : size_t
2440 0 : SgTypeInt::get_childIndex(SgNode *child) {
2441 0 : if (child == p_type_kind) return 0;
2442 0 : else if (child == p_builtin_type) return 1;
2443 0 : else return (size_t) -1;
2444 : }
2445 : vector<SgNode*>
2446 0 : SgTypeSignedInt::get_traversalSuccessorContainer() {
2447 0 : vector<SgNode*> traversalSuccessorContainer;
2448 0 : traversalSuccessorContainer.reserve(2);
2449 0 : traversalSuccessorContainer.push_back(p_type_kind);
2450 : // suppress handling of builtin_type date members
2451 0 : return traversalSuccessorContainer;
2452 : }
2453 : vector<string>
2454 0 : SgTypeSignedInt::get_traversalSuccessorNamesContainer() {
2455 0 : vector<string> traversalSuccessorContainer;
2456 0 : traversalSuccessorContainer.push_back("p_type_kind");
2457 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2458 0 : return traversalSuccessorContainer;
2459 : }
2460 : size_t
2461 0 : SgTypeSignedInt::get_numberOfTraversalSuccessors() {
2462 0 : return 2;
2463 : }
2464 : SgNode *
2465 0 : SgTypeSignedInt::get_traversalSuccessorByIndex(size_t idx) {
2466 0 : switch (idx) {
2467 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2468 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2469 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2470 0 : ROSE_ASSERT(false);
2471 : return NULL;
2472 : }
2473 : }
2474 : size_t
2475 0 : SgTypeSignedInt::get_childIndex(SgNode *child) {
2476 0 : if (child == p_type_kind) return 0;
2477 0 : else if (child == p_builtin_type) return 1;
2478 0 : else return (size_t) -1;
2479 : }
2480 : vector<SgNode*>
2481 0 : SgTypeUnsignedInt::get_traversalSuccessorContainer() {
2482 0 : vector<SgNode*> traversalSuccessorContainer;
2483 0 : traversalSuccessorContainer.reserve(2);
2484 0 : traversalSuccessorContainer.push_back(p_type_kind);
2485 : // suppress handling of builtin_type date members
2486 0 : return traversalSuccessorContainer;
2487 : }
2488 : vector<string>
2489 0 : SgTypeUnsignedInt::get_traversalSuccessorNamesContainer() {
2490 0 : vector<string> traversalSuccessorContainer;
2491 0 : traversalSuccessorContainer.push_back("p_type_kind");
2492 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2493 0 : return traversalSuccessorContainer;
2494 : }
2495 : size_t
2496 0 : SgTypeUnsignedInt::get_numberOfTraversalSuccessors() {
2497 0 : return 2;
2498 : }
2499 : SgNode *
2500 0 : SgTypeUnsignedInt::get_traversalSuccessorByIndex(size_t idx) {
2501 0 : switch (idx) {
2502 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2503 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2504 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2505 0 : ROSE_ASSERT(false);
2506 : return NULL;
2507 : }
2508 : }
2509 : size_t
2510 0 : SgTypeUnsignedInt::get_childIndex(SgNode *child) {
2511 0 : if (child == p_type_kind) return 0;
2512 0 : else if (child == p_builtin_type) return 1;
2513 0 : else return (size_t) -1;
2514 : }
2515 : vector<SgNode*>
2516 0 : SgTypeLong::get_traversalSuccessorContainer() {
2517 0 : vector<SgNode*> traversalSuccessorContainer;
2518 0 : traversalSuccessorContainer.reserve(2);
2519 0 : traversalSuccessorContainer.push_back(p_type_kind);
2520 : // suppress handling of builtin_type date members
2521 0 : return traversalSuccessorContainer;
2522 : }
2523 : vector<string>
2524 0 : SgTypeLong::get_traversalSuccessorNamesContainer() {
2525 0 : vector<string> traversalSuccessorContainer;
2526 0 : traversalSuccessorContainer.push_back("p_type_kind");
2527 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2528 0 : return traversalSuccessorContainer;
2529 : }
2530 : size_t
2531 0 : SgTypeLong::get_numberOfTraversalSuccessors() {
2532 0 : return 2;
2533 : }
2534 : SgNode *
2535 0 : SgTypeLong::get_traversalSuccessorByIndex(size_t idx) {
2536 0 : switch (idx) {
2537 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2538 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2539 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2540 0 : ROSE_ASSERT(false);
2541 : return NULL;
2542 : }
2543 : }
2544 : size_t
2545 0 : SgTypeLong::get_childIndex(SgNode *child) {
2546 0 : if (child == p_type_kind) return 0;
2547 0 : else if (child == p_builtin_type) return 1;
2548 0 : else return (size_t) -1;
2549 : }
2550 : vector<SgNode*>
2551 0 : SgTypeSignedLong::get_traversalSuccessorContainer() {
2552 0 : vector<SgNode*> traversalSuccessorContainer;
2553 0 : traversalSuccessorContainer.reserve(2);
2554 0 : traversalSuccessorContainer.push_back(p_type_kind);
2555 : // suppress handling of builtin_type date members
2556 0 : return traversalSuccessorContainer;
2557 : }
2558 : vector<string>
2559 0 : SgTypeSignedLong::get_traversalSuccessorNamesContainer() {
2560 0 : vector<string> traversalSuccessorContainer;
2561 0 : traversalSuccessorContainer.push_back("p_type_kind");
2562 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2563 0 : return traversalSuccessorContainer;
2564 : }
2565 : size_t
2566 0 : SgTypeSignedLong::get_numberOfTraversalSuccessors() {
2567 0 : return 2;
2568 : }
2569 : SgNode *
2570 0 : SgTypeSignedLong::get_traversalSuccessorByIndex(size_t idx) {
2571 0 : switch (idx) {
2572 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2573 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2574 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2575 0 : ROSE_ASSERT(false);
2576 : return NULL;
2577 : }
2578 : }
2579 : size_t
2580 0 : SgTypeSignedLong::get_childIndex(SgNode *child) {
2581 0 : if (child == p_type_kind) return 0;
2582 0 : else if (child == p_builtin_type) return 1;
2583 0 : else return (size_t) -1;
2584 : }
2585 : vector<SgNode*>
2586 0 : SgTypeUnsignedLong::get_traversalSuccessorContainer() {
2587 0 : vector<SgNode*> traversalSuccessorContainer;
2588 0 : traversalSuccessorContainer.reserve(2);
2589 0 : traversalSuccessorContainer.push_back(p_type_kind);
2590 : // suppress handling of builtin_type date members
2591 0 : return traversalSuccessorContainer;
2592 : }
2593 : vector<string>
2594 0 : SgTypeUnsignedLong::get_traversalSuccessorNamesContainer() {
2595 0 : vector<string> traversalSuccessorContainer;
2596 0 : traversalSuccessorContainer.push_back("p_type_kind");
2597 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2598 0 : return traversalSuccessorContainer;
2599 : }
2600 : size_t
2601 0 : SgTypeUnsignedLong::get_numberOfTraversalSuccessors() {
2602 0 : return 2;
2603 : }
2604 : SgNode *
2605 0 : SgTypeUnsignedLong::get_traversalSuccessorByIndex(size_t idx) {
2606 0 : switch (idx) {
2607 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2608 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2609 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2610 0 : ROSE_ASSERT(false);
2611 : return NULL;
2612 : }
2613 : }
2614 : size_t
2615 0 : SgTypeUnsignedLong::get_childIndex(SgNode *child) {
2616 0 : if (child == p_type_kind) return 0;
2617 0 : else if (child == p_builtin_type) return 1;
2618 0 : else return (size_t) -1;
2619 : }
2620 : vector<SgNode*>
2621 0 : SgTypeVoid::get_traversalSuccessorContainer() {
2622 0 : vector<SgNode*> traversalSuccessorContainer;
2623 0 : traversalSuccessorContainer.reserve(2);
2624 0 : traversalSuccessorContainer.push_back(p_type_kind);
2625 : // suppress handling of builtin_type date members
2626 0 : return traversalSuccessorContainer;
2627 : }
2628 : vector<string>
2629 0 : SgTypeVoid::get_traversalSuccessorNamesContainer() {
2630 0 : vector<string> traversalSuccessorContainer;
2631 0 : traversalSuccessorContainer.push_back("p_type_kind");
2632 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2633 0 : return traversalSuccessorContainer;
2634 : }
2635 : size_t
2636 0 : SgTypeVoid::get_numberOfTraversalSuccessors() {
2637 0 : return 2;
2638 : }
2639 : SgNode *
2640 0 : SgTypeVoid::get_traversalSuccessorByIndex(size_t idx) {
2641 0 : switch (idx) {
2642 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2643 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2644 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2645 0 : ROSE_ASSERT(false);
2646 : return NULL;
2647 : }
2648 : }
2649 : size_t
2650 0 : SgTypeVoid::get_childIndex(SgNode *child) {
2651 0 : if (child == p_type_kind) return 0;
2652 0 : else if (child == p_builtin_type) return 1;
2653 0 : else return (size_t) -1;
2654 : }
2655 : vector<SgNode*>
2656 0 : SgTypeGlobalVoid::get_traversalSuccessorContainer() {
2657 0 : vector<SgNode*> traversalSuccessorContainer;
2658 0 : traversalSuccessorContainer.reserve(2);
2659 0 : traversalSuccessorContainer.push_back(p_type_kind);
2660 : // suppress handling of builtin_type date members
2661 0 : return traversalSuccessorContainer;
2662 : }
2663 : vector<string>
2664 0 : SgTypeGlobalVoid::get_traversalSuccessorNamesContainer() {
2665 0 : vector<string> traversalSuccessorContainer;
2666 0 : traversalSuccessorContainer.push_back("p_type_kind");
2667 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2668 0 : return traversalSuccessorContainer;
2669 : }
2670 : size_t
2671 0 : SgTypeGlobalVoid::get_numberOfTraversalSuccessors() {
2672 0 : return 2;
2673 : }
2674 : SgNode *
2675 0 : SgTypeGlobalVoid::get_traversalSuccessorByIndex(size_t idx) {
2676 0 : switch (idx) {
2677 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2678 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2679 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2680 0 : ROSE_ASSERT(false);
2681 : return NULL;
2682 : }
2683 : }
2684 : size_t
2685 0 : SgTypeGlobalVoid::get_childIndex(SgNode *child) {
2686 0 : if (child == p_type_kind) return 0;
2687 0 : else if (child == p_builtin_type) return 1;
2688 0 : else return (size_t) -1;
2689 : }
2690 : vector<SgNode*>
2691 0 : SgTypeWchar::get_traversalSuccessorContainer() {
2692 0 : vector<SgNode*> traversalSuccessorContainer;
2693 0 : traversalSuccessorContainer.reserve(2);
2694 0 : traversalSuccessorContainer.push_back(p_type_kind);
2695 : // suppress handling of builtin_type date members
2696 0 : return traversalSuccessorContainer;
2697 : }
2698 : vector<string>
2699 0 : SgTypeWchar::get_traversalSuccessorNamesContainer() {
2700 0 : vector<string> traversalSuccessorContainer;
2701 0 : traversalSuccessorContainer.push_back("p_type_kind");
2702 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2703 0 : return traversalSuccessorContainer;
2704 : }
2705 : size_t
2706 0 : SgTypeWchar::get_numberOfTraversalSuccessors() {
2707 0 : return 2;
2708 : }
2709 : SgNode *
2710 0 : SgTypeWchar::get_traversalSuccessorByIndex(size_t idx) {
2711 0 : switch (idx) {
2712 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2713 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2714 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2715 0 : ROSE_ASSERT(false);
2716 : return NULL;
2717 : }
2718 : }
2719 : size_t
2720 0 : SgTypeWchar::get_childIndex(SgNode *child) {
2721 0 : if (child == p_type_kind) return 0;
2722 0 : else if (child == p_builtin_type) return 1;
2723 0 : else return (size_t) -1;
2724 : }
2725 : vector<SgNode*>
2726 0 : SgTypeFloat::get_traversalSuccessorContainer() {
2727 0 : vector<SgNode*> traversalSuccessorContainer;
2728 0 : traversalSuccessorContainer.reserve(2);
2729 0 : traversalSuccessorContainer.push_back(p_type_kind);
2730 : // suppress handling of builtin_type date members
2731 0 : return traversalSuccessorContainer;
2732 : }
2733 : vector<string>
2734 0 : SgTypeFloat::get_traversalSuccessorNamesContainer() {
2735 0 : vector<string> traversalSuccessorContainer;
2736 0 : traversalSuccessorContainer.push_back("p_type_kind");
2737 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2738 0 : return traversalSuccessorContainer;
2739 : }
2740 : size_t
2741 0 : SgTypeFloat::get_numberOfTraversalSuccessors() {
2742 0 : return 2;
2743 : }
2744 : SgNode *
2745 0 : SgTypeFloat::get_traversalSuccessorByIndex(size_t idx) {
2746 0 : switch (idx) {
2747 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2748 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2749 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2750 0 : ROSE_ASSERT(false);
2751 : return NULL;
2752 : }
2753 : }
2754 : size_t
2755 0 : SgTypeFloat::get_childIndex(SgNode *child) {
2756 0 : if (child == p_type_kind) return 0;
2757 0 : else if (child == p_builtin_type) return 1;
2758 0 : else return (size_t) -1;
2759 : }
2760 : vector<SgNode*>
2761 0 : SgTypeDouble::get_traversalSuccessorContainer() {
2762 0 : vector<SgNode*> traversalSuccessorContainer;
2763 0 : traversalSuccessorContainer.reserve(2);
2764 0 : traversalSuccessorContainer.push_back(p_type_kind);
2765 : // suppress handling of builtin_type date members
2766 0 : return traversalSuccessorContainer;
2767 : }
2768 : vector<string>
2769 0 : SgTypeDouble::get_traversalSuccessorNamesContainer() {
2770 0 : vector<string> traversalSuccessorContainer;
2771 0 : traversalSuccessorContainer.push_back("p_type_kind");
2772 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2773 0 : return traversalSuccessorContainer;
2774 : }
2775 : size_t
2776 0 : SgTypeDouble::get_numberOfTraversalSuccessors() {
2777 0 : return 2;
2778 : }
2779 : SgNode *
2780 0 : SgTypeDouble::get_traversalSuccessorByIndex(size_t idx) {
2781 0 : switch (idx) {
2782 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2783 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2784 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2785 0 : ROSE_ASSERT(false);
2786 : return NULL;
2787 : }
2788 : }
2789 : size_t
2790 0 : SgTypeDouble::get_childIndex(SgNode *child) {
2791 0 : if (child == p_type_kind) return 0;
2792 0 : else if (child == p_builtin_type) return 1;
2793 0 : else return (size_t) -1;
2794 : }
2795 : vector<SgNode*>
2796 0 : SgTypeLongLong::get_traversalSuccessorContainer() {
2797 0 : vector<SgNode*> traversalSuccessorContainer;
2798 0 : traversalSuccessorContainer.reserve(2);
2799 0 : traversalSuccessorContainer.push_back(p_type_kind);
2800 : // suppress handling of builtin_type date members
2801 0 : return traversalSuccessorContainer;
2802 : }
2803 : vector<string>
2804 0 : SgTypeLongLong::get_traversalSuccessorNamesContainer() {
2805 0 : vector<string> traversalSuccessorContainer;
2806 0 : traversalSuccessorContainer.push_back("p_type_kind");
2807 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2808 0 : return traversalSuccessorContainer;
2809 : }
2810 : size_t
2811 0 : SgTypeLongLong::get_numberOfTraversalSuccessors() {
2812 0 : return 2;
2813 : }
2814 : SgNode *
2815 0 : SgTypeLongLong::get_traversalSuccessorByIndex(size_t idx) {
2816 0 : switch (idx) {
2817 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2818 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2819 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2820 0 : ROSE_ASSERT(false);
2821 : return NULL;
2822 : }
2823 : }
2824 : size_t
2825 0 : SgTypeLongLong::get_childIndex(SgNode *child) {
2826 0 : if (child == p_type_kind) return 0;
2827 0 : else if (child == p_builtin_type) return 1;
2828 0 : else return (size_t) -1;
2829 : }
2830 : vector<SgNode*>
2831 0 : SgTypeSignedLongLong::get_traversalSuccessorContainer() {
2832 0 : vector<SgNode*> traversalSuccessorContainer;
2833 0 : traversalSuccessorContainer.reserve(2);
2834 0 : traversalSuccessorContainer.push_back(p_type_kind);
2835 : // suppress handling of builtin_type date members
2836 0 : return traversalSuccessorContainer;
2837 : }
2838 : vector<string>
2839 0 : SgTypeSignedLongLong::get_traversalSuccessorNamesContainer() {
2840 0 : vector<string> traversalSuccessorContainer;
2841 0 : traversalSuccessorContainer.push_back("p_type_kind");
2842 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2843 0 : return traversalSuccessorContainer;
2844 : }
2845 : size_t
2846 0 : SgTypeSignedLongLong::get_numberOfTraversalSuccessors() {
2847 0 : return 2;
2848 : }
2849 : SgNode *
2850 0 : SgTypeSignedLongLong::get_traversalSuccessorByIndex(size_t idx) {
2851 0 : switch (idx) {
2852 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2853 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2854 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2855 0 : ROSE_ASSERT(false);
2856 : return NULL;
2857 : }
2858 : }
2859 : size_t
2860 0 : SgTypeSignedLongLong::get_childIndex(SgNode *child) {
2861 0 : if (child == p_type_kind) return 0;
2862 0 : else if (child == p_builtin_type) return 1;
2863 0 : else return (size_t) -1;
2864 : }
2865 : vector<SgNode*>
2866 0 : SgTypeUnsignedLongLong::get_traversalSuccessorContainer() {
2867 0 : vector<SgNode*> traversalSuccessorContainer;
2868 0 : traversalSuccessorContainer.reserve(2);
2869 0 : traversalSuccessorContainer.push_back(p_type_kind);
2870 : // suppress handling of builtin_type date members
2871 0 : return traversalSuccessorContainer;
2872 : }
2873 : vector<string>
2874 0 : SgTypeUnsignedLongLong::get_traversalSuccessorNamesContainer() {
2875 0 : vector<string> traversalSuccessorContainer;
2876 0 : traversalSuccessorContainer.push_back("p_type_kind");
2877 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2878 0 : return traversalSuccessorContainer;
2879 : }
2880 : size_t
2881 0 : SgTypeUnsignedLongLong::get_numberOfTraversalSuccessors() {
2882 0 : return 2;
2883 : }
2884 : SgNode *
2885 0 : SgTypeUnsignedLongLong::get_traversalSuccessorByIndex(size_t idx) {
2886 0 : switch (idx) {
2887 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2888 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2889 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2890 0 : ROSE_ASSERT(false);
2891 : return NULL;
2892 : }
2893 : }
2894 : size_t
2895 0 : SgTypeUnsignedLongLong::get_childIndex(SgNode *child) {
2896 0 : if (child == p_type_kind) return 0;
2897 0 : else if (child == p_builtin_type) return 1;
2898 0 : else return (size_t) -1;
2899 : }
2900 : vector<SgNode*>
2901 0 : SgTypeSigned128bitInteger::get_traversalSuccessorContainer() {
2902 0 : vector<SgNode*> traversalSuccessorContainer;
2903 0 : traversalSuccessorContainer.reserve(2);
2904 0 : traversalSuccessorContainer.push_back(p_type_kind);
2905 : // suppress handling of builtin_type date members
2906 0 : return traversalSuccessorContainer;
2907 : }
2908 : vector<string>
2909 0 : SgTypeSigned128bitInteger::get_traversalSuccessorNamesContainer() {
2910 0 : vector<string> traversalSuccessorContainer;
2911 0 : traversalSuccessorContainer.push_back("p_type_kind");
2912 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2913 0 : return traversalSuccessorContainer;
2914 : }
2915 : size_t
2916 0 : SgTypeSigned128bitInteger::get_numberOfTraversalSuccessors() {
2917 0 : return 2;
2918 : }
2919 : SgNode *
2920 0 : SgTypeSigned128bitInteger::get_traversalSuccessorByIndex(size_t idx) {
2921 0 : switch (idx) {
2922 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2923 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2924 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2925 0 : ROSE_ASSERT(false);
2926 : return NULL;
2927 : }
2928 : }
2929 : size_t
2930 0 : SgTypeSigned128bitInteger::get_childIndex(SgNode *child) {
2931 0 : if (child == p_type_kind) return 0;
2932 0 : else if (child == p_builtin_type) return 1;
2933 0 : else return (size_t) -1;
2934 : }
2935 : vector<SgNode*>
2936 0 : SgTypeUnsigned128bitInteger::get_traversalSuccessorContainer() {
2937 0 : vector<SgNode*> traversalSuccessorContainer;
2938 0 : traversalSuccessorContainer.reserve(2);
2939 0 : traversalSuccessorContainer.push_back(p_type_kind);
2940 : // suppress handling of builtin_type date members
2941 0 : return traversalSuccessorContainer;
2942 : }
2943 : vector<string>
2944 0 : SgTypeUnsigned128bitInteger::get_traversalSuccessorNamesContainer() {
2945 0 : vector<string> traversalSuccessorContainer;
2946 0 : traversalSuccessorContainer.push_back("p_type_kind");
2947 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2948 0 : return traversalSuccessorContainer;
2949 : }
2950 : size_t
2951 0 : SgTypeUnsigned128bitInteger::get_numberOfTraversalSuccessors() {
2952 0 : return 2;
2953 : }
2954 : SgNode *
2955 0 : SgTypeUnsigned128bitInteger::get_traversalSuccessorByIndex(size_t idx) {
2956 0 : switch (idx) {
2957 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2958 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2959 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2960 0 : ROSE_ASSERT(false);
2961 : return NULL;
2962 : }
2963 : }
2964 : size_t
2965 0 : SgTypeUnsigned128bitInteger::get_childIndex(SgNode *child) {
2966 0 : if (child == p_type_kind) return 0;
2967 0 : else if (child == p_builtin_type) return 1;
2968 0 : else return (size_t) -1;
2969 : }
2970 : vector<SgNode*>
2971 0 : SgTypeFloat80::get_traversalSuccessorContainer() {
2972 0 : vector<SgNode*> traversalSuccessorContainer;
2973 0 : traversalSuccessorContainer.reserve(2);
2974 0 : traversalSuccessorContainer.push_back(p_type_kind);
2975 : // suppress handling of builtin_type date members
2976 0 : return traversalSuccessorContainer;
2977 : }
2978 : vector<string>
2979 0 : SgTypeFloat80::get_traversalSuccessorNamesContainer() {
2980 0 : vector<string> traversalSuccessorContainer;
2981 0 : traversalSuccessorContainer.push_back("p_type_kind");
2982 0 : traversalSuccessorContainer.push_back("p_builtin_type");
2983 0 : return traversalSuccessorContainer;
2984 : }
2985 : size_t
2986 0 : SgTypeFloat80::get_numberOfTraversalSuccessors() {
2987 0 : return 2;
2988 : }
2989 : SgNode *
2990 0 : SgTypeFloat80::get_traversalSuccessorByIndex(size_t idx) {
2991 0 : switch (idx) {
2992 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
2993 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
2994 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
2995 0 : ROSE_ASSERT(false);
2996 : return NULL;
2997 : }
2998 : }
2999 : size_t
3000 0 : SgTypeFloat80::get_childIndex(SgNode *child) {
3001 0 : if (child == p_type_kind) return 0;
3002 0 : else if (child == p_builtin_type) return 1;
3003 0 : else return (size_t) -1;
3004 : }
3005 : vector<SgNode*>
3006 0 : SgTypeLongDouble::get_traversalSuccessorContainer() {
3007 0 : vector<SgNode*> traversalSuccessorContainer;
3008 0 : traversalSuccessorContainer.reserve(2);
3009 0 : traversalSuccessorContainer.push_back(p_type_kind);
3010 : // suppress handling of builtin_type date members
3011 0 : return traversalSuccessorContainer;
3012 : }
3013 : vector<string>
3014 0 : SgTypeLongDouble::get_traversalSuccessorNamesContainer() {
3015 0 : vector<string> traversalSuccessorContainer;
3016 0 : traversalSuccessorContainer.push_back("p_type_kind");
3017 0 : traversalSuccessorContainer.push_back("p_builtin_type");
3018 0 : return traversalSuccessorContainer;
3019 : }
3020 : size_t
3021 0 : SgTypeLongDouble::get_numberOfTraversalSuccessors() {
3022 0 : return 2;
3023 : }
3024 : SgNode *
3025 0 : SgTypeLongDouble::get_traversalSuccessorByIndex(size_t idx) {
3026 0 : switch (idx) {
3027 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3028 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
3029 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3030 0 : ROSE_ASSERT(false);
3031 : return NULL;
3032 : }
3033 : }
3034 : size_t
3035 0 : SgTypeLongDouble::get_childIndex(SgNode *child) {
3036 0 : if (child == p_type_kind) return 0;
3037 0 : else if (child == p_builtin_type) return 1;
3038 0 : else return (size_t) -1;
3039 : }
3040 : vector<SgNode*>
3041 0 : SgTypeString::get_traversalSuccessorContainer() {
3042 0 : vector<SgNode*> traversalSuccessorContainer;
3043 0 : traversalSuccessorContainer.reserve(2);
3044 0 : traversalSuccessorContainer.push_back(p_type_kind);
3045 0 : traversalSuccessorContainer.push_back(p_lengthExpression);
3046 0 : return traversalSuccessorContainer;
3047 : }
3048 : vector<string>
3049 0 : SgTypeString::get_traversalSuccessorNamesContainer() {
3050 0 : vector<string> traversalSuccessorContainer;
3051 0 : traversalSuccessorContainer.push_back("p_type_kind");
3052 0 : traversalSuccessorContainer.push_back("p_lengthExpression");
3053 0 : return traversalSuccessorContainer;
3054 : }
3055 : size_t
3056 0 : SgTypeString::get_numberOfTraversalSuccessors() {
3057 0 : return 2;
3058 : }
3059 : SgNode *
3060 0 : SgTypeString::get_traversalSuccessorByIndex(size_t idx) {
3061 0 : switch (idx) {
3062 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3063 0 : case 1: ROSE_ASSERT(p_lengthExpression == NULL || p_lengthExpression != NULL); return p_lengthExpression;
3064 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3065 0 : ROSE_ASSERT(false);
3066 : return NULL;
3067 : }
3068 : }
3069 : size_t
3070 0 : SgTypeString::get_childIndex(SgNode *child) {
3071 0 : if (child == p_type_kind) return 0;
3072 0 : else if (child == p_lengthExpression) return 1;
3073 0 : else return (size_t) -1;
3074 : }
3075 : vector<SgNode*>
3076 0 : SgTypeBool::get_traversalSuccessorContainer() {
3077 0 : vector<SgNode*> traversalSuccessorContainer;
3078 0 : traversalSuccessorContainer.reserve(2);
3079 0 : traversalSuccessorContainer.push_back(p_type_kind);
3080 : // suppress handling of builtin_type date members
3081 0 : return traversalSuccessorContainer;
3082 : }
3083 : vector<string>
3084 0 : SgTypeBool::get_traversalSuccessorNamesContainer() {
3085 0 : vector<string> traversalSuccessorContainer;
3086 0 : traversalSuccessorContainer.push_back("p_type_kind");
3087 0 : traversalSuccessorContainer.push_back("p_builtin_type");
3088 0 : return traversalSuccessorContainer;
3089 : }
3090 : size_t
3091 0 : SgTypeBool::get_numberOfTraversalSuccessors() {
3092 0 : return 2;
3093 : }
3094 : SgNode *
3095 0 : SgTypeBool::get_traversalSuccessorByIndex(size_t idx) {
3096 0 : switch (idx) {
3097 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3098 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
3099 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3100 0 : ROSE_ASSERT(false);
3101 : return NULL;
3102 : }
3103 : }
3104 : size_t
3105 0 : SgTypeBool::get_childIndex(SgNode *child) {
3106 0 : if (child == p_type_kind) return 0;
3107 0 : else if (child == p_builtin_type) return 1;
3108 0 : else return (size_t) -1;
3109 : }
3110 : vector<SgNode*>
3111 0 : SgPointerType::get_traversalSuccessorContainer() {
3112 0 : vector<SgNode*> traversalSuccessorContainer;
3113 0 : traversalSuccessorContainer.reserve(2);
3114 0 : traversalSuccessorContainer.push_back(p_type_kind);
3115 0 : traversalSuccessorContainer.push_back(p_base_type);
3116 0 : return traversalSuccessorContainer;
3117 : }
3118 : vector<string>
3119 0 : SgPointerType::get_traversalSuccessorNamesContainer() {
3120 0 : vector<string> traversalSuccessorContainer;
3121 0 : traversalSuccessorContainer.push_back("p_type_kind");
3122 0 : traversalSuccessorContainer.push_back("p_base_type");
3123 0 : return traversalSuccessorContainer;
3124 : }
3125 : size_t
3126 0 : SgPointerType::get_numberOfTraversalSuccessors() {
3127 0 : return 2;
3128 : }
3129 : SgNode *
3130 0 : SgPointerType::get_traversalSuccessorByIndex(size_t idx) {
3131 0 : switch (idx) {
3132 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3133 0 : case 1: ROSE_ASSERT(p_base_type == NULL || p_base_type != NULL); return p_base_type;
3134 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3135 0 : ROSE_ASSERT(false);
3136 : return NULL;
3137 : }
3138 : }
3139 : size_t
3140 0 : SgPointerType::get_childIndex(SgNode *child) {
3141 0 : if (child == p_type_kind) return 0;
3142 0 : else if (child == p_base_type) return 1;
3143 0 : else return (size_t) -1;
3144 : }
3145 : vector<SgNode*>
3146 0 : SgPointerMemberType::get_traversalSuccessorContainer() {
3147 0 : vector<SgNode*> traversalSuccessorContainer;
3148 0 : traversalSuccessorContainer.reserve(2);
3149 0 : traversalSuccessorContainer.push_back(p_type_kind);
3150 0 : traversalSuccessorContainer.push_back(p_base_type);
3151 0 : return traversalSuccessorContainer;
3152 : }
3153 : vector<string>
3154 0 : SgPointerMemberType::get_traversalSuccessorNamesContainer() {
3155 0 : vector<string> traversalSuccessorContainer;
3156 0 : traversalSuccessorContainer.push_back("p_type_kind");
3157 0 : traversalSuccessorContainer.push_back("p_base_type");
3158 0 : return traversalSuccessorContainer;
3159 : }
3160 : size_t
3161 382 : SgPointerMemberType::get_numberOfTraversalSuccessors() {
3162 382 : return 2;
3163 : }
3164 : SgNode *
3165 764 : SgPointerMemberType::get_traversalSuccessorByIndex(size_t idx) {
3166 764 : switch (idx) {
3167 382 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3168 382 : case 1: ROSE_ASSERT(p_base_type == NULL || p_base_type != NULL); return p_base_type;
3169 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3170 0 : ROSE_ASSERT(false);
3171 : return NULL;
3172 : }
3173 : }
3174 : size_t
3175 0 : SgPointerMemberType::get_childIndex(SgNode *child) {
3176 0 : if (child == p_type_kind) return 0;
3177 0 : else if (child == p_base_type) return 1;
3178 0 : else return (size_t) -1;
3179 : }
3180 : vector<SgNode*>
3181 0 : SgReferenceType::get_traversalSuccessorContainer() {
3182 0 : vector<SgNode*> traversalSuccessorContainer;
3183 0 : traversalSuccessorContainer.reserve(1);
3184 0 : traversalSuccessorContainer.push_back(p_type_kind);
3185 0 : return traversalSuccessorContainer;
3186 : }
3187 : vector<string>
3188 0 : SgReferenceType::get_traversalSuccessorNamesContainer() {
3189 0 : vector<string> traversalSuccessorContainer;
3190 0 : traversalSuccessorContainer.push_back("p_type_kind");
3191 0 : return traversalSuccessorContainer;
3192 : }
3193 : size_t
3194 0 : SgReferenceType::get_numberOfTraversalSuccessors() {
3195 0 : return 1;
3196 : }
3197 : SgNode *
3198 0 : SgReferenceType::get_traversalSuccessorByIndex(size_t idx) {
3199 0 : switch (idx) {
3200 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3201 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3202 0 : ROSE_ASSERT(false);
3203 : return NULL;
3204 : }
3205 : }
3206 : size_t
3207 0 : SgReferenceType::get_childIndex(SgNode *child) {
3208 0 : if (child == p_type_kind) return 0;
3209 0 : else return (size_t) -1;
3210 : }
3211 : vector<SgNode*>
3212 0 : SgNamedType::get_traversalSuccessorContainer() {
3213 0 : vector<SgNode*> traversalSuccessorContainer;
3214 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
3215 0 : << "static: SgNamedType" << endl << "dynamic: " << this->sage_class_name() << endl;
3216 0 : cerr << "Aborting ..." << endl;
3217 0 : ROSE_ASSERT(false);
3218 : return traversalSuccessorContainer;
3219 : }
3220 :
3221 : vector<string>
3222 0 : SgNamedType::get_traversalSuccessorNamesContainer() {
3223 0 : vector<string> traversalSuccessorContainer;
3224 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
3225 0 : << "static: SgNamedType" << endl << "dynamic: " << this->sage_class_name() << endl;
3226 0 : cerr << "Aborting ..." << endl;
3227 0 : ROSE_ASSERT(false);
3228 : return traversalSuccessorContainer;
3229 : }
3230 :
3231 : size_t
3232 0 : SgNamedType::get_numberOfTraversalSuccessors() {
3233 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
3234 0 : << "static: SgNamedType" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
3235 0 : cerr << "Aborting ..." << endl;
3236 0 : ROSE_ASSERT(false);
3237 : return 42;
3238 : }
3239 :
3240 : SgNode*
3241 0 : SgNamedType::get_traversalSuccessorByIndex(size_t) {
3242 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
3243 0 : << "static: SgNamedType" << endl << "dynamic: " << this->sage_class_name() << endl;
3244 0 : cerr << "Aborting ..." << endl;
3245 0 : ROSE_ASSERT(false);
3246 : return NULL;
3247 : }
3248 :
3249 : size_t
3250 0 : SgNamedType::get_childIndex(SgNode *) {
3251 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
3252 0 : << "static: SgNamedType" << endl << "dynamic: " << this->sage_class_name() << endl;
3253 0 : cerr << "Aborting ..." << endl;
3254 0 : ROSE_ASSERT(false);
3255 : return 42;
3256 : }
3257 :
3258 : vector<SgNode*>
3259 0 : SgClassType::get_traversalSuccessorContainer() {
3260 0 : vector<SgNode*> traversalSuccessorContainer;
3261 0 : traversalSuccessorContainer.reserve(3);
3262 0 : traversalSuccessorContainer.push_back(p_type_kind);
3263 : // suppress handling of builtin_type date members
3264 0 : traversalSuccessorContainer.push_back(p_declaration);
3265 0 : return traversalSuccessorContainer;
3266 : }
3267 : vector<string>
3268 0 : SgClassType::get_traversalSuccessorNamesContainer() {
3269 0 : vector<string> traversalSuccessorContainer;
3270 0 : traversalSuccessorContainer.push_back("p_type_kind");
3271 0 : traversalSuccessorContainer.push_back("p_builtin_type");
3272 0 : traversalSuccessorContainer.push_back("p_declaration");
3273 0 : return traversalSuccessorContainer;
3274 : }
3275 : size_t
3276 0 : SgClassType::get_numberOfTraversalSuccessors() {
3277 0 : return 3;
3278 : }
3279 : SgNode *
3280 0 : SgClassType::get_traversalSuccessorByIndex(size_t idx) {
3281 0 : switch (idx) {
3282 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3283 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
3284 0 : case 2: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
3285 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3286 0 : ROSE_ASSERT(false);
3287 : return NULL;
3288 : }
3289 : }
3290 : size_t
3291 0 : SgClassType::get_childIndex(SgNode *child) {
3292 0 : if (child == p_type_kind) return 0;
3293 0 : else if (child == p_builtin_type) return 1;
3294 0 : else if (child == p_declaration) return 2;
3295 0 : else return (size_t) -1;
3296 : }
3297 : vector<SgNode*>
3298 0 : SgEnumType::get_traversalSuccessorContainer() {
3299 0 : vector<SgNode*> traversalSuccessorContainer;
3300 0 : traversalSuccessorContainer.reserve(3);
3301 0 : traversalSuccessorContainer.push_back(p_type_kind);
3302 : // suppress handling of builtin_type date members
3303 0 : traversalSuccessorContainer.push_back(p_declaration);
3304 0 : return traversalSuccessorContainer;
3305 : }
3306 : vector<string>
3307 0 : SgEnumType::get_traversalSuccessorNamesContainer() {
3308 0 : vector<string> traversalSuccessorContainer;
3309 0 : traversalSuccessorContainer.push_back("p_type_kind");
3310 0 : traversalSuccessorContainer.push_back("p_builtin_type");
3311 0 : traversalSuccessorContainer.push_back("p_declaration");
3312 0 : return traversalSuccessorContainer;
3313 : }
3314 : size_t
3315 0 : SgEnumType::get_numberOfTraversalSuccessors() {
3316 0 : return 3;
3317 : }
3318 : SgNode *
3319 0 : SgEnumType::get_traversalSuccessorByIndex(size_t idx) {
3320 0 : switch (idx) {
3321 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3322 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
3323 0 : case 2: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
3324 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3325 0 : ROSE_ASSERT(false);
3326 : return NULL;
3327 : }
3328 : }
3329 : size_t
3330 0 : SgEnumType::get_childIndex(SgNode *child) {
3331 0 : if (child == p_type_kind) return 0;
3332 0 : else if (child == p_builtin_type) return 1;
3333 0 : else if (child == p_declaration) return 2;
3334 0 : else return (size_t) -1;
3335 : }
3336 : vector<SgNode*>
3337 0 : SgTypedefType::get_traversalSuccessorContainer() {
3338 0 : vector<SgNode*> traversalSuccessorContainer;
3339 0 : traversalSuccessorContainer.reserve(3);
3340 0 : traversalSuccessorContainer.push_back(p_type_kind);
3341 : // suppress handling of builtin_type date members
3342 0 : traversalSuccessorContainer.push_back(p_declaration);
3343 0 : return traversalSuccessorContainer;
3344 : }
3345 : vector<string>
3346 0 : SgTypedefType::get_traversalSuccessorNamesContainer() {
3347 0 : vector<string> traversalSuccessorContainer;
3348 0 : traversalSuccessorContainer.push_back("p_type_kind");
3349 0 : traversalSuccessorContainer.push_back("p_builtin_type");
3350 0 : traversalSuccessorContainer.push_back("p_declaration");
3351 0 : return traversalSuccessorContainer;
3352 : }
3353 : size_t
3354 0 : SgTypedefType::get_numberOfTraversalSuccessors() {
3355 0 : return 3;
3356 : }
3357 : SgNode *
3358 0 : SgTypedefType::get_traversalSuccessorByIndex(size_t idx) {
3359 0 : switch (idx) {
3360 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3361 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
3362 0 : case 2: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
3363 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3364 0 : ROSE_ASSERT(false);
3365 : return NULL;
3366 : }
3367 : }
3368 : size_t
3369 0 : SgTypedefType::get_childIndex(SgNode *child) {
3370 0 : if (child == p_type_kind) return 0;
3371 0 : else if (child == p_builtin_type) return 1;
3372 0 : else if (child == p_declaration) return 2;
3373 0 : else return (size_t) -1;
3374 : }
3375 : vector<SgNode*>
3376 0 : SgNonrealType::get_traversalSuccessorContainer() {
3377 0 : vector<SgNode*> traversalSuccessorContainer;
3378 0 : traversalSuccessorContainer.reserve(3);
3379 0 : traversalSuccessorContainer.push_back(p_type_kind);
3380 : // suppress handling of builtin_type date members
3381 0 : traversalSuccessorContainer.push_back(p_declaration);
3382 0 : return traversalSuccessorContainer;
3383 : }
3384 : vector<string>
3385 0 : SgNonrealType::get_traversalSuccessorNamesContainer() {
3386 0 : vector<string> traversalSuccessorContainer;
3387 0 : traversalSuccessorContainer.push_back("p_type_kind");
3388 0 : traversalSuccessorContainer.push_back("p_builtin_type");
3389 0 : traversalSuccessorContainer.push_back("p_declaration");
3390 0 : return traversalSuccessorContainer;
3391 : }
3392 : size_t
3393 742 : SgNonrealType::get_numberOfTraversalSuccessors() {
3394 742 : return 3;
3395 : }
3396 : SgNode *
3397 2226 : SgNonrealType::get_traversalSuccessorByIndex(size_t idx) {
3398 2226 : switch (idx) {
3399 742 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3400 742 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
3401 742 : case 2: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
3402 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3403 0 : ROSE_ASSERT(false);
3404 : return NULL;
3405 : }
3406 : }
3407 : size_t
3408 0 : SgNonrealType::get_childIndex(SgNode *child) {
3409 0 : if (child == p_type_kind) return 0;
3410 0 : else if (child == p_builtin_type) return 1;
3411 0 : else if (child == p_declaration) return 2;
3412 0 : else return (size_t) -1;
3413 : }
3414 : vector<SgNode*>
3415 0 : SgModifierType::get_traversalSuccessorContainer() {
3416 0 : vector<SgNode*> traversalSuccessorContainer;
3417 0 : traversalSuccessorContainer.reserve(2);
3418 0 : traversalSuccessorContainer.push_back(p_type_kind);
3419 0 : traversalSuccessorContainer.push_back(p_base_type);
3420 0 : return traversalSuccessorContainer;
3421 : }
3422 : vector<string>
3423 0 : SgModifierType::get_traversalSuccessorNamesContainer() {
3424 0 : vector<string> traversalSuccessorContainer;
3425 0 : traversalSuccessorContainer.push_back("p_type_kind");
3426 0 : traversalSuccessorContainer.push_back("p_base_type");
3427 0 : return traversalSuccessorContainer;
3428 : }
3429 : size_t
3430 0 : SgModifierType::get_numberOfTraversalSuccessors() {
3431 0 : return 2;
3432 : }
3433 : SgNode *
3434 0 : SgModifierType::get_traversalSuccessorByIndex(size_t idx) {
3435 0 : switch (idx) {
3436 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3437 0 : case 1: ROSE_ASSERT(p_base_type == NULL || p_base_type != NULL); return p_base_type;
3438 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3439 0 : ROSE_ASSERT(false);
3440 : return NULL;
3441 : }
3442 : }
3443 : size_t
3444 0 : SgModifierType::get_childIndex(SgNode *child) {
3445 0 : if (child == p_type_kind) return 0;
3446 0 : else if (child == p_base_type) return 1;
3447 0 : else return (size_t) -1;
3448 : }
3449 : vector<SgNode*>
3450 0 : SgFunctionType::get_traversalSuccessorContainer() {
3451 0 : vector<SgNode*> traversalSuccessorContainer;
3452 0 : traversalSuccessorContainer.reserve(3);
3453 0 : traversalSuccessorContainer.push_back(p_type_kind);
3454 0 : traversalSuccessorContainer.push_back(p_return_type);
3455 0 : traversalSuccessorContainer.push_back(p_orig_return_type);
3456 0 : return traversalSuccessorContainer;
3457 : }
3458 : vector<string>
3459 0 : SgFunctionType::get_traversalSuccessorNamesContainer() {
3460 0 : vector<string> traversalSuccessorContainer;
3461 0 : traversalSuccessorContainer.push_back("p_type_kind");
3462 0 : traversalSuccessorContainer.push_back("p_return_type");
3463 0 : traversalSuccessorContainer.push_back("p_orig_return_type");
3464 0 : return traversalSuccessorContainer;
3465 : }
3466 : size_t
3467 0 : SgFunctionType::get_numberOfTraversalSuccessors() {
3468 0 : return 3;
3469 : }
3470 : SgNode *
3471 0 : SgFunctionType::get_traversalSuccessorByIndex(size_t idx) {
3472 0 : switch (idx) {
3473 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3474 0 : case 1: ROSE_ASSERT(p_return_type == NULL || p_return_type != NULL); return p_return_type;
3475 0 : case 2: ROSE_ASSERT(p_orig_return_type == NULL || p_orig_return_type != NULL); return p_orig_return_type;
3476 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3477 0 : ROSE_ASSERT(false);
3478 : return NULL;
3479 : }
3480 : }
3481 : size_t
3482 0 : SgFunctionType::get_childIndex(SgNode *child) {
3483 0 : if (child == p_type_kind) return 0;
3484 0 : else if (child == p_return_type) return 1;
3485 0 : else if (child == p_orig_return_type) return 2;
3486 0 : else return (size_t) -1;
3487 : }
3488 : vector<SgNode*>
3489 0 : SgMemberFunctionType::get_traversalSuccessorContainer() {
3490 0 : vector<SgNode*> traversalSuccessorContainer;
3491 0 : traversalSuccessorContainer.reserve(3);
3492 0 : traversalSuccessorContainer.push_back(p_type_kind);
3493 0 : traversalSuccessorContainer.push_back(p_return_type);
3494 0 : traversalSuccessorContainer.push_back(p_orig_return_type);
3495 0 : return traversalSuccessorContainer;
3496 : }
3497 : vector<string>
3498 0 : SgMemberFunctionType::get_traversalSuccessorNamesContainer() {
3499 0 : vector<string> traversalSuccessorContainer;
3500 0 : traversalSuccessorContainer.push_back("p_type_kind");
3501 0 : traversalSuccessorContainer.push_back("p_return_type");
3502 0 : traversalSuccessorContainer.push_back("p_orig_return_type");
3503 0 : return traversalSuccessorContainer;
3504 : }
3505 : size_t
3506 360 : SgMemberFunctionType::get_numberOfTraversalSuccessors() {
3507 360 : return 3;
3508 : }
3509 : SgNode *
3510 1080 : SgMemberFunctionType::get_traversalSuccessorByIndex(size_t idx) {
3511 1080 : switch (idx) {
3512 360 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3513 360 : case 1: ROSE_ASSERT(p_return_type == NULL || p_return_type != NULL); return p_return_type;
3514 360 : case 2: ROSE_ASSERT(p_orig_return_type == NULL || p_orig_return_type != NULL); return p_orig_return_type;
3515 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3516 0 : ROSE_ASSERT(false);
3517 : return NULL;
3518 : }
3519 : }
3520 : size_t
3521 0 : SgMemberFunctionType::get_childIndex(SgNode *child) {
3522 0 : if (child == p_type_kind) return 0;
3523 0 : else if (child == p_return_type) return 1;
3524 0 : else if (child == p_orig_return_type) return 2;
3525 0 : else return (size_t) -1;
3526 : }
3527 : vector<SgNode*>
3528 0 : SgPartialFunctionType::get_traversalSuccessorContainer() {
3529 0 : vector<SgNode*> traversalSuccessorContainer;
3530 0 : traversalSuccessorContainer.reserve(3);
3531 0 : traversalSuccessorContainer.push_back(p_type_kind);
3532 0 : traversalSuccessorContainer.push_back(p_return_type);
3533 0 : traversalSuccessorContainer.push_back(p_orig_return_type);
3534 0 : return traversalSuccessorContainer;
3535 : }
3536 : vector<string>
3537 0 : SgPartialFunctionType::get_traversalSuccessorNamesContainer() {
3538 0 : vector<string> traversalSuccessorContainer;
3539 0 : traversalSuccessorContainer.push_back("p_type_kind");
3540 0 : traversalSuccessorContainer.push_back("p_return_type");
3541 0 : traversalSuccessorContainer.push_back("p_orig_return_type");
3542 0 : return traversalSuccessorContainer;
3543 : }
3544 : size_t
3545 0 : SgPartialFunctionType::get_numberOfTraversalSuccessors() {
3546 0 : return 3;
3547 : }
3548 : SgNode *
3549 0 : SgPartialFunctionType::get_traversalSuccessorByIndex(size_t idx) {
3550 0 : switch (idx) {
3551 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3552 0 : case 1: ROSE_ASSERT(p_return_type == NULL || p_return_type != NULL); return p_return_type;
3553 0 : case 2: ROSE_ASSERT(p_orig_return_type == NULL || p_orig_return_type != NULL); return p_orig_return_type;
3554 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3555 0 : ROSE_ASSERT(false);
3556 : return NULL;
3557 : }
3558 : }
3559 : size_t
3560 0 : SgPartialFunctionType::get_childIndex(SgNode *child) {
3561 0 : if (child == p_type_kind) return 0;
3562 0 : else if (child == p_return_type) return 1;
3563 0 : else if (child == p_orig_return_type) return 2;
3564 0 : else return (size_t) -1;
3565 : }
3566 : vector<SgNode*>
3567 0 : SgPartialFunctionModifierType::get_traversalSuccessorContainer() {
3568 0 : vector<SgNode*> traversalSuccessorContainer;
3569 0 : traversalSuccessorContainer.reserve(4);
3570 0 : traversalSuccessorContainer.push_back(p_type_kind);
3571 0 : traversalSuccessorContainer.push_back(p_return_type);
3572 0 : traversalSuccessorContainer.push_back(p_orig_return_type);
3573 0 : traversalSuccessorContainer.push_back(p_builtin_type);
3574 0 : return traversalSuccessorContainer;
3575 : }
3576 : vector<string>
3577 0 : SgPartialFunctionModifierType::get_traversalSuccessorNamesContainer() {
3578 0 : vector<string> traversalSuccessorContainer;
3579 0 : traversalSuccessorContainer.push_back("p_type_kind");
3580 0 : traversalSuccessorContainer.push_back("p_return_type");
3581 0 : traversalSuccessorContainer.push_back("p_orig_return_type");
3582 0 : traversalSuccessorContainer.push_back("p_builtin_type");
3583 0 : return traversalSuccessorContainer;
3584 : }
3585 : size_t
3586 0 : SgPartialFunctionModifierType::get_numberOfTraversalSuccessors() {
3587 0 : return 4;
3588 : }
3589 : SgNode *
3590 0 : SgPartialFunctionModifierType::get_traversalSuccessorByIndex(size_t idx) {
3591 0 : switch (idx) {
3592 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3593 0 : case 1: ROSE_ASSERT(p_return_type == NULL || p_return_type != NULL); return p_return_type;
3594 0 : case 2: ROSE_ASSERT(p_orig_return_type == NULL || p_orig_return_type != NULL); return p_orig_return_type;
3595 0 : case 3: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
3596 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3597 0 : ROSE_ASSERT(false);
3598 : return NULL;
3599 : }
3600 : }
3601 : size_t
3602 0 : SgPartialFunctionModifierType::get_childIndex(SgNode *child) {
3603 0 : if (child == p_type_kind) return 0;
3604 0 : else if (child == p_return_type) return 1;
3605 0 : else if (child == p_orig_return_type) return 2;
3606 0 : else if (child == p_builtin_type) return 3;
3607 0 : else return (size_t) -1;
3608 : }
3609 : vector<SgNode*>
3610 0 : SgArrayType::get_traversalSuccessorContainer() {
3611 0 : vector<SgNode*> traversalSuccessorContainer;
3612 0 : traversalSuccessorContainer.reserve(3);
3613 0 : traversalSuccessorContainer.push_back(p_type_kind);
3614 0 : traversalSuccessorContainer.push_back(p_index);
3615 0 : traversalSuccessorContainer.push_back(p_dim_info);
3616 0 : return traversalSuccessorContainer;
3617 : }
3618 : vector<string>
3619 0 : SgArrayType::get_traversalSuccessorNamesContainer() {
3620 0 : vector<string> traversalSuccessorContainer;
3621 0 : traversalSuccessorContainer.push_back("p_type_kind");
3622 0 : traversalSuccessorContainer.push_back("p_index");
3623 0 : traversalSuccessorContainer.push_back("p_dim_info");
3624 0 : return traversalSuccessorContainer;
3625 : }
3626 : size_t
3627 0 : SgArrayType::get_numberOfTraversalSuccessors() {
3628 0 : return 3;
3629 : }
3630 : SgNode *
3631 0 : SgArrayType::get_traversalSuccessorByIndex(size_t idx) {
3632 0 : switch (idx) {
3633 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3634 0 : case 1: ROSE_ASSERT(p_index == NULL || p_index != NULL); return p_index;
3635 0 : case 2: ROSE_ASSERT(p_dim_info == NULL || p_dim_info != NULL); return p_dim_info;
3636 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3637 0 : ROSE_ASSERT(false);
3638 : return NULL;
3639 : }
3640 : }
3641 : size_t
3642 0 : SgArrayType::get_childIndex(SgNode *child) {
3643 0 : if (child == p_type_kind) return 0;
3644 0 : else if (child == p_index) return 1;
3645 0 : else if (child == p_dim_info) return 2;
3646 0 : else return (size_t) -1;
3647 : }
3648 : vector<SgNode*>
3649 0 : SgTypeEllipse::get_traversalSuccessorContainer() {
3650 0 : vector<SgNode*> traversalSuccessorContainer;
3651 0 : traversalSuccessorContainer.reserve(2);
3652 0 : traversalSuccessorContainer.push_back(p_type_kind);
3653 : // suppress handling of builtin_type date members
3654 0 : return traversalSuccessorContainer;
3655 : }
3656 : vector<string>
3657 0 : SgTypeEllipse::get_traversalSuccessorNamesContainer() {
3658 0 : vector<string> traversalSuccessorContainer;
3659 0 : traversalSuccessorContainer.push_back("p_type_kind");
3660 0 : traversalSuccessorContainer.push_back("p_builtin_type");
3661 0 : return traversalSuccessorContainer;
3662 : }
3663 : size_t
3664 0 : SgTypeEllipse::get_numberOfTraversalSuccessors() {
3665 0 : return 2;
3666 : }
3667 : SgNode *
3668 0 : SgTypeEllipse::get_traversalSuccessorByIndex(size_t idx) {
3669 0 : switch (idx) {
3670 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3671 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
3672 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3673 0 : ROSE_ASSERT(false);
3674 : return NULL;
3675 : }
3676 : }
3677 : size_t
3678 0 : SgTypeEllipse::get_childIndex(SgNode *child) {
3679 0 : if (child == p_type_kind) return 0;
3680 0 : else if (child == p_builtin_type) return 1;
3681 0 : else return (size_t) -1;
3682 : }
3683 : vector<SgNode*>
3684 0 : SgTemplateType::get_traversalSuccessorContainer() {
3685 0 : vector<SgNode*> traversalSuccessorContainer;
3686 0 : traversalSuccessorContainer.reserve(4);
3687 0 : traversalSuccessorContainer.push_back(p_type_kind);
3688 0 : traversalSuccessorContainer.push_back(p_class_type);
3689 0 : traversalSuccessorContainer.push_back(p_parent_class_type);
3690 0 : traversalSuccessorContainer.push_back(p_template_parameter);
3691 0 : return traversalSuccessorContainer;
3692 : }
3693 : vector<string>
3694 0 : SgTemplateType::get_traversalSuccessorNamesContainer() {
3695 0 : vector<string> traversalSuccessorContainer;
3696 0 : traversalSuccessorContainer.push_back("p_type_kind");
3697 0 : traversalSuccessorContainer.push_back("p_class_type");
3698 0 : traversalSuccessorContainer.push_back("p_parent_class_type");
3699 0 : traversalSuccessorContainer.push_back("p_template_parameter");
3700 0 : return traversalSuccessorContainer;
3701 : }
3702 : size_t
3703 0 : SgTemplateType::get_numberOfTraversalSuccessors() {
3704 0 : return 4;
3705 : }
3706 : SgNode *
3707 0 : SgTemplateType::get_traversalSuccessorByIndex(size_t idx) {
3708 0 : switch (idx) {
3709 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3710 0 : case 1: ROSE_ASSERT(p_class_type == NULL || p_class_type != NULL); return p_class_type;
3711 0 : case 2: ROSE_ASSERT(p_parent_class_type == NULL || p_parent_class_type != NULL); return p_parent_class_type;
3712 0 : case 3: ROSE_ASSERT(p_template_parameter == NULL || p_template_parameter != NULL); return p_template_parameter;
3713 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3714 0 : ROSE_ASSERT(false);
3715 : return NULL;
3716 : }
3717 : }
3718 : size_t
3719 0 : SgTemplateType::get_childIndex(SgNode *child) {
3720 0 : if (child == p_type_kind) return 0;
3721 0 : else if (child == p_class_type) return 1;
3722 0 : else if (child == p_parent_class_type) return 2;
3723 0 : else if (child == p_template_parameter) return 3;
3724 0 : else return (size_t) -1;
3725 : }
3726 : vector<SgNode*>
3727 0 : SgQualifiedNameType::get_traversalSuccessorContainer() {
3728 0 : vector<SgNode*> traversalSuccessorContainer;
3729 0 : traversalSuccessorContainer.reserve(1);
3730 0 : traversalSuccessorContainer.push_back(p_type_kind);
3731 0 : return traversalSuccessorContainer;
3732 : }
3733 : vector<string>
3734 0 : SgQualifiedNameType::get_traversalSuccessorNamesContainer() {
3735 0 : vector<string> traversalSuccessorContainer;
3736 0 : traversalSuccessorContainer.push_back("p_type_kind");
3737 0 : return traversalSuccessorContainer;
3738 : }
3739 : size_t
3740 0 : SgQualifiedNameType::get_numberOfTraversalSuccessors() {
3741 0 : return 1;
3742 : }
3743 : SgNode *
3744 0 : SgQualifiedNameType::get_traversalSuccessorByIndex(size_t idx) {
3745 0 : switch (idx) {
3746 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3747 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3748 0 : ROSE_ASSERT(false);
3749 : return NULL;
3750 : }
3751 : }
3752 : size_t
3753 0 : SgQualifiedNameType::get_childIndex(SgNode *child) {
3754 0 : if (child == p_type_kind) return 0;
3755 0 : else return (size_t) -1;
3756 : }
3757 : vector<SgNode*>
3758 0 : SgTypeComplex::get_traversalSuccessorContainer() {
3759 0 : vector<SgNode*> traversalSuccessorContainer;
3760 0 : traversalSuccessorContainer.reserve(1);
3761 0 : traversalSuccessorContainer.push_back(p_type_kind);
3762 0 : return traversalSuccessorContainer;
3763 : }
3764 : vector<string>
3765 0 : SgTypeComplex::get_traversalSuccessorNamesContainer() {
3766 0 : vector<string> traversalSuccessorContainer;
3767 0 : traversalSuccessorContainer.push_back("p_type_kind");
3768 0 : return traversalSuccessorContainer;
3769 : }
3770 : size_t
3771 0 : SgTypeComplex::get_numberOfTraversalSuccessors() {
3772 0 : return 1;
3773 : }
3774 : SgNode *
3775 0 : SgTypeComplex::get_traversalSuccessorByIndex(size_t idx) {
3776 0 : switch (idx) {
3777 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3778 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3779 0 : ROSE_ASSERT(false);
3780 : return NULL;
3781 : }
3782 : }
3783 : size_t
3784 0 : SgTypeComplex::get_childIndex(SgNode *child) {
3785 0 : if (child == p_type_kind) return 0;
3786 0 : else return (size_t) -1;
3787 : }
3788 : vector<SgNode*>
3789 0 : SgTypeImaginary::get_traversalSuccessorContainer() {
3790 0 : vector<SgNode*> traversalSuccessorContainer;
3791 0 : traversalSuccessorContainer.reserve(1);
3792 0 : traversalSuccessorContainer.push_back(p_type_kind);
3793 0 : return traversalSuccessorContainer;
3794 : }
3795 : vector<string>
3796 0 : SgTypeImaginary::get_traversalSuccessorNamesContainer() {
3797 0 : vector<string> traversalSuccessorContainer;
3798 0 : traversalSuccessorContainer.push_back("p_type_kind");
3799 0 : return traversalSuccessorContainer;
3800 : }
3801 : size_t
3802 0 : SgTypeImaginary::get_numberOfTraversalSuccessors() {
3803 0 : return 1;
3804 : }
3805 : SgNode *
3806 0 : SgTypeImaginary::get_traversalSuccessorByIndex(size_t idx) {
3807 0 : switch (idx) {
3808 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3809 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3810 0 : ROSE_ASSERT(false);
3811 : return NULL;
3812 : }
3813 : }
3814 : size_t
3815 0 : SgTypeImaginary::get_childIndex(SgNode *child) {
3816 0 : if (child == p_type_kind) return 0;
3817 0 : else return (size_t) -1;
3818 : }
3819 : vector<SgNode*>
3820 0 : SgTypeDefault::get_traversalSuccessorContainer() {
3821 0 : vector<SgNode*> traversalSuccessorContainer;
3822 0 : traversalSuccessorContainer.reserve(2);
3823 0 : traversalSuccessorContainer.push_back(p_type_kind);
3824 : // suppress handling of builtin_type date members
3825 0 : return traversalSuccessorContainer;
3826 : }
3827 : vector<string>
3828 0 : SgTypeDefault::get_traversalSuccessorNamesContainer() {
3829 0 : vector<string> traversalSuccessorContainer;
3830 0 : traversalSuccessorContainer.push_back("p_type_kind");
3831 0 : traversalSuccessorContainer.push_back("p_builtin_type");
3832 0 : return traversalSuccessorContainer;
3833 : }
3834 : size_t
3835 0 : SgTypeDefault::get_numberOfTraversalSuccessors() {
3836 0 : return 2;
3837 : }
3838 : SgNode *
3839 0 : SgTypeDefault::get_traversalSuccessorByIndex(size_t idx) {
3840 0 : switch (idx) {
3841 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3842 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
3843 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3844 0 : ROSE_ASSERT(false);
3845 : return NULL;
3846 : }
3847 : }
3848 : size_t
3849 0 : SgTypeDefault::get_childIndex(SgNode *child) {
3850 0 : if (child == p_type_kind) return 0;
3851 0 : else if (child == p_builtin_type) return 1;
3852 0 : else return (size_t) -1;
3853 : }
3854 : vector<SgNode*>
3855 0 : SgTypeCAFTeam::get_traversalSuccessorContainer() {
3856 0 : vector<SgNode*> traversalSuccessorContainer;
3857 0 : traversalSuccessorContainer.reserve(2);
3858 0 : traversalSuccessorContainer.push_back(p_type_kind);
3859 : // suppress handling of builtin_type date members
3860 0 : return traversalSuccessorContainer;
3861 : }
3862 : vector<string>
3863 0 : SgTypeCAFTeam::get_traversalSuccessorNamesContainer() {
3864 0 : vector<string> traversalSuccessorContainer;
3865 0 : traversalSuccessorContainer.push_back("p_type_kind");
3866 0 : traversalSuccessorContainer.push_back("p_builtin_type");
3867 0 : return traversalSuccessorContainer;
3868 : }
3869 : size_t
3870 0 : SgTypeCAFTeam::get_numberOfTraversalSuccessors() {
3871 0 : return 2;
3872 : }
3873 : SgNode *
3874 0 : SgTypeCAFTeam::get_traversalSuccessorByIndex(size_t idx) {
3875 0 : switch (idx) {
3876 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3877 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
3878 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3879 0 : ROSE_ASSERT(false);
3880 : return NULL;
3881 : }
3882 : }
3883 : size_t
3884 0 : SgTypeCAFTeam::get_childIndex(SgNode *child) {
3885 0 : if (child == p_type_kind) return 0;
3886 0 : else if (child == p_builtin_type) return 1;
3887 0 : else return (size_t) -1;
3888 : }
3889 : vector<SgNode*>
3890 0 : SgTypeCrayPointer::get_traversalSuccessorContainer() {
3891 0 : vector<SgNode*> traversalSuccessorContainer;
3892 0 : traversalSuccessorContainer.reserve(2);
3893 0 : traversalSuccessorContainer.push_back(p_type_kind);
3894 : // suppress handling of builtin_type date members
3895 0 : return traversalSuccessorContainer;
3896 : }
3897 : vector<string>
3898 0 : SgTypeCrayPointer::get_traversalSuccessorNamesContainer() {
3899 0 : vector<string> traversalSuccessorContainer;
3900 0 : traversalSuccessorContainer.push_back("p_type_kind");
3901 0 : traversalSuccessorContainer.push_back("p_builtin_type");
3902 0 : return traversalSuccessorContainer;
3903 : }
3904 : size_t
3905 0 : SgTypeCrayPointer::get_numberOfTraversalSuccessors() {
3906 0 : return 2;
3907 : }
3908 : SgNode *
3909 0 : SgTypeCrayPointer::get_traversalSuccessorByIndex(size_t idx) {
3910 0 : switch (idx) {
3911 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3912 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
3913 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3914 0 : ROSE_ASSERT(false);
3915 : return NULL;
3916 : }
3917 : }
3918 : size_t
3919 0 : SgTypeCrayPointer::get_childIndex(SgNode *child) {
3920 0 : if (child == p_type_kind) return 0;
3921 0 : else if (child == p_builtin_type) return 1;
3922 0 : else return (size_t) -1;
3923 : }
3924 : vector<SgNode*>
3925 0 : SgTypeLabel::get_traversalSuccessorContainer() {
3926 0 : vector<SgNode*> traversalSuccessorContainer;
3927 0 : traversalSuccessorContainer.reserve(2);
3928 0 : traversalSuccessorContainer.push_back(p_type_kind);
3929 : // suppress handling of builtin_type date members
3930 0 : return traversalSuccessorContainer;
3931 : }
3932 : vector<string>
3933 0 : SgTypeLabel::get_traversalSuccessorNamesContainer() {
3934 0 : vector<string> traversalSuccessorContainer;
3935 0 : traversalSuccessorContainer.push_back("p_type_kind");
3936 0 : traversalSuccessorContainer.push_back("p_builtin_type");
3937 0 : return traversalSuccessorContainer;
3938 : }
3939 : size_t
3940 0 : SgTypeLabel::get_numberOfTraversalSuccessors() {
3941 0 : return 2;
3942 : }
3943 : SgNode *
3944 0 : SgTypeLabel::get_traversalSuccessorByIndex(size_t idx) {
3945 0 : switch (idx) {
3946 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3947 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
3948 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3949 0 : ROSE_ASSERT(false);
3950 : return NULL;
3951 : }
3952 : }
3953 : size_t
3954 0 : SgTypeLabel::get_childIndex(SgNode *child) {
3955 0 : if (child == p_type_kind) return 0;
3956 0 : else if (child == p_builtin_type) return 1;
3957 0 : else return (size_t) -1;
3958 : }
3959 : vector<SgNode*>
3960 0 : SgRvalueReferenceType::get_traversalSuccessorContainer() {
3961 0 : vector<SgNode*> traversalSuccessorContainer;
3962 0 : traversalSuccessorContainer.reserve(1);
3963 0 : traversalSuccessorContainer.push_back(p_type_kind);
3964 0 : return traversalSuccessorContainer;
3965 : }
3966 : vector<string>
3967 0 : SgRvalueReferenceType::get_traversalSuccessorNamesContainer() {
3968 0 : vector<string> traversalSuccessorContainer;
3969 0 : traversalSuccessorContainer.push_back("p_type_kind");
3970 0 : return traversalSuccessorContainer;
3971 : }
3972 : size_t
3973 0 : SgRvalueReferenceType::get_numberOfTraversalSuccessors() {
3974 0 : return 1;
3975 : }
3976 : SgNode *
3977 0 : SgRvalueReferenceType::get_traversalSuccessorByIndex(size_t idx) {
3978 0 : switch (idx) {
3979 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
3980 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
3981 0 : ROSE_ASSERT(false);
3982 : return NULL;
3983 : }
3984 : }
3985 : size_t
3986 0 : SgRvalueReferenceType::get_childIndex(SgNode *child) {
3987 0 : if (child == p_type_kind) return 0;
3988 0 : else return (size_t) -1;
3989 : }
3990 : vector<SgNode*>
3991 0 : SgTypeNullptr::get_traversalSuccessorContainer() {
3992 0 : vector<SgNode*> traversalSuccessorContainer;
3993 0 : traversalSuccessorContainer.reserve(2);
3994 0 : traversalSuccessorContainer.push_back(p_type_kind);
3995 : // suppress handling of builtin_type date members
3996 0 : return traversalSuccessorContainer;
3997 : }
3998 : vector<string>
3999 0 : SgTypeNullptr::get_traversalSuccessorNamesContainer() {
4000 0 : vector<string> traversalSuccessorContainer;
4001 0 : traversalSuccessorContainer.push_back("p_type_kind");
4002 0 : traversalSuccessorContainer.push_back("p_builtin_type");
4003 0 : return traversalSuccessorContainer;
4004 : }
4005 : size_t
4006 0 : SgTypeNullptr::get_numberOfTraversalSuccessors() {
4007 0 : return 2;
4008 : }
4009 : SgNode *
4010 0 : SgTypeNullptr::get_traversalSuccessorByIndex(size_t idx) {
4011 0 : switch (idx) {
4012 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
4013 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
4014 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
4015 0 : ROSE_ASSERT(false);
4016 : return NULL;
4017 : }
4018 : }
4019 : size_t
4020 0 : SgTypeNullptr::get_childIndex(SgNode *child) {
4021 0 : if (child == p_type_kind) return 0;
4022 0 : else if (child == p_builtin_type) return 1;
4023 0 : else return (size_t) -1;
4024 : }
4025 : vector<SgNode*>
4026 0 : SgDeclType::get_traversalSuccessorContainer() {
4027 0 : vector<SgNode*> traversalSuccessorContainer;
4028 0 : traversalSuccessorContainer.reserve(1);
4029 0 : traversalSuccessorContainer.push_back(p_type_kind);
4030 0 : return traversalSuccessorContainer;
4031 : }
4032 : vector<string>
4033 0 : SgDeclType::get_traversalSuccessorNamesContainer() {
4034 0 : vector<string> traversalSuccessorContainer;
4035 0 : traversalSuccessorContainer.push_back("p_type_kind");
4036 0 : return traversalSuccessorContainer;
4037 : }
4038 : size_t
4039 0 : SgDeclType::get_numberOfTraversalSuccessors() {
4040 0 : return 1;
4041 : }
4042 : SgNode *
4043 0 : SgDeclType::get_traversalSuccessorByIndex(size_t idx) {
4044 0 : switch (idx) {
4045 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
4046 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
4047 0 : ROSE_ASSERT(false);
4048 : return NULL;
4049 : }
4050 : }
4051 : size_t
4052 0 : SgDeclType::get_childIndex(SgNode *child) {
4053 0 : if (child == p_type_kind) return 0;
4054 0 : else return (size_t) -1;
4055 : }
4056 : vector<SgNode*>
4057 0 : SgTypeOfType::get_traversalSuccessorContainer() {
4058 0 : vector<SgNode*> traversalSuccessorContainer;
4059 0 : traversalSuccessorContainer.reserve(1);
4060 0 : traversalSuccessorContainer.push_back(p_type_kind);
4061 0 : return traversalSuccessorContainer;
4062 : }
4063 : vector<string>
4064 0 : SgTypeOfType::get_traversalSuccessorNamesContainer() {
4065 0 : vector<string> traversalSuccessorContainer;
4066 0 : traversalSuccessorContainer.push_back("p_type_kind");
4067 0 : return traversalSuccessorContainer;
4068 : }
4069 : size_t
4070 0 : SgTypeOfType::get_numberOfTraversalSuccessors() {
4071 0 : return 1;
4072 : }
4073 : SgNode *
4074 0 : SgTypeOfType::get_traversalSuccessorByIndex(size_t idx) {
4075 0 : switch (idx) {
4076 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
4077 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
4078 0 : ROSE_ASSERT(false);
4079 : return NULL;
4080 : }
4081 : }
4082 : size_t
4083 0 : SgTypeOfType::get_childIndex(SgNode *child) {
4084 0 : if (child == p_type_kind) return 0;
4085 0 : else return (size_t) -1;
4086 : }
4087 : vector<SgNode*>
4088 0 : SgTypeMatrix::get_traversalSuccessorContainer() {
4089 0 : vector<SgNode*> traversalSuccessorContainer;
4090 0 : traversalSuccessorContainer.reserve(2);
4091 0 : traversalSuccessorContainer.push_back(p_type_kind);
4092 : // suppress handling of builtin_type date members
4093 0 : return traversalSuccessorContainer;
4094 : }
4095 : vector<string>
4096 0 : SgTypeMatrix::get_traversalSuccessorNamesContainer() {
4097 0 : vector<string> traversalSuccessorContainer;
4098 0 : traversalSuccessorContainer.push_back("p_type_kind");
4099 0 : traversalSuccessorContainer.push_back("p_builtin_type");
4100 0 : return traversalSuccessorContainer;
4101 : }
4102 : size_t
4103 0 : SgTypeMatrix::get_numberOfTraversalSuccessors() {
4104 0 : return 2;
4105 : }
4106 : SgNode *
4107 0 : SgTypeMatrix::get_traversalSuccessorByIndex(size_t idx) {
4108 0 : switch (idx) {
4109 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
4110 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
4111 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
4112 0 : ROSE_ASSERT(false);
4113 : return NULL;
4114 : }
4115 : }
4116 : size_t
4117 0 : SgTypeMatrix::get_childIndex(SgNode *child) {
4118 0 : if (child == p_type_kind) return 0;
4119 0 : else if (child == p_builtin_type) return 1;
4120 0 : else return (size_t) -1;
4121 : }
4122 : vector<SgNode*>
4123 0 : SgTypeTuple::get_traversalSuccessorContainer() {
4124 0 : vector<SgNode*> traversalSuccessorContainer;
4125 0 : traversalSuccessorContainer.reserve(2);
4126 0 : traversalSuccessorContainer.push_back(p_type_kind);
4127 : // suppress handling of builtin_type date members
4128 0 : return traversalSuccessorContainer;
4129 : }
4130 : vector<string>
4131 0 : SgTypeTuple::get_traversalSuccessorNamesContainer() {
4132 0 : vector<string> traversalSuccessorContainer;
4133 0 : traversalSuccessorContainer.push_back("p_type_kind");
4134 0 : traversalSuccessorContainer.push_back("p_builtin_type");
4135 0 : return traversalSuccessorContainer;
4136 : }
4137 : size_t
4138 0 : SgTypeTuple::get_numberOfTraversalSuccessors() {
4139 0 : return 2;
4140 : }
4141 : SgNode *
4142 0 : SgTypeTuple::get_traversalSuccessorByIndex(size_t idx) {
4143 0 : switch (idx) {
4144 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
4145 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
4146 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
4147 0 : ROSE_ASSERT(false);
4148 : return NULL;
4149 : }
4150 : }
4151 : size_t
4152 0 : SgTypeTuple::get_childIndex(SgNode *child) {
4153 0 : if (child == p_type_kind) return 0;
4154 0 : else if (child == p_builtin_type) return 1;
4155 0 : else return (size_t) -1;
4156 : }
4157 : vector<SgNode*>
4158 0 : SgTypeChar16::get_traversalSuccessorContainer() {
4159 0 : vector<SgNode*> traversalSuccessorContainer;
4160 0 : traversalSuccessorContainer.reserve(2);
4161 0 : traversalSuccessorContainer.push_back(p_type_kind);
4162 : // suppress handling of builtin_type date members
4163 0 : return traversalSuccessorContainer;
4164 : }
4165 : vector<string>
4166 0 : SgTypeChar16::get_traversalSuccessorNamesContainer() {
4167 0 : vector<string> traversalSuccessorContainer;
4168 0 : traversalSuccessorContainer.push_back("p_type_kind");
4169 0 : traversalSuccessorContainer.push_back("p_builtin_type");
4170 0 : return traversalSuccessorContainer;
4171 : }
4172 : size_t
4173 0 : SgTypeChar16::get_numberOfTraversalSuccessors() {
4174 0 : return 2;
4175 : }
4176 : SgNode *
4177 0 : SgTypeChar16::get_traversalSuccessorByIndex(size_t idx) {
4178 0 : switch (idx) {
4179 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
4180 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
4181 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
4182 0 : ROSE_ASSERT(false);
4183 : return NULL;
4184 : }
4185 : }
4186 : size_t
4187 0 : SgTypeChar16::get_childIndex(SgNode *child) {
4188 0 : if (child == p_type_kind) return 0;
4189 0 : else if (child == p_builtin_type) return 1;
4190 0 : else return (size_t) -1;
4191 : }
4192 : vector<SgNode*>
4193 0 : SgTypeChar32::get_traversalSuccessorContainer() {
4194 0 : vector<SgNode*> traversalSuccessorContainer;
4195 0 : traversalSuccessorContainer.reserve(2);
4196 0 : traversalSuccessorContainer.push_back(p_type_kind);
4197 : // suppress handling of builtin_type date members
4198 0 : return traversalSuccessorContainer;
4199 : }
4200 : vector<string>
4201 0 : SgTypeChar32::get_traversalSuccessorNamesContainer() {
4202 0 : vector<string> traversalSuccessorContainer;
4203 0 : traversalSuccessorContainer.push_back("p_type_kind");
4204 0 : traversalSuccessorContainer.push_back("p_builtin_type");
4205 0 : return traversalSuccessorContainer;
4206 : }
4207 : size_t
4208 0 : SgTypeChar32::get_numberOfTraversalSuccessors() {
4209 0 : return 2;
4210 : }
4211 : SgNode *
4212 0 : SgTypeChar32::get_traversalSuccessorByIndex(size_t idx) {
4213 0 : switch (idx) {
4214 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
4215 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
4216 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
4217 0 : ROSE_ASSERT(false);
4218 : return NULL;
4219 : }
4220 : }
4221 : size_t
4222 0 : SgTypeChar32::get_childIndex(SgNode *child) {
4223 0 : if (child == p_type_kind) return 0;
4224 0 : else if (child == p_builtin_type) return 1;
4225 0 : else return (size_t) -1;
4226 : }
4227 : vector<SgNode*>
4228 0 : SgTypeFloat128::get_traversalSuccessorContainer() {
4229 0 : vector<SgNode*> traversalSuccessorContainer;
4230 0 : traversalSuccessorContainer.reserve(2);
4231 0 : traversalSuccessorContainer.push_back(p_type_kind);
4232 : // suppress handling of builtin_type date members
4233 0 : return traversalSuccessorContainer;
4234 : }
4235 : vector<string>
4236 0 : SgTypeFloat128::get_traversalSuccessorNamesContainer() {
4237 0 : vector<string> traversalSuccessorContainer;
4238 0 : traversalSuccessorContainer.push_back("p_type_kind");
4239 0 : traversalSuccessorContainer.push_back("p_builtin_type");
4240 0 : return traversalSuccessorContainer;
4241 : }
4242 : size_t
4243 0 : SgTypeFloat128::get_numberOfTraversalSuccessors() {
4244 0 : return 2;
4245 : }
4246 : SgNode *
4247 0 : SgTypeFloat128::get_traversalSuccessorByIndex(size_t idx) {
4248 0 : switch (idx) {
4249 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
4250 0 : case 1: ROSE_ASSERT(p_builtin_type == NULL || p_builtin_type != NULL); return p_builtin_type;
4251 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
4252 0 : ROSE_ASSERT(false);
4253 : return NULL;
4254 : }
4255 : }
4256 : size_t
4257 0 : SgTypeFloat128::get_childIndex(SgNode *child) {
4258 0 : if (child == p_type_kind) return 0;
4259 0 : else if (child == p_builtin_type) return 1;
4260 0 : else return (size_t) -1;
4261 : }
4262 : vector<SgNode*>
4263 0 : SgTypeFixed::get_traversalSuccessorContainer() {
4264 0 : vector<SgNode*> traversalSuccessorContainer;
4265 0 : traversalSuccessorContainer.reserve(3);
4266 0 : traversalSuccessorContainer.push_back(p_type_kind);
4267 0 : traversalSuccessorContainer.push_back(p_scale);
4268 0 : traversalSuccessorContainer.push_back(p_fraction);
4269 0 : return traversalSuccessorContainer;
4270 : }
4271 : vector<string>
4272 0 : SgTypeFixed::get_traversalSuccessorNamesContainer() {
4273 0 : vector<string> traversalSuccessorContainer;
4274 0 : traversalSuccessorContainer.push_back("p_type_kind");
4275 0 : traversalSuccessorContainer.push_back("p_scale");
4276 0 : traversalSuccessorContainer.push_back("p_fraction");
4277 0 : return traversalSuccessorContainer;
4278 : }
4279 : size_t
4280 0 : SgTypeFixed::get_numberOfTraversalSuccessors() {
4281 0 : return 3;
4282 : }
4283 : SgNode *
4284 0 : SgTypeFixed::get_traversalSuccessorByIndex(size_t idx) {
4285 0 : switch (idx) {
4286 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
4287 0 : case 1: ROSE_ASSERT(p_scale == NULL || p_scale != NULL); return p_scale;
4288 0 : case 2: ROSE_ASSERT(p_fraction == NULL || p_fraction != NULL); return p_fraction;
4289 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
4290 0 : ROSE_ASSERT(false);
4291 : return NULL;
4292 : }
4293 : }
4294 : size_t
4295 0 : SgTypeFixed::get_childIndex(SgNode *child) {
4296 0 : if (child == p_type_kind) return 0;
4297 0 : else if (child == p_scale) return 1;
4298 0 : else if (child == p_fraction) return 2;
4299 0 : else return (size_t) -1;
4300 : }
4301 : vector<SgNode*>
4302 0 : SgAutoType::get_traversalSuccessorContainer() {
4303 0 : vector<SgNode*> traversalSuccessorContainer;
4304 0 : traversalSuccessorContainer.reserve(1);
4305 0 : traversalSuccessorContainer.push_back(p_type_kind);
4306 0 : return traversalSuccessorContainer;
4307 : }
4308 : vector<string>
4309 0 : SgAutoType::get_traversalSuccessorNamesContainer() {
4310 0 : vector<string> traversalSuccessorContainer;
4311 0 : traversalSuccessorContainer.push_back("p_type_kind");
4312 0 : return traversalSuccessorContainer;
4313 : }
4314 : size_t
4315 0 : SgAutoType::get_numberOfTraversalSuccessors() {
4316 0 : return 1;
4317 : }
4318 : SgNode *
4319 0 : SgAutoType::get_traversalSuccessorByIndex(size_t idx) {
4320 0 : switch (idx) {
4321 0 : case 0: ROSE_ASSERT(p_type_kind == NULL || p_type_kind != NULL); return p_type_kind;
4322 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
4323 0 : ROSE_ASSERT(false);
4324 : return NULL;
4325 : }
4326 : }
4327 : size_t
4328 0 : SgAutoType::get_childIndex(SgNode *child) {
4329 0 : if (child == p_type_kind) return 0;
4330 0 : else return (size_t) -1;
4331 : }
4332 : vector<SgNode*>
4333 0 : SgLocatedNode::get_traversalSuccessorContainer() {
4334 0 : vector<SgNode*> traversalSuccessorContainer;
4335 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
4336 0 : << "static: SgLocatedNode" << endl << "dynamic: " << this->sage_class_name() << endl;
4337 0 : cerr << "Aborting ..." << endl;
4338 0 : ROSE_ASSERT(false);
4339 : return traversalSuccessorContainer;
4340 : }
4341 :
4342 : vector<string>
4343 0 : SgLocatedNode::get_traversalSuccessorNamesContainer() {
4344 0 : vector<string> traversalSuccessorContainer;
4345 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
4346 0 : << "static: SgLocatedNode" << endl << "dynamic: " << this->sage_class_name() << endl;
4347 0 : cerr << "Aborting ..." << endl;
4348 0 : ROSE_ASSERT(false);
4349 : return traversalSuccessorContainer;
4350 : }
4351 :
4352 : size_t
4353 0 : SgLocatedNode::get_numberOfTraversalSuccessors() {
4354 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
4355 0 : << "static: SgLocatedNode" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
4356 0 : cerr << "Aborting ..." << endl;
4357 0 : ROSE_ASSERT(false);
4358 : return 42;
4359 : }
4360 :
4361 : SgNode*
4362 0 : SgLocatedNode::get_traversalSuccessorByIndex(size_t) {
4363 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
4364 0 : << "static: SgLocatedNode" << endl << "dynamic: " << this->sage_class_name() << endl;
4365 0 : cerr << "Aborting ..." << endl;
4366 0 : ROSE_ASSERT(false);
4367 : return NULL;
4368 : }
4369 :
4370 : size_t
4371 0 : SgLocatedNode::get_childIndex(SgNode *) {
4372 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
4373 0 : << "static: SgLocatedNode" << endl << "dynamic: " << this->sage_class_name() << endl;
4374 0 : cerr << "Aborting ..." << endl;
4375 0 : ROSE_ASSERT(false);
4376 : return 42;
4377 : }
4378 :
4379 : vector<SgNode*>
4380 0 : SgToken::get_traversalSuccessorContainer() {
4381 0 : vector<SgNode*> traversalSuccessorContainer;
4382 0 : return traversalSuccessorContainer;
4383 : }
4384 : vector<string>
4385 0 : SgToken::get_traversalSuccessorNamesContainer() {
4386 0 : vector<string> traversalSuccessorContainer;
4387 0 : return traversalSuccessorContainer;
4388 : }
4389 : size_t
4390 0 : SgToken::get_numberOfTraversalSuccessors() {
4391 0 : return 0;
4392 : }
4393 : SgNode *
4394 0 : SgToken::get_traversalSuccessorByIndex(size_t idx) {
4395 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgToken" << " that has no successors!" << endl;
4396 0 : ROSE_ASSERT(false);
4397 : return NULL;
4398 : }
4399 : size_t
4400 0 : SgToken::get_childIndex(SgNode *child) {
4401 0 : cout << "error: get_childIndex called on node of type " << "SgToken" << " that has no successors!" << endl;
4402 0 : ROSE_ASSERT(false);
4403 : return 0;
4404 : }
4405 : vector<SgNode*>
4406 0 : SgLocatedNodeSupport::get_traversalSuccessorContainer() {
4407 0 : vector<SgNode*> traversalSuccessorContainer;
4408 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
4409 0 : << "static: SgLocatedNodeSupport" << endl << "dynamic: " << this->sage_class_name() << endl;
4410 0 : cerr << "Aborting ..." << endl;
4411 0 : ROSE_ASSERT(false);
4412 : return traversalSuccessorContainer;
4413 : }
4414 :
4415 : vector<string>
4416 0 : SgLocatedNodeSupport::get_traversalSuccessorNamesContainer() {
4417 0 : vector<string> traversalSuccessorContainer;
4418 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
4419 0 : << "static: SgLocatedNodeSupport" << endl << "dynamic: " << this->sage_class_name() << endl;
4420 0 : cerr << "Aborting ..." << endl;
4421 0 : ROSE_ASSERT(false);
4422 : return traversalSuccessorContainer;
4423 : }
4424 :
4425 : size_t
4426 0 : SgLocatedNodeSupport::get_numberOfTraversalSuccessors() {
4427 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
4428 0 : << "static: SgLocatedNodeSupport" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
4429 0 : cerr << "Aborting ..." << endl;
4430 0 : ROSE_ASSERT(false);
4431 : return 42;
4432 : }
4433 :
4434 : SgNode*
4435 0 : SgLocatedNodeSupport::get_traversalSuccessorByIndex(size_t) {
4436 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
4437 0 : << "static: SgLocatedNodeSupport" << endl << "dynamic: " << this->sage_class_name() << endl;
4438 0 : cerr << "Aborting ..." << endl;
4439 0 : ROSE_ASSERT(false);
4440 : return NULL;
4441 : }
4442 :
4443 : size_t
4444 0 : SgLocatedNodeSupport::get_childIndex(SgNode *) {
4445 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
4446 0 : << "static: SgLocatedNodeSupport" << endl << "dynamic: " << this->sage_class_name() << endl;
4447 0 : cerr << "Aborting ..." << endl;
4448 0 : ROSE_ASSERT(false);
4449 : return 42;
4450 : }
4451 :
4452 : vector<SgNode*>
4453 33 : SgCommonBlockObject::get_traversalSuccessorContainer() {
4454 33 : vector<SgNode*> traversalSuccessorContainer;
4455 33 : traversalSuccessorContainer.reserve(1);
4456 33 : traversalSuccessorContainer.push_back(p_variable_reference_list);
4457 33 : return traversalSuccessorContainer;
4458 : }
4459 : vector<string>
4460 12 : SgCommonBlockObject::get_traversalSuccessorNamesContainer() {
4461 12 : vector<string> traversalSuccessorContainer;
4462 24 : traversalSuccessorContainer.push_back("p_variable_reference_list");
4463 12 : return traversalSuccessorContainer;
4464 : }
4465 : size_t
4466 234 : SgCommonBlockObject::get_numberOfTraversalSuccessors() {
4467 234 : return 1;
4468 : }
4469 : SgNode *
4470 234 : SgCommonBlockObject::get_traversalSuccessorByIndex(size_t idx) {
4471 234 : switch (idx) {
4472 234 : case 0: ROSE_ASSERT(p_variable_reference_list == NULL || p_variable_reference_list != NULL); return p_variable_reference_list;
4473 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
4474 0 : ROSE_ASSERT(false);
4475 : return NULL;
4476 : }
4477 : }
4478 : size_t
4479 0 : SgCommonBlockObject::get_childIndex(SgNode *child) {
4480 0 : if (child == p_variable_reference_list) return 0;
4481 0 : else return (size_t) -1;
4482 : }
4483 : vector<SgNode*>
4484 22137800 : SgInitializedName::get_traversalSuccessorContainer() {
4485 22137800 : vector<SgNode*> traversalSuccessorContainer;
4486 22137800 : traversalSuccessorContainer.reserve(1);
4487 22137800 : traversalSuccessorContainer.push_back(p_initptr);
4488 22137800 : return traversalSuccessorContainer;
4489 : }
4490 : vector<string>
4491 5911590 : SgInitializedName::get_traversalSuccessorNamesContainer() {
4492 5911590 : vector<string> traversalSuccessorContainer;
4493 11823200 : traversalSuccessorContainer.push_back("p_initptr");
4494 5911590 : return traversalSuccessorContainer;
4495 : }
4496 : size_t
4497 135503000 : SgInitializedName::get_numberOfTraversalSuccessors() {
4498 135503000 : return 1;
4499 : }
4500 : SgNode *
4501 135487000 : SgInitializedName::get_traversalSuccessorByIndex(size_t idx) {
4502 135487000 : switch (idx) {
4503 135487000 : case 0: ROSE_ASSERT(p_initptr == NULL || p_initptr != NULL); return p_initptr;
4504 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
4505 0 : ROSE_ASSERT(false);
4506 : return NULL;
4507 : }
4508 : }
4509 : size_t
4510 0 : SgInitializedName::get_childIndex(SgNode *child) {
4511 0 : if (child == p_initptr) return 0;
4512 0 : else return (size_t) -1;
4513 : }
4514 : vector<SgNode*>
4515 0 : SgInterfaceBody::get_traversalSuccessorContainer() {
4516 0 : vector<SgNode*> traversalSuccessorContainer;
4517 0 : return traversalSuccessorContainer;
4518 : }
4519 : vector<string>
4520 0 : SgInterfaceBody::get_traversalSuccessorNamesContainer() {
4521 0 : vector<string> traversalSuccessorContainer;
4522 0 : return traversalSuccessorContainer;
4523 : }
4524 : size_t
4525 0 : SgInterfaceBody::get_numberOfTraversalSuccessors() {
4526 0 : return 0;
4527 : }
4528 : SgNode *
4529 0 : SgInterfaceBody::get_traversalSuccessorByIndex(size_t idx) {
4530 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgInterfaceBody" << " that has no successors!" << endl;
4531 0 : ROSE_ASSERT(false);
4532 : return NULL;
4533 : }
4534 : size_t
4535 0 : SgInterfaceBody::get_childIndex(SgNode *child) {
4536 0 : cout << "error: get_childIndex called on node of type " << "SgInterfaceBody" << " that has no successors!" << endl;
4537 0 : ROSE_ASSERT(false);
4538 : return 0;
4539 : }
4540 : vector<SgNode*>
4541 0 : SgHeaderFileBody::get_traversalSuccessorContainer() {
4542 0 : vector<SgNode*> traversalSuccessorContainer;
4543 0 : return traversalSuccessorContainer;
4544 : }
4545 : vector<string>
4546 0 : SgHeaderFileBody::get_traversalSuccessorNamesContainer() {
4547 0 : vector<string> traversalSuccessorContainer;
4548 0 : return traversalSuccessorContainer;
4549 : }
4550 : size_t
4551 0 : SgHeaderFileBody::get_numberOfTraversalSuccessors() {
4552 0 : return 0;
4553 : }
4554 : SgNode *
4555 0 : SgHeaderFileBody::get_traversalSuccessorByIndex(size_t idx) {
4556 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgHeaderFileBody" << " that has no successors!" << endl;
4557 0 : ROSE_ASSERT(false);
4558 : return NULL;
4559 : }
4560 : size_t
4561 0 : SgHeaderFileBody::get_childIndex(SgNode *child) {
4562 0 : cout << "error: get_childIndex called on node of type " << "SgHeaderFileBody" << " that has no successors!" << endl;
4563 0 : ROSE_ASSERT(false);
4564 : return 0;
4565 : }
4566 : vector<SgNode*>
4567 0 : SgRenamePair::get_traversalSuccessorContainer() {
4568 0 : vector<SgNode*> traversalSuccessorContainer;
4569 0 : return traversalSuccessorContainer;
4570 : }
4571 : vector<string>
4572 0 : SgRenamePair::get_traversalSuccessorNamesContainer() {
4573 0 : vector<string> traversalSuccessorContainer;
4574 0 : return traversalSuccessorContainer;
4575 : }
4576 : size_t
4577 0 : SgRenamePair::get_numberOfTraversalSuccessors() {
4578 0 : return 0;
4579 : }
4580 : SgNode *
4581 0 : SgRenamePair::get_traversalSuccessorByIndex(size_t idx) {
4582 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgRenamePair" << " that has no successors!" << endl;
4583 0 : ROSE_ASSERT(false);
4584 : return NULL;
4585 : }
4586 : size_t
4587 0 : SgRenamePair::get_childIndex(SgNode *child) {
4588 0 : cout << "error: get_childIndex called on node of type " << "SgRenamePair" << " that has no successors!" << endl;
4589 0 : ROSE_ASSERT(false);
4590 : return 0;
4591 : }
4592 : vector<SgNode*>
4593 0 : SgOmpClause::get_traversalSuccessorContainer() {
4594 0 : vector<SgNode*> traversalSuccessorContainer;
4595 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
4596 0 : << "static: SgOmpClause" << endl << "dynamic: " << this->sage_class_name() << endl;
4597 0 : cerr << "Aborting ..." << endl;
4598 0 : ROSE_ASSERT(false);
4599 : return traversalSuccessorContainer;
4600 : }
4601 :
4602 : vector<string>
4603 0 : SgOmpClause::get_traversalSuccessorNamesContainer() {
4604 0 : vector<string> traversalSuccessorContainer;
4605 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
4606 0 : << "static: SgOmpClause" << endl << "dynamic: " << this->sage_class_name() << endl;
4607 0 : cerr << "Aborting ..." << endl;
4608 0 : ROSE_ASSERT(false);
4609 : return traversalSuccessorContainer;
4610 : }
4611 :
4612 : size_t
4613 0 : SgOmpClause::get_numberOfTraversalSuccessors() {
4614 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
4615 0 : << "static: SgOmpClause" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
4616 0 : cerr << "Aborting ..." << endl;
4617 0 : ROSE_ASSERT(false);
4618 : return 42;
4619 : }
4620 :
4621 : SgNode*
4622 0 : SgOmpClause::get_traversalSuccessorByIndex(size_t) {
4623 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
4624 0 : << "static: SgOmpClause" << endl << "dynamic: " << this->sage_class_name() << endl;
4625 0 : cerr << "Aborting ..." << endl;
4626 0 : ROSE_ASSERT(false);
4627 : return NULL;
4628 : }
4629 :
4630 : size_t
4631 0 : SgOmpClause::get_childIndex(SgNode *) {
4632 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
4633 0 : << "static: SgOmpClause" << endl << "dynamic: " << this->sage_class_name() << endl;
4634 0 : cerr << "Aborting ..." << endl;
4635 0 : ROSE_ASSERT(false);
4636 : return 42;
4637 : }
4638 :
4639 : vector<SgNode*>
4640 16 : SgOmpNowaitClause::get_traversalSuccessorContainer() {
4641 16 : vector<SgNode*> traversalSuccessorContainer;
4642 16 : return traversalSuccessorContainer;
4643 : }
4644 : vector<string>
4645 16 : SgOmpNowaitClause::get_traversalSuccessorNamesContainer() {
4646 16 : vector<string> traversalSuccessorContainer;
4647 16 : return traversalSuccessorContainer;
4648 : }
4649 : size_t
4650 119 : SgOmpNowaitClause::get_numberOfTraversalSuccessors() {
4651 119 : return 0;
4652 : }
4653 : SgNode *
4654 0 : SgOmpNowaitClause::get_traversalSuccessorByIndex(size_t idx) {
4655 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpNowaitClause" << " that has no successors!" << endl;
4656 0 : ROSE_ASSERT(false);
4657 : return NULL;
4658 : }
4659 : size_t
4660 0 : SgOmpNowaitClause::get_childIndex(SgNode *child) {
4661 0 : cout << "error: get_childIndex called on node of type " << "SgOmpNowaitClause" << " that has no successors!" << endl;
4662 0 : ROSE_ASSERT(false);
4663 : return 0;
4664 : }
4665 : vector<SgNode*>
4666 4 : SgOmpReadClause::get_traversalSuccessorContainer() {
4667 4 : vector<SgNode*> traversalSuccessorContainer;
4668 4 : return traversalSuccessorContainer;
4669 : }
4670 : vector<string>
4671 4 : SgOmpReadClause::get_traversalSuccessorNamesContainer() {
4672 4 : vector<string> traversalSuccessorContainer;
4673 4 : return traversalSuccessorContainer;
4674 : }
4675 : size_t
4676 32 : SgOmpReadClause::get_numberOfTraversalSuccessors() {
4677 32 : return 0;
4678 : }
4679 : SgNode *
4680 0 : SgOmpReadClause::get_traversalSuccessorByIndex(size_t idx) {
4681 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpReadClause" << " that has no successors!" << endl;
4682 0 : ROSE_ASSERT(false);
4683 : return NULL;
4684 : }
4685 : size_t
4686 0 : SgOmpReadClause::get_childIndex(SgNode *child) {
4687 0 : cout << "error: get_childIndex called on node of type " << "SgOmpReadClause" << " that has no successors!" << endl;
4688 0 : ROSE_ASSERT(false);
4689 : return 0;
4690 : }
4691 : vector<SgNode*>
4692 0 : SgOmpThreadsClause::get_traversalSuccessorContainer() {
4693 0 : vector<SgNode*> traversalSuccessorContainer;
4694 0 : return traversalSuccessorContainer;
4695 : }
4696 : vector<string>
4697 0 : SgOmpThreadsClause::get_traversalSuccessorNamesContainer() {
4698 0 : vector<string> traversalSuccessorContainer;
4699 0 : return traversalSuccessorContainer;
4700 : }
4701 : size_t
4702 0 : SgOmpThreadsClause::get_numberOfTraversalSuccessors() {
4703 0 : return 0;
4704 : }
4705 : SgNode *
4706 0 : SgOmpThreadsClause::get_traversalSuccessorByIndex(size_t idx) {
4707 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpThreadsClause" << " that has no successors!" << endl;
4708 0 : ROSE_ASSERT(false);
4709 : return NULL;
4710 : }
4711 : size_t
4712 0 : SgOmpThreadsClause::get_childIndex(SgNode *child) {
4713 0 : cout << "error: get_childIndex called on node of type " << "SgOmpThreadsClause" << " that has no successors!" << endl;
4714 0 : ROSE_ASSERT(false);
4715 : return 0;
4716 : }
4717 : vector<SgNode*>
4718 0 : SgOmpSimdClause::get_traversalSuccessorContainer() {
4719 0 : vector<SgNode*> traversalSuccessorContainer;
4720 0 : return traversalSuccessorContainer;
4721 : }
4722 : vector<string>
4723 0 : SgOmpSimdClause::get_traversalSuccessorNamesContainer() {
4724 0 : vector<string> traversalSuccessorContainer;
4725 0 : return traversalSuccessorContainer;
4726 : }
4727 : size_t
4728 0 : SgOmpSimdClause::get_numberOfTraversalSuccessors() {
4729 0 : return 0;
4730 : }
4731 : SgNode *
4732 0 : SgOmpSimdClause::get_traversalSuccessorByIndex(size_t idx) {
4733 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpSimdClause" << " that has no successors!" << endl;
4734 0 : ROSE_ASSERT(false);
4735 : return NULL;
4736 : }
4737 : size_t
4738 0 : SgOmpSimdClause::get_childIndex(SgNode *child) {
4739 0 : cout << "error: get_childIndex called on node of type " << "SgOmpSimdClause" << " that has no successors!" << endl;
4740 0 : ROSE_ASSERT(false);
4741 : return 0;
4742 : }
4743 : vector<SgNode*>
4744 2 : SgOmpWriteClause::get_traversalSuccessorContainer() {
4745 2 : vector<SgNode*> traversalSuccessorContainer;
4746 2 : return traversalSuccessorContainer;
4747 : }
4748 : vector<string>
4749 2 : SgOmpWriteClause::get_traversalSuccessorNamesContainer() {
4750 2 : vector<string> traversalSuccessorContainer;
4751 2 : return traversalSuccessorContainer;
4752 : }
4753 : size_t
4754 16 : SgOmpWriteClause::get_numberOfTraversalSuccessors() {
4755 16 : return 0;
4756 : }
4757 : SgNode *
4758 0 : SgOmpWriteClause::get_traversalSuccessorByIndex(size_t idx) {
4759 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpWriteClause" << " that has no successors!" << endl;
4760 0 : ROSE_ASSERT(false);
4761 : return NULL;
4762 : }
4763 : size_t
4764 0 : SgOmpWriteClause::get_childIndex(SgNode *child) {
4765 0 : cout << "error: get_childIndex called on node of type " << "SgOmpWriteClause" << " that has no successors!" << endl;
4766 0 : ROSE_ASSERT(false);
4767 : return 0;
4768 : }
4769 : vector<SgNode*>
4770 2 : SgOmpUpdateClause::get_traversalSuccessorContainer() {
4771 2 : vector<SgNode*> traversalSuccessorContainer;
4772 2 : return traversalSuccessorContainer;
4773 : }
4774 : vector<string>
4775 2 : SgOmpUpdateClause::get_traversalSuccessorNamesContainer() {
4776 2 : vector<string> traversalSuccessorContainer;
4777 2 : return traversalSuccessorContainer;
4778 : }
4779 : size_t
4780 16 : SgOmpUpdateClause::get_numberOfTraversalSuccessors() {
4781 16 : return 0;
4782 : }
4783 : SgNode *
4784 0 : SgOmpUpdateClause::get_traversalSuccessorByIndex(size_t idx) {
4785 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpUpdateClause" << " that has no successors!" << endl;
4786 0 : ROSE_ASSERT(false);
4787 : return NULL;
4788 : }
4789 : size_t
4790 0 : SgOmpUpdateClause::get_childIndex(SgNode *child) {
4791 0 : cout << "error: get_childIndex called on node of type " << "SgOmpUpdateClause" << " that has no successors!" << endl;
4792 0 : ROSE_ASSERT(false);
4793 : return 0;
4794 : }
4795 : vector<SgNode*>
4796 2 : SgOmpDepobjUpdateClause::get_traversalSuccessorContainer() {
4797 2 : vector<SgNode*> traversalSuccessorContainer;
4798 2 : return traversalSuccessorContainer;
4799 : }
4800 : vector<string>
4801 2 : SgOmpDepobjUpdateClause::get_traversalSuccessorNamesContainer() {
4802 2 : vector<string> traversalSuccessorContainer;
4803 2 : return traversalSuccessorContainer;
4804 : }
4805 : size_t
4806 16 : SgOmpDepobjUpdateClause::get_numberOfTraversalSuccessors() {
4807 16 : return 0;
4808 : }
4809 : SgNode *
4810 0 : SgOmpDepobjUpdateClause::get_traversalSuccessorByIndex(size_t idx) {
4811 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpDepobjUpdateClause" << " that has no successors!" << endl;
4812 0 : ROSE_ASSERT(false);
4813 : return NULL;
4814 : }
4815 : size_t
4816 0 : SgOmpDepobjUpdateClause::get_childIndex(SgNode *child) {
4817 0 : cout << "error: get_childIndex called on node of type " << "SgOmpDepobjUpdateClause" << " that has no successors!" << endl;
4818 0 : ROSE_ASSERT(false);
4819 : return 0;
4820 : }
4821 : vector<SgNode*>
4822 2 : SgOmpDestroyClause::get_traversalSuccessorContainer() {
4823 2 : vector<SgNode*> traversalSuccessorContainer;
4824 2 : return traversalSuccessorContainer;
4825 : }
4826 : vector<string>
4827 2 : SgOmpDestroyClause::get_traversalSuccessorNamesContainer() {
4828 2 : vector<string> traversalSuccessorContainer;
4829 2 : return traversalSuccessorContainer;
4830 : }
4831 : size_t
4832 16 : SgOmpDestroyClause::get_numberOfTraversalSuccessors() {
4833 16 : return 0;
4834 : }
4835 : SgNode *
4836 0 : SgOmpDestroyClause::get_traversalSuccessorByIndex(size_t idx) {
4837 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpDestroyClause" << " that has no successors!" << endl;
4838 0 : ROSE_ASSERT(false);
4839 : return NULL;
4840 : }
4841 : size_t
4842 0 : SgOmpDestroyClause::get_childIndex(SgNode *child) {
4843 0 : cout << "error: get_childIndex called on node of type " << "SgOmpDestroyClause" << " that has no successors!" << endl;
4844 0 : ROSE_ASSERT(false);
4845 : return 0;
4846 : }
4847 : vector<SgNode*>
4848 2 : SgOmpCaptureClause::get_traversalSuccessorContainer() {
4849 2 : vector<SgNode*> traversalSuccessorContainer;
4850 2 : return traversalSuccessorContainer;
4851 : }
4852 : vector<string>
4853 2 : SgOmpCaptureClause::get_traversalSuccessorNamesContainer() {
4854 2 : vector<string> traversalSuccessorContainer;
4855 2 : return traversalSuccessorContainer;
4856 : }
4857 : size_t
4858 16 : SgOmpCaptureClause::get_numberOfTraversalSuccessors() {
4859 16 : return 0;
4860 : }
4861 : SgNode *
4862 0 : SgOmpCaptureClause::get_traversalSuccessorByIndex(size_t idx) {
4863 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpCaptureClause" << " that has no successors!" << endl;
4864 0 : ROSE_ASSERT(false);
4865 : return NULL;
4866 : }
4867 : size_t
4868 0 : SgOmpCaptureClause::get_childIndex(SgNode *child) {
4869 0 : cout << "error: get_childIndex called on node of type " << "SgOmpCaptureClause" << " that has no successors!" << endl;
4870 0 : ROSE_ASSERT(false);
4871 : return 0;
4872 : }
4873 : vector<SgNode*>
4874 0 : SgOmpBeginClause::get_traversalSuccessorContainer() {
4875 0 : vector<SgNode*> traversalSuccessorContainer;
4876 0 : return traversalSuccessorContainer;
4877 : }
4878 : vector<string>
4879 0 : SgOmpBeginClause::get_traversalSuccessorNamesContainer() {
4880 0 : vector<string> traversalSuccessorContainer;
4881 0 : return traversalSuccessorContainer;
4882 : }
4883 : size_t
4884 0 : SgOmpBeginClause::get_numberOfTraversalSuccessors() {
4885 0 : return 0;
4886 : }
4887 : SgNode *
4888 0 : SgOmpBeginClause::get_traversalSuccessorByIndex(size_t idx) {
4889 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpBeginClause" << " that has no successors!" << endl;
4890 0 : ROSE_ASSERT(false);
4891 : return NULL;
4892 : }
4893 : size_t
4894 0 : SgOmpBeginClause::get_childIndex(SgNode *child) {
4895 0 : cout << "error: get_childIndex called on node of type " << "SgOmpBeginClause" << " that has no successors!" << endl;
4896 0 : ROSE_ASSERT(false);
4897 : return 0;
4898 : }
4899 : vector<SgNode*>
4900 0 : SgOmpEndClause::get_traversalSuccessorContainer() {
4901 0 : vector<SgNode*> traversalSuccessorContainer;
4902 0 : return traversalSuccessorContainer;
4903 : }
4904 : vector<string>
4905 0 : SgOmpEndClause::get_traversalSuccessorNamesContainer() {
4906 0 : vector<string> traversalSuccessorContainer;
4907 0 : return traversalSuccessorContainer;
4908 : }
4909 : size_t
4910 0 : SgOmpEndClause::get_numberOfTraversalSuccessors() {
4911 0 : return 0;
4912 : }
4913 : SgNode *
4914 0 : SgOmpEndClause::get_traversalSuccessorByIndex(size_t idx) {
4915 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpEndClause" << " that has no successors!" << endl;
4916 0 : ROSE_ASSERT(false);
4917 : return NULL;
4918 : }
4919 : size_t
4920 0 : SgOmpEndClause::get_childIndex(SgNode *child) {
4921 0 : cout << "error: get_childIndex called on node of type " << "SgOmpEndClause" << " that has no successors!" << endl;
4922 0 : ROSE_ASSERT(false);
4923 : return 0;
4924 : }
4925 : vector<SgNode*>
4926 8 : SgOmpUntiedClause::get_traversalSuccessorContainer() {
4927 8 : vector<SgNode*> traversalSuccessorContainer;
4928 8 : return traversalSuccessorContainer;
4929 : }
4930 : vector<string>
4931 8 : SgOmpUntiedClause::get_traversalSuccessorNamesContainer() {
4932 8 : vector<string> traversalSuccessorContainer;
4933 8 : return traversalSuccessorContainer;
4934 : }
4935 : size_t
4936 63 : SgOmpUntiedClause::get_numberOfTraversalSuccessors() {
4937 63 : return 0;
4938 : }
4939 : SgNode *
4940 0 : SgOmpUntiedClause::get_traversalSuccessorByIndex(size_t idx) {
4941 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpUntiedClause" << " that has no successors!" << endl;
4942 0 : ROSE_ASSERT(false);
4943 : return NULL;
4944 : }
4945 : size_t
4946 0 : SgOmpUntiedClause::get_childIndex(SgNode *child) {
4947 0 : cout << "error: get_childIndex called on node of type " << "SgOmpUntiedClause" << " that has no successors!" << endl;
4948 0 : ROSE_ASSERT(false);
4949 : return 0;
4950 : }
4951 : vector<SgNode*>
4952 0 : SgOmpSeqCstClause::get_traversalSuccessorContainer() {
4953 0 : vector<SgNode*> traversalSuccessorContainer;
4954 0 : return traversalSuccessorContainer;
4955 : }
4956 : vector<string>
4957 0 : SgOmpSeqCstClause::get_traversalSuccessorNamesContainer() {
4958 0 : vector<string> traversalSuccessorContainer;
4959 0 : return traversalSuccessorContainer;
4960 : }
4961 : size_t
4962 0 : SgOmpSeqCstClause::get_numberOfTraversalSuccessors() {
4963 0 : return 0;
4964 : }
4965 : SgNode *
4966 0 : SgOmpSeqCstClause::get_traversalSuccessorByIndex(size_t idx) {
4967 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpSeqCstClause" << " that has no successors!" << endl;
4968 0 : ROSE_ASSERT(false);
4969 : return NULL;
4970 : }
4971 : size_t
4972 0 : SgOmpSeqCstClause::get_childIndex(SgNode *child) {
4973 0 : cout << "error: get_childIndex called on node of type " << "SgOmpSeqCstClause" << " that has no successors!" << endl;
4974 0 : ROSE_ASSERT(false);
4975 : return 0;
4976 : }
4977 : vector<SgNode*>
4978 0 : SgOmpAcqRelClause::get_traversalSuccessorContainer() {
4979 0 : vector<SgNode*> traversalSuccessorContainer;
4980 0 : return traversalSuccessorContainer;
4981 : }
4982 : vector<string>
4983 0 : SgOmpAcqRelClause::get_traversalSuccessorNamesContainer() {
4984 0 : vector<string> traversalSuccessorContainer;
4985 0 : return traversalSuccessorContainer;
4986 : }
4987 : size_t
4988 0 : SgOmpAcqRelClause::get_numberOfTraversalSuccessors() {
4989 0 : return 0;
4990 : }
4991 : SgNode *
4992 0 : SgOmpAcqRelClause::get_traversalSuccessorByIndex(size_t idx) {
4993 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpAcqRelClause" << " that has no successors!" << endl;
4994 0 : ROSE_ASSERT(false);
4995 : return NULL;
4996 : }
4997 : size_t
4998 0 : SgOmpAcqRelClause::get_childIndex(SgNode *child) {
4999 0 : cout << "error: get_childIndex called on node of type " << "SgOmpAcqRelClause" << " that has no successors!" << endl;
5000 0 : ROSE_ASSERT(false);
5001 : return 0;
5002 : }
5003 : vector<SgNode*>
5004 2 : SgOmpReleaseClause::get_traversalSuccessorContainer() {
5005 2 : vector<SgNode*> traversalSuccessorContainer;
5006 2 : return traversalSuccessorContainer;
5007 : }
5008 : vector<string>
5009 2 : SgOmpReleaseClause::get_traversalSuccessorNamesContainer() {
5010 2 : vector<string> traversalSuccessorContainer;
5011 2 : return traversalSuccessorContainer;
5012 : }
5013 : size_t
5014 16 : SgOmpReleaseClause::get_numberOfTraversalSuccessors() {
5015 16 : return 0;
5016 : }
5017 : SgNode *
5018 0 : SgOmpReleaseClause::get_traversalSuccessorByIndex(size_t idx) {
5019 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpReleaseClause" << " that has no successors!" << endl;
5020 0 : ROSE_ASSERT(false);
5021 : return NULL;
5022 : }
5023 : size_t
5024 0 : SgOmpReleaseClause::get_childIndex(SgNode *child) {
5025 0 : cout << "error: get_childIndex called on node of type " << "SgOmpReleaseClause" << " that has no successors!" << endl;
5026 0 : ROSE_ASSERT(false);
5027 : return 0;
5028 : }
5029 : vector<SgNode*>
5030 0 : SgOmpAcquireClause::get_traversalSuccessorContainer() {
5031 0 : vector<SgNode*> traversalSuccessorContainer;
5032 0 : return traversalSuccessorContainer;
5033 : }
5034 : vector<string>
5035 0 : SgOmpAcquireClause::get_traversalSuccessorNamesContainer() {
5036 0 : vector<string> traversalSuccessorContainer;
5037 0 : return traversalSuccessorContainer;
5038 : }
5039 : size_t
5040 0 : SgOmpAcquireClause::get_numberOfTraversalSuccessors() {
5041 0 : return 0;
5042 : }
5043 : SgNode *
5044 0 : SgOmpAcquireClause::get_traversalSuccessorByIndex(size_t idx) {
5045 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpAcquireClause" << " that has no successors!" << endl;
5046 0 : ROSE_ASSERT(false);
5047 : return NULL;
5048 : }
5049 : size_t
5050 0 : SgOmpAcquireClause::get_childIndex(SgNode *child) {
5051 0 : cout << "error: get_childIndex called on node of type " << "SgOmpAcquireClause" << " that has no successors!" << endl;
5052 0 : ROSE_ASSERT(false);
5053 : return 0;
5054 : }
5055 : vector<SgNode*>
5056 0 : SgOmpRelaxedClause::get_traversalSuccessorContainer() {
5057 0 : vector<SgNode*> traversalSuccessorContainer;
5058 0 : return traversalSuccessorContainer;
5059 : }
5060 : vector<string>
5061 0 : SgOmpRelaxedClause::get_traversalSuccessorNamesContainer() {
5062 0 : vector<string> traversalSuccessorContainer;
5063 0 : return traversalSuccessorContainer;
5064 : }
5065 : size_t
5066 0 : SgOmpRelaxedClause::get_numberOfTraversalSuccessors() {
5067 0 : return 0;
5068 : }
5069 : SgNode *
5070 0 : SgOmpRelaxedClause::get_traversalSuccessorByIndex(size_t idx) {
5071 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpRelaxedClause" << " that has no successors!" << endl;
5072 0 : ROSE_ASSERT(false);
5073 : return NULL;
5074 : }
5075 : size_t
5076 0 : SgOmpRelaxedClause::get_childIndex(SgNode *child) {
5077 0 : cout << "error: get_childIndex called on node of type " << "SgOmpRelaxedClause" << " that has no successors!" << endl;
5078 0 : ROSE_ASSERT(false);
5079 : return 0;
5080 : }
5081 : vector<SgNode*>
5082 4 : SgOmpReverseOffloadClause::get_traversalSuccessorContainer() {
5083 4 : vector<SgNode*> traversalSuccessorContainer;
5084 4 : return traversalSuccessorContainer;
5085 : }
5086 : vector<string>
5087 4 : SgOmpReverseOffloadClause::get_traversalSuccessorNamesContainer() {
5088 4 : vector<string> traversalSuccessorContainer;
5089 4 : return traversalSuccessorContainer;
5090 : }
5091 : size_t
5092 30 : SgOmpReverseOffloadClause::get_numberOfTraversalSuccessors() {
5093 30 : return 0;
5094 : }
5095 : SgNode *
5096 0 : SgOmpReverseOffloadClause::get_traversalSuccessorByIndex(size_t idx) {
5097 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpReverseOffloadClause" << " that has no successors!" << endl;
5098 0 : ROSE_ASSERT(false);
5099 : return NULL;
5100 : }
5101 : size_t
5102 0 : SgOmpReverseOffloadClause::get_childIndex(SgNode *child) {
5103 0 : cout << "error: get_childIndex called on node of type " << "SgOmpReverseOffloadClause" << " that has no successors!" << endl;
5104 0 : ROSE_ASSERT(false);
5105 : return 0;
5106 : }
5107 : vector<SgNode*>
5108 2 : SgOmpUnifiedAddressClause::get_traversalSuccessorContainer() {
5109 2 : vector<SgNode*> traversalSuccessorContainer;
5110 2 : return traversalSuccessorContainer;
5111 : }
5112 : vector<string>
5113 2 : SgOmpUnifiedAddressClause::get_traversalSuccessorNamesContainer() {
5114 2 : vector<string> traversalSuccessorContainer;
5115 2 : return traversalSuccessorContainer;
5116 : }
5117 : size_t
5118 15 : SgOmpUnifiedAddressClause::get_numberOfTraversalSuccessors() {
5119 15 : return 0;
5120 : }
5121 : SgNode *
5122 0 : SgOmpUnifiedAddressClause::get_traversalSuccessorByIndex(size_t idx) {
5123 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpUnifiedAddressClause" << " that has no successors!" << endl;
5124 0 : ROSE_ASSERT(false);
5125 : return NULL;
5126 : }
5127 : size_t
5128 0 : SgOmpUnifiedAddressClause::get_childIndex(SgNode *child) {
5129 0 : cout << "error: get_childIndex called on node of type " << "SgOmpUnifiedAddressClause" << " that has no successors!" << endl;
5130 0 : ROSE_ASSERT(false);
5131 : return 0;
5132 : }
5133 : vector<SgNode*>
5134 2 : SgOmpUnifiedSharedMemoryClause::get_traversalSuccessorContainer() {
5135 2 : vector<SgNode*> traversalSuccessorContainer;
5136 2 : return traversalSuccessorContainer;
5137 : }
5138 : vector<string>
5139 2 : SgOmpUnifiedSharedMemoryClause::get_traversalSuccessorNamesContainer() {
5140 2 : vector<string> traversalSuccessorContainer;
5141 2 : return traversalSuccessorContainer;
5142 : }
5143 : size_t
5144 15 : SgOmpUnifiedSharedMemoryClause::get_numberOfTraversalSuccessors() {
5145 15 : return 0;
5146 : }
5147 : SgNode *
5148 0 : SgOmpUnifiedSharedMemoryClause::get_traversalSuccessorByIndex(size_t idx) {
5149 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpUnifiedSharedMemoryClause" << " that has no successors!" << endl;
5150 0 : ROSE_ASSERT(false);
5151 : return NULL;
5152 : }
5153 : size_t
5154 0 : SgOmpUnifiedSharedMemoryClause::get_childIndex(SgNode *child) {
5155 0 : cout << "error: get_childIndex called on node of type " << "SgOmpUnifiedSharedMemoryClause" << " that has no successors!" << endl;
5156 0 : ROSE_ASSERT(false);
5157 : return 0;
5158 : }
5159 : vector<SgNode*>
5160 2 : SgOmpDynamicAllocatorsClause::get_traversalSuccessorContainer() {
5161 2 : vector<SgNode*> traversalSuccessorContainer;
5162 2 : return traversalSuccessorContainer;
5163 : }
5164 : vector<string>
5165 2 : SgOmpDynamicAllocatorsClause::get_traversalSuccessorNamesContainer() {
5166 2 : vector<string> traversalSuccessorContainer;
5167 2 : return traversalSuccessorContainer;
5168 : }
5169 : size_t
5170 15 : SgOmpDynamicAllocatorsClause::get_numberOfTraversalSuccessors() {
5171 15 : return 0;
5172 : }
5173 : SgNode *
5174 0 : SgOmpDynamicAllocatorsClause::get_traversalSuccessorByIndex(size_t idx) {
5175 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpDynamicAllocatorsClause" << " that has no successors!" << endl;
5176 0 : ROSE_ASSERT(false);
5177 : return NULL;
5178 : }
5179 : size_t
5180 0 : SgOmpDynamicAllocatorsClause::get_childIndex(SgNode *child) {
5181 0 : cout << "error: get_childIndex called on node of type " << "SgOmpDynamicAllocatorsClause" << " that has no successors!" << endl;
5182 0 : ROSE_ASSERT(false);
5183 : return 0;
5184 : }
5185 : vector<SgNode*>
5186 0 : SgOmpParallelClause::get_traversalSuccessorContainer() {
5187 0 : vector<SgNode*> traversalSuccessorContainer;
5188 0 : return traversalSuccessorContainer;
5189 : }
5190 : vector<string>
5191 0 : SgOmpParallelClause::get_traversalSuccessorNamesContainer() {
5192 0 : vector<string> traversalSuccessorContainer;
5193 0 : return traversalSuccessorContainer;
5194 : }
5195 : size_t
5196 0 : SgOmpParallelClause::get_numberOfTraversalSuccessors() {
5197 0 : return 0;
5198 : }
5199 : SgNode *
5200 0 : SgOmpParallelClause::get_traversalSuccessorByIndex(size_t idx) {
5201 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpParallelClause" << " that has no successors!" << endl;
5202 0 : ROSE_ASSERT(false);
5203 : return NULL;
5204 : }
5205 : size_t
5206 0 : SgOmpParallelClause::get_childIndex(SgNode *child) {
5207 0 : cout << "error: get_childIndex called on node of type " << "SgOmpParallelClause" << " that has no successors!" << endl;
5208 0 : ROSE_ASSERT(false);
5209 : return 0;
5210 : }
5211 : vector<SgNode*>
5212 0 : SgOmpSectionsClause::get_traversalSuccessorContainer() {
5213 0 : vector<SgNode*> traversalSuccessorContainer;
5214 0 : return traversalSuccessorContainer;
5215 : }
5216 : vector<string>
5217 0 : SgOmpSectionsClause::get_traversalSuccessorNamesContainer() {
5218 0 : vector<string> traversalSuccessorContainer;
5219 0 : return traversalSuccessorContainer;
5220 : }
5221 : size_t
5222 0 : SgOmpSectionsClause::get_numberOfTraversalSuccessors() {
5223 0 : return 0;
5224 : }
5225 : SgNode *
5226 0 : SgOmpSectionsClause::get_traversalSuccessorByIndex(size_t idx) {
5227 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpSectionsClause" << " that has no successors!" << endl;
5228 0 : ROSE_ASSERT(false);
5229 : return NULL;
5230 : }
5231 : size_t
5232 0 : SgOmpSectionsClause::get_childIndex(SgNode *child) {
5233 0 : cout << "error: get_childIndex called on node of type " << "SgOmpSectionsClause" << " that has no successors!" << endl;
5234 0 : ROSE_ASSERT(false);
5235 : return 0;
5236 : }
5237 : vector<SgNode*>
5238 0 : SgOmpForClause::get_traversalSuccessorContainer() {
5239 0 : vector<SgNode*> traversalSuccessorContainer;
5240 0 : return traversalSuccessorContainer;
5241 : }
5242 : vector<string>
5243 0 : SgOmpForClause::get_traversalSuccessorNamesContainer() {
5244 0 : vector<string> traversalSuccessorContainer;
5245 0 : return traversalSuccessorContainer;
5246 : }
5247 : size_t
5248 0 : SgOmpForClause::get_numberOfTraversalSuccessors() {
5249 0 : return 0;
5250 : }
5251 : SgNode *
5252 0 : SgOmpForClause::get_traversalSuccessorByIndex(size_t idx) {
5253 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpForClause" << " that has no successors!" << endl;
5254 0 : ROSE_ASSERT(false);
5255 : return NULL;
5256 : }
5257 : size_t
5258 0 : SgOmpForClause::get_childIndex(SgNode *child) {
5259 0 : cout << "error: get_childIndex called on node of type " << "SgOmpForClause" << " that has no successors!" << endl;
5260 0 : ROSE_ASSERT(false);
5261 : return 0;
5262 : }
5263 : vector<SgNode*>
5264 0 : SgOmpTaskgroupClause::get_traversalSuccessorContainer() {
5265 0 : vector<SgNode*> traversalSuccessorContainer;
5266 0 : return traversalSuccessorContainer;
5267 : }
5268 : vector<string>
5269 0 : SgOmpTaskgroupClause::get_traversalSuccessorNamesContainer() {
5270 0 : vector<string> traversalSuccessorContainer;
5271 0 : return traversalSuccessorContainer;
5272 : }
5273 : size_t
5274 0 : SgOmpTaskgroupClause::get_numberOfTraversalSuccessors() {
5275 0 : return 0;
5276 : }
5277 : SgNode *
5278 0 : SgOmpTaskgroupClause::get_traversalSuccessorByIndex(size_t idx) {
5279 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpTaskgroupClause" << " that has no successors!" << endl;
5280 0 : ROSE_ASSERT(false);
5281 : return NULL;
5282 : }
5283 : size_t
5284 0 : SgOmpTaskgroupClause::get_childIndex(SgNode *child) {
5285 0 : cout << "error: get_childIndex called on node of type " << "SgOmpTaskgroupClause" << " that has no successors!" << endl;
5286 0 : ROSE_ASSERT(false);
5287 : return 0;
5288 : }
5289 : vector<SgNode*>
5290 2 : SgOmpNogroupClause::get_traversalSuccessorContainer() {
5291 2 : vector<SgNode*> traversalSuccessorContainer;
5292 2 : return traversalSuccessorContainer;
5293 : }
5294 : vector<string>
5295 2 : SgOmpNogroupClause::get_traversalSuccessorNamesContainer() {
5296 2 : vector<string> traversalSuccessorContainer;
5297 2 : return traversalSuccessorContainer;
5298 : }
5299 : size_t
5300 16 : SgOmpNogroupClause::get_numberOfTraversalSuccessors() {
5301 16 : return 0;
5302 : }
5303 : SgNode *
5304 0 : SgOmpNogroupClause::get_traversalSuccessorByIndex(size_t idx) {
5305 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpNogroupClause" << " that has no successors!" << endl;
5306 0 : ROSE_ASSERT(false);
5307 : return NULL;
5308 : }
5309 : size_t
5310 0 : SgOmpNogroupClause::get_childIndex(SgNode *child) {
5311 0 : cout << "error: get_childIndex called on node of type " << "SgOmpNogroupClause" << " that has no successors!" << endl;
5312 0 : ROSE_ASSERT(false);
5313 : return 0;
5314 : }
5315 : vector<SgNode*>
5316 10 : SgOmpDefaultClause::get_traversalSuccessorContainer() {
5317 10 : vector<SgNode*> traversalSuccessorContainer;
5318 10 : traversalSuccessorContainer.reserve(1);
5319 10 : traversalSuccessorContainer.push_back(p_variant_directive);
5320 10 : return traversalSuccessorContainer;
5321 : }
5322 : vector<string>
5323 10 : SgOmpDefaultClause::get_traversalSuccessorNamesContainer() {
5324 10 : vector<string> traversalSuccessorContainer;
5325 20 : traversalSuccessorContainer.push_back("p_variant_directive");
5326 10 : return traversalSuccessorContainer;
5327 : }
5328 : size_t
5329 78 : SgOmpDefaultClause::get_numberOfTraversalSuccessors() {
5330 78 : return 1;
5331 : }
5332 : SgNode *
5333 78 : SgOmpDefaultClause::get_traversalSuccessorByIndex(size_t idx) {
5334 78 : switch (idx) {
5335 78 : case 0: ROSE_ASSERT(p_variant_directive == NULL || p_variant_directive != NULL); return p_variant_directive;
5336 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
5337 0 : ROSE_ASSERT(false);
5338 : return NULL;
5339 : }
5340 : }
5341 : size_t
5342 0 : SgOmpDefaultClause::get_childIndex(SgNode *child) {
5343 0 : if (child == p_variant_directive) return 0;
5344 0 : else return (size_t) -1;
5345 : }
5346 : vector<SgNode*>
5347 0 : SgOmpAllocatorClause::get_traversalSuccessorContainer() {
5348 0 : vector<SgNode*> traversalSuccessorContainer;
5349 0 : return traversalSuccessorContainer;
5350 : }
5351 : vector<string>
5352 0 : SgOmpAllocatorClause::get_traversalSuccessorNamesContainer() {
5353 0 : vector<string> traversalSuccessorContainer;
5354 0 : return traversalSuccessorContainer;
5355 : }
5356 : size_t
5357 0 : SgOmpAllocatorClause::get_numberOfTraversalSuccessors() {
5358 0 : return 0;
5359 : }
5360 : SgNode *
5361 0 : SgOmpAllocatorClause::get_traversalSuccessorByIndex(size_t idx) {
5362 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpAllocatorClause" << " that has no successors!" << endl;
5363 0 : ROSE_ASSERT(false);
5364 : return NULL;
5365 : }
5366 : size_t
5367 0 : SgOmpAllocatorClause::get_childIndex(SgNode *child) {
5368 0 : cout << "error: get_childIndex called on node of type " << "SgOmpAllocatorClause" << " that has no successors!" << endl;
5369 0 : ROSE_ASSERT(false);
5370 : return 0;
5371 : }
5372 : vector<SgNode*>
5373 0 : SgOmpAtomicClause::get_traversalSuccessorContainer() {
5374 0 : vector<SgNode*> traversalSuccessorContainer;
5375 0 : return traversalSuccessorContainer;
5376 : }
5377 : vector<string>
5378 0 : SgOmpAtomicClause::get_traversalSuccessorNamesContainer() {
5379 0 : vector<string> traversalSuccessorContainer;
5380 0 : return traversalSuccessorContainer;
5381 : }
5382 : size_t
5383 0 : SgOmpAtomicClause::get_numberOfTraversalSuccessors() {
5384 0 : return 0;
5385 : }
5386 : SgNode *
5387 0 : SgOmpAtomicClause::get_traversalSuccessorByIndex(size_t idx) {
5388 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpAtomicClause" << " that has no successors!" << endl;
5389 0 : ROSE_ASSERT(false);
5390 : return NULL;
5391 : }
5392 : size_t
5393 0 : SgOmpAtomicClause::get_childIndex(SgNode *child) {
5394 0 : cout << "error: get_childIndex called on node of type " << "SgOmpAtomicClause" << " that has no successors!" << endl;
5395 0 : ROSE_ASSERT(false);
5396 : return 0;
5397 : }
5398 : vector<SgNode*>
5399 6 : SgOmpProcBindClause::get_traversalSuccessorContainer() {
5400 6 : vector<SgNode*> traversalSuccessorContainer;
5401 6 : return traversalSuccessorContainer;
5402 : }
5403 : vector<string>
5404 6 : SgOmpProcBindClause::get_traversalSuccessorNamesContainer() {
5405 6 : vector<string> traversalSuccessorContainer;
5406 6 : return traversalSuccessorContainer;
5407 : }
5408 : size_t
5409 45 : SgOmpProcBindClause::get_numberOfTraversalSuccessors() {
5410 45 : return 0;
5411 : }
5412 : SgNode *
5413 0 : SgOmpProcBindClause::get_traversalSuccessorByIndex(size_t idx) {
5414 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpProcBindClause" << " that has no successors!" << endl;
5415 0 : ROSE_ASSERT(false);
5416 : return NULL;
5417 : }
5418 : size_t
5419 0 : SgOmpProcBindClause::get_childIndex(SgNode *child) {
5420 0 : cout << "error: get_childIndex called on node of type " << "SgOmpProcBindClause" << " that has no successors!" << endl;
5421 0 : ROSE_ASSERT(false);
5422 : return 0;
5423 : }
5424 : vector<SgNode*>
5425 2 : SgOmpBindClause::get_traversalSuccessorContainer() {
5426 2 : vector<SgNode*> traversalSuccessorContainer;
5427 2 : return traversalSuccessorContainer;
5428 : }
5429 : vector<string>
5430 2 : SgOmpBindClause::get_traversalSuccessorNamesContainer() {
5431 2 : vector<string> traversalSuccessorContainer;
5432 2 : return traversalSuccessorContainer;
5433 : }
5434 : size_t
5435 16 : SgOmpBindClause::get_numberOfTraversalSuccessors() {
5436 16 : return 0;
5437 : }
5438 : SgNode *
5439 0 : SgOmpBindClause::get_traversalSuccessorByIndex(size_t idx) {
5440 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpBindClause" << " that has no successors!" << endl;
5441 0 : ROSE_ASSERT(false);
5442 : return NULL;
5443 : }
5444 : size_t
5445 0 : SgOmpBindClause::get_childIndex(SgNode *child) {
5446 0 : cout << "error: get_childIndex called on node of type " << "SgOmpBindClause" << " that has no successors!" << endl;
5447 0 : ROSE_ASSERT(false);
5448 : return 0;
5449 : }
5450 : vector<SgNode*>
5451 0 : SgOmpOrderClause::get_traversalSuccessorContainer() {
5452 0 : vector<SgNode*> traversalSuccessorContainer;
5453 0 : return traversalSuccessorContainer;
5454 : }
5455 : vector<string>
5456 0 : SgOmpOrderClause::get_traversalSuccessorNamesContainer() {
5457 0 : vector<string> traversalSuccessorContainer;
5458 0 : return traversalSuccessorContainer;
5459 : }
5460 : size_t
5461 0 : SgOmpOrderClause::get_numberOfTraversalSuccessors() {
5462 0 : return 0;
5463 : }
5464 : SgNode *
5465 0 : SgOmpOrderClause::get_traversalSuccessorByIndex(size_t idx) {
5466 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpOrderClause" << " that has no successors!" << endl;
5467 0 : ROSE_ASSERT(false);
5468 : return NULL;
5469 : }
5470 : size_t
5471 0 : SgOmpOrderClause::get_childIndex(SgNode *child) {
5472 0 : cout << "error: get_childIndex called on node of type " << "SgOmpOrderClause" << " that has no successors!" << endl;
5473 0 : ROSE_ASSERT(false);
5474 : return 0;
5475 : }
5476 : vector<SgNode*>
5477 2 : SgOmpDistScheduleClause::get_traversalSuccessorContainer() {
5478 2 : vector<SgNode*> traversalSuccessorContainer;
5479 2 : traversalSuccessorContainer.reserve(1);
5480 2 : traversalSuccessorContainer.push_back(p_chunk_size);
5481 2 : return traversalSuccessorContainer;
5482 : }
5483 : vector<string>
5484 2 : SgOmpDistScheduleClause::get_traversalSuccessorNamesContainer() {
5485 2 : vector<string> traversalSuccessorContainer;
5486 4 : traversalSuccessorContainer.push_back("p_chunk_size");
5487 2 : return traversalSuccessorContainer;
5488 : }
5489 : size_t
5490 16 : SgOmpDistScheduleClause::get_numberOfTraversalSuccessors() {
5491 16 : return 1;
5492 : }
5493 : SgNode *
5494 16 : SgOmpDistScheduleClause::get_traversalSuccessorByIndex(size_t idx) {
5495 16 : switch (idx) {
5496 16 : case 0: ROSE_ASSERT(p_chunk_size == NULL || p_chunk_size != NULL); return p_chunk_size;
5497 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
5498 0 : ROSE_ASSERT(false);
5499 : return NULL;
5500 : }
5501 : }
5502 : size_t
5503 0 : SgOmpDistScheduleClause::get_childIndex(SgNode *child) {
5504 0 : if (child == p_chunk_size) return 0;
5505 0 : else return (size_t) -1;
5506 : }
5507 : vector<SgNode*>
5508 0 : SgOmpExpressionClause::get_traversalSuccessorContainer() {
5509 0 : vector<SgNode*> traversalSuccessorContainer;
5510 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
5511 0 : << "static: SgOmpExpressionClause" << endl << "dynamic: " << this->sage_class_name() << endl;
5512 0 : cerr << "Aborting ..." << endl;
5513 0 : ROSE_ASSERT(false);
5514 : return traversalSuccessorContainer;
5515 : }
5516 :
5517 : vector<string>
5518 0 : SgOmpExpressionClause::get_traversalSuccessorNamesContainer() {
5519 0 : vector<string> traversalSuccessorContainer;
5520 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
5521 0 : << "static: SgOmpExpressionClause" << endl << "dynamic: " << this->sage_class_name() << endl;
5522 0 : cerr << "Aborting ..." << endl;
5523 0 : ROSE_ASSERT(false);
5524 : return traversalSuccessorContainer;
5525 : }
5526 :
5527 : size_t
5528 0 : SgOmpExpressionClause::get_numberOfTraversalSuccessors() {
5529 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
5530 0 : << "static: SgOmpExpressionClause" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
5531 0 : cerr << "Aborting ..." << endl;
5532 0 : ROSE_ASSERT(false);
5533 : return 42;
5534 : }
5535 :
5536 : SgNode*
5537 0 : SgOmpExpressionClause::get_traversalSuccessorByIndex(size_t) {
5538 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
5539 0 : << "static: SgOmpExpressionClause" << endl << "dynamic: " << this->sage_class_name() << endl;
5540 0 : cerr << "Aborting ..." << endl;
5541 0 : ROSE_ASSERT(false);
5542 : return NULL;
5543 : }
5544 :
5545 : size_t
5546 0 : SgOmpExpressionClause::get_childIndex(SgNode *) {
5547 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
5548 0 : << "static: SgOmpExpressionClause" << endl << "dynamic: " << this->sage_class_name() << endl;
5549 0 : cerr << "Aborting ..." << endl;
5550 0 : ROSE_ASSERT(false);
5551 : return 42;
5552 : }
5553 :
5554 : vector<SgNode*>
5555 0 : SgOmpOrderedClause::get_traversalSuccessorContainer() {
5556 0 : vector<SgNode*> traversalSuccessorContainer;
5557 0 : traversalSuccessorContainer.reserve(1);
5558 0 : traversalSuccessorContainer.push_back(p_expression);
5559 0 : return traversalSuccessorContainer;
5560 : }
5561 : vector<string>
5562 0 : SgOmpOrderedClause::get_traversalSuccessorNamesContainer() {
5563 0 : vector<string> traversalSuccessorContainer;
5564 0 : traversalSuccessorContainer.push_back("p_expression");
5565 0 : return traversalSuccessorContainer;
5566 : }
5567 : size_t
5568 0 : SgOmpOrderedClause::get_numberOfTraversalSuccessors() {
5569 0 : return 1;
5570 : }
5571 : SgNode *
5572 0 : SgOmpOrderedClause::get_traversalSuccessorByIndex(size_t idx) {
5573 0 : switch (idx) {
5574 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
5575 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
5576 0 : ROSE_ASSERT(false);
5577 : return NULL;
5578 : }
5579 : }
5580 : size_t
5581 0 : SgOmpOrderedClause::get_childIndex(SgNode *child) {
5582 0 : if (child == p_expression) return 0;
5583 0 : else return (size_t) -1;
5584 : }
5585 : vector<SgNode*>
5586 4 : SgOmpCollapseClause::get_traversalSuccessorContainer() {
5587 4 : vector<SgNode*> traversalSuccessorContainer;
5588 4 : traversalSuccessorContainer.reserve(1);
5589 4 : traversalSuccessorContainer.push_back(p_expression);
5590 4 : return traversalSuccessorContainer;
5591 : }
5592 : vector<string>
5593 4 : SgOmpCollapseClause::get_traversalSuccessorNamesContainer() {
5594 4 : vector<string> traversalSuccessorContainer;
5595 8 : traversalSuccessorContainer.push_back("p_expression");
5596 4 : return traversalSuccessorContainer;
5597 : }
5598 : size_t
5599 32 : SgOmpCollapseClause::get_numberOfTraversalSuccessors() {
5600 32 : return 1;
5601 : }
5602 : SgNode *
5603 32 : SgOmpCollapseClause::get_traversalSuccessorByIndex(size_t idx) {
5604 32 : switch (idx) {
5605 32 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
5606 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
5607 0 : ROSE_ASSERT(false);
5608 : return NULL;
5609 : }
5610 : }
5611 : size_t
5612 0 : SgOmpCollapseClause::get_childIndex(SgNode *child) {
5613 0 : if (child == p_expression) return 0;
5614 0 : else return (size_t) -1;
5615 : }
5616 : vector<SgNode*>
5617 66 : SgOmpIfClause::get_traversalSuccessorContainer() {
5618 66 : vector<SgNode*> traversalSuccessorContainer;
5619 66 : traversalSuccessorContainer.reserve(1);
5620 66 : traversalSuccessorContainer.push_back(p_expression);
5621 66 : return traversalSuccessorContainer;
5622 : }
5623 : vector<string>
5624 66 : SgOmpIfClause::get_traversalSuccessorNamesContainer() {
5625 66 : vector<string> traversalSuccessorContainer;
5626 132 : traversalSuccessorContainer.push_back("p_expression");
5627 66 : return traversalSuccessorContainer;
5628 : }
5629 : size_t
5630 527 : SgOmpIfClause::get_numberOfTraversalSuccessors() {
5631 527 : return 1;
5632 : }
5633 : SgNode *
5634 527 : SgOmpIfClause::get_traversalSuccessorByIndex(size_t idx) {
5635 527 : switch (idx) {
5636 527 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
5637 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
5638 0 : ROSE_ASSERT(false);
5639 : return NULL;
5640 : }
5641 : }
5642 : size_t
5643 0 : SgOmpIfClause::get_childIndex(SgNode *child) {
5644 0 : if (child == p_expression) return 0;
5645 0 : else return (size_t) -1;
5646 : }
5647 : vector<SgNode*>
5648 36 : SgUpirNumUnitsField::get_traversalSuccessorContainer() {
5649 36 : vector<SgNode*> traversalSuccessorContainer;
5650 36 : traversalSuccessorContainer.reserve(1);
5651 36 : traversalSuccessorContainer.push_back(p_expression);
5652 36 : return traversalSuccessorContainer;
5653 : }
5654 : vector<string>
5655 36 : SgUpirNumUnitsField::get_traversalSuccessorNamesContainer() {
5656 36 : vector<string> traversalSuccessorContainer;
5657 72 : traversalSuccessorContainer.push_back("p_expression");
5658 36 : return traversalSuccessorContainer;
5659 : }
5660 : size_t
5661 300 : SgUpirNumUnitsField::get_numberOfTraversalSuccessors() {
5662 300 : return 1;
5663 : }
5664 : SgNode *
5665 300 : SgUpirNumUnitsField::get_traversalSuccessorByIndex(size_t idx) {
5666 300 : switch (idx) {
5667 300 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
5668 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
5669 0 : ROSE_ASSERT(false);
5670 : return NULL;
5671 : }
5672 : }
5673 : size_t
5674 0 : SgUpirNumUnitsField::get_childIndex(SgNode *child) {
5675 0 : if (child == p_expression) return 0;
5676 0 : else return (size_t) -1;
5677 : }
5678 : vector<SgNode*>
5679 16 : SgOmpNumTeamsClause::get_traversalSuccessorContainer() {
5680 16 : vector<SgNode*> traversalSuccessorContainer;
5681 16 : traversalSuccessorContainer.reserve(1);
5682 16 : traversalSuccessorContainer.push_back(p_expression);
5683 16 : return traversalSuccessorContainer;
5684 : }
5685 : vector<string>
5686 16 : SgOmpNumTeamsClause::get_traversalSuccessorNamesContainer() {
5687 16 : vector<string> traversalSuccessorContainer;
5688 32 : traversalSuccessorContainer.push_back("p_expression");
5689 16 : return traversalSuccessorContainer;
5690 : }
5691 : size_t
5692 128 : SgOmpNumTeamsClause::get_numberOfTraversalSuccessors() {
5693 128 : return 1;
5694 : }
5695 : SgNode *
5696 128 : SgOmpNumTeamsClause::get_traversalSuccessorByIndex(size_t idx) {
5697 128 : switch (idx) {
5698 128 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
5699 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
5700 0 : ROSE_ASSERT(false);
5701 : return NULL;
5702 : }
5703 : }
5704 : size_t
5705 0 : SgOmpNumTeamsClause::get_childIndex(SgNode *child) {
5706 0 : if (child == p_expression) return 0;
5707 0 : else return (size_t) -1;
5708 : }
5709 : vector<SgNode*>
5710 4 : SgOmpThreadLimitClause::get_traversalSuccessorContainer() {
5711 4 : vector<SgNode*> traversalSuccessorContainer;
5712 4 : traversalSuccessorContainer.reserve(1);
5713 4 : traversalSuccessorContainer.push_back(p_expression);
5714 4 : return traversalSuccessorContainer;
5715 : }
5716 : vector<string>
5717 4 : SgOmpThreadLimitClause::get_traversalSuccessorNamesContainer() {
5718 4 : vector<string> traversalSuccessorContainer;
5719 8 : traversalSuccessorContainer.push_back("p_expression");
5720 4 : return traversalSuccessorContainer;
5721 : }
5722 : size_t
5723 32 : SgOmpThreadLimitClause::get_numberOfTraversalSuccessors() {
5724 32 : return 1;
5725 : }
5726 : SgNode *
5727 32 : SgOmpThreadLimitClause::get_traversalSuccessorByIndex(size_t idx) {
5728 32 : switch (idx) {
5729 32 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
5730 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
5731 0 : ROSE_ASSERT(false);
5732 : return NULL;
5733 : }
5734 : }
5735 : size_t
5736 0 : SgOmpThreadLimitClause::get_childIndex(SgNode *child) {
5737 0 : if (child == p_expression) return 0;
5738 0 : else return (size_t) -1;
5739 : }
5740 : vector<SgNode*>
5741 16 : SgOmpDeviceClause::get_traversalSuccessorContainer() {
5742 16 : vector<SgNode*> traversalSuccessorContainer;
5743 16 : traversalSuccessorContainer.reserve(1);
5744 16 : traversalSuccessorContainer.push_back(p_expression);
5745 16 : return traversalSuccessorContainer;
5746 : }
5747 : vector<string>
5748 16 : SgOmpDeviceClause::get_traversalSuccessorNamesContainer() {
5749 16 : vector<string> traversalSuccessorContainer;
5750 32 : traversalSuccessorContainer.push_back("p_expression");
5751 16 : return traversalSuccessorContainer;
5752 : }
5753 : size_t
5754 127 : SgOmpDeviceClause::get_numberOfTraversalSuccessors() {
5755 127 : return 1;
5756 : }
5757 : SgNode *
5758 127 : SgOmpDeviceClause::get_traversalSuccessorByIndex(size_t idx) {
5759 127 : switch (idx) {
5760 127 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
5761 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
5762 0 : ROSE_ASSERT(false);
5763 : return NULL;
5764 : }
5765 : }
5766 : size_t
5767 0 : SgOmpDeviceClause::get_childIndex(SgNode *child) {
5768 0 : if (child == p_expression) return 0;
5769 0 : else return (size_t) -1;
5770 : }
5771 : vector<SgNode*>
5772 6 : SgOmpHintClause::get_traversalSuccessorContainer() {
5773 6 : vector<SgNode*> traversalSuccessorContainer;
5774 6 : traversalSuccessorContainer.reserve(1);
5775 6 : traversalSuccessorContainer.push_back(p_expression);
5776 6 : return traversalSuccessorContainer;
5777 : }
5778 : vector<string>
5779 6 : SgOmpHintClause::get_traversalSuccessorNamesContainer() {
5780 6 : vector<string> traversalSuccessorContainer;
5781 12 : traversalSuccessorContainer.push_back("p_expression");
5782 6 : return traversalSuccessorContainer;
5783 : }
5784 : size_t
5785 48 : SgOmpHintClause::get_numberOfTraversalSuccessors() {
5786 48 : return 1;
5787 : }
5788 : SgNode *
5789 48 : SgOmpHintClause::get_traversalSuccessorByIndex(size_t idx) {
5790 48 : switch (idx) {
5791 48 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
5792 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
5793 0 : ROSE_ASSERT(false);
5794 : return NULL;
5795 : }
5796 : }
5797 : size_t
5798 0 : SgOmpHintClause::get_childIndex(SgNode *child) {
5799 0 : if (child == p_expression) return 0;
5800 0 : else return (size_t) -1;
5801 : }
5802 : vector<SgNode*>
5803 0 : SgOmpGrainsizeClause::get_traversalSuccessorContainer() {
5804 0 : vector<SgNode*> traversalSuccessorContainer;
5805 0 : traversalSuccessorContainer.reserve(1);
5806 0 : traversalSuccessorContainer.push_back(p_expression);
5807 0 : return traversalSuccessorContainer;
5808 : }
5809 : vector<string>
5810 0 : SgOmpGrainsizeClause::get_traversalSuccessorNamesContainer() {
5811 0 : vector<string> traversalSuccessorContainer;
5812 0 : traversalSuccessorContainer.push_back("p_expression");
5813 0 : return traversalSuccessorContainer;
5814 : }
5815 : size_t
5816 0 : SgOmpGrainsizeClause::get_numberOfTraversalSuccessors() {
5817 0 : return 1;
5818 : }
5819 : SgNode *
5820 0 : SgOmpGrainsizeClause::get_traversalSuccessorByIndex(size_t idx) {
5821 0 : switch (idx) {
5822 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
5823 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
5824 0 : ROSE_ASSERT(false);
5825 : return NULL;
5826 : }
5827 : }
5828 : size_t
5829 0 : SgOmpGrainsizeClause::get_childIndex(SgNode *child) {
5830 0 : if (child == p_expression) return 0;
5831 0 : else return (size_t) -1;
5832 : }
5833 : vector<SgNode*>
5834 0 : SgOmpNumTasksClause::get_traversalSuccessorContainer() {
5835 0 : vector<SgNode*> traversalSuccessorContainer;
5836 0 : traversalSuccessorContainer.reserve(1);
5837 0 : traversalSuccessorContainer.push_back(p_expression);
5838 0 : return traversalSuccessorContainer;
5839 : }
5840 : vector<string>
5841 0 : SgOmpNumTasksClause::get_traversalSuccessorNamesContainer() {
5842 0 : vector<string> traversalSuccessorContainer;
5843 0 : traversalSuccessorContainer.push_back("p_expression");
5844 0 : return traversalSuccessorContainer;
5845 : }
5846 : size_t
5847 0 : SgOmpNumTasksClause::get_numberOfTraversalSuccessors() {
5848 0 : return 1;
5849 : }
5850 : SgNode *
5851 0 : SgOmpNumTasksClause::get_traversalSuccessorByIndex(size_t idx) {
5852 0 : switch (idx) {
5853 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
5854 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
5855 0 : ROSE_ASSERT(false);
5856 : return NULL;
5857 : }
5858 : }
5859 : size_t
5860 0 : SgOmpNumTasksClause::get_childIndex(SgNode *child) {
5861 0 : if (child == p_expression) return 0;
5862 0 : else return (size_t) -1;
5863 : }
5864 : vector<SgNode*>
5865 0 : SgOmpDetachClause::get_traversalSuccessorContainer() {
5866 0 : vector<SgNode*> traversalSuccessorContainer;
5867 0 : traversalSuccessorContainer.reserve(1);
5868 0 : traversalSuccessorContainer.push_back(p_expression);
5869 0 : return traversalSuccessorContainer;
5870 : }
5871 : vector<string>
5872 0 : SgOmpDetachClause::get_traversalSuccessorNamesContainer() {
5873 0 : vector<string> traversalSuccessorContainer;
5874 0 : traversalSuccessorContainer.push_back("p_expression");
5875 0 : return traversalSuccessorContainer;
5876 : }
5877 : size_t
5878 0 : SgOmpDetachClause::get_numberOfTraversalSuccessors() {
5879 0 : return 1;
5880 : }
5881 : SgNode *
5882 0 : SgOmpDetachClause::get_traversalSuccessorByIndex(size_t idx) {
5883 0 : switch (idx) {
5884 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
5885 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
5886 0 : ROSE_ASSERT(false);
5887 : return NULL;
5888 : }
5889 : }
5890 : size_t
5891 0 : SgOmpDetachClause::get_childIndex(SgNode *child) {
5892 0 : if (child == p_expression) return 0;
5893 0 : else return (size_t) -1;
5894 : }
5895 : vector<SgNode*>
5896 0 : SgOmpSafelenClause::get_traversalSuccessorContainer() {
5897 0 : vector<SgNode*> traversalSuccessorContainer;
5898 0 : traversalSuccessorContainer.reserve(1);
5899 0 : traversalSuccessorContainer.push_back(p_expression);
5900 0 : return traversalSuccessorContainer;
5901 : }
5902 : vector<string>
5903 0 : SgOmpSafelenClause::get_traversalSuccessorNamesContainer() {
5904 0 : vector<string> traversalSuccessorContainer;
5905 0 : traversalSuccessorContainer.push_back("p_expression");
5906 0 : return traversalSuccessorContainer;
5907 : }
5908 : size_t
5909 0 : SgOmpSafelenClause::get_numberOfTraversalSuccessors() {
5910 0 : return 1;
5911 : }
5912 : SgNode *
5913 0 : SgOmpSafelenClause::get_traversalSuccessorByIndex(size_t idx) {
5914 0 : switch (idx) {
5915 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
5916 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
5917 0 : ROSE_ASSERT(false);
5918 : return NULL;
5919 : }
5920 : }
5921 : size_t
5922 0 : SgOmpSafelenClause::get_childIndex(SgNode *child) {
5923 0 : if (child == p_expression) return 0;
5924 0 : else return (size_t) -1;
5925 : }
5926 : vector<SgNode*>
5927 0 : SgOmpSimdlenClause::get_traversalSuccessorContainer() {
5928 0 : vector<SgNode*> traversalSuccessorContainer;
5929 0 : traversalSuccessorContainer.reserve(1);
5930 0 : traversalSuccessorContainer.push_back(p_expression);
5931 0 : return traversalSuccessorContainer;
5932 : }
5933 : vector<string>
5934 0 : SgOmpSimdlenClause::get_traversalSuccessorNamesContainer() {
5935 0 : vector<string> traversalSuccessorContainer;
5936 0 : traversalSuccessorContainer.push_back("p_expression");
5937 0 : return traversalSuccessorContainer;
5938 : }
5939 : size_t
5940 0 : SgOmpSimdlenClause::get_numberOfTraversalSuccessors() {
5941 0 : return 1;
5942 : }
5943 : SgNode *
5944 0 : SgOmpSimdlenClause::get_traversalSuccessorByIndex(size_t idx) {
5945 0 : switch (idx) {
5946 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
5947 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
5948 0 : ROSE_ASSERT(false);
5949 : return NULL;
5950 : }
5951 : }
5952 : size_t
5953 0 : SgOmpSimdlenClause::get_childIndex(SgNode *child) {
5954 0 : if (child == p_expression) return 0;
5955 0 : else return (size_t) -1;
5956 : }
5957 : vector<SgNode*>
5958 6 : SgOmpFinalClause::get_traversalSuccessorContainer() {
5959 6 : vector<SgNode*> traversalSuccessorContainer;
5960 6 : traversalSuccessorContainer.reserve(1);
5961 6 : traversalSuccessorContainer.push_back(p_expression);
5962 6 : return traversalSuccessorContainer;
5963 : }
5964 : vector<string>
5965 6 : SgOmpFinalClause::get_traversalSuccessorNamesContainer() {
5966 6 : vector<string> traversalSuccessorContainer;
5967 12 : traversalSuccessorContainer.push_back("p_expression");
5968 6 : return traversalSuccessorContainer;
5969 : }
5970 : size_t
5971 47 : SgOmpFinalClause::get_numberOfTraversalSuccessors() {
5972 47 : return 1;
5973 : }
5974 : SgNode *
5975 47 : SgOmpFinalClause::get_traversalSuccessorByIndex(size_t idx) {
5976 47 : switch (idx) {
5977 47 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
5978 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
5979 0 : ROSE_ASSERT(false);
5980 : return NULL;
5981 : }
5982 : }
5983 : size_t
5984 0 : SgOmpFinalClause::get_childIndex(SgNode *child) {
5985 0 : if (child == p_expression) return 0;
5986 0 : else return (size_t) -1;
5987 : }
5988 : vector<SgNode*>
5989 2 : SgOmpPriorityClause::get_traversalSuccessorContainer() {
5990 2 : vector<SgNode*> traversalSuccessorContainer;
5991 2 : traversalSuccessorContainer.reserve(1);
5992 2 : traversalSuccessorContainer.push_back(p_expression);
5993 2 : return traversalSuccessorContainer;
5994 : }
5995 : vector<string>
5996 2 : SgOmpPriorityClause::get_traversalSuccessorNamesContainer() {
5997 2 : vector<string> traversalSuccessorContainer;
5998 4 : traversalSuccessorContainer.push_back("p_expression");
5999 2 : return traversalSuccessorContainer;
6000 : }
6001 : size_t
6002 16 : SgOmpPriorityClause::get_numberOfTraversalSuccessors() {
6003 16 : return 1;
6004 : }
6005 : SgNode *
6006 16 : SgOmpPriorityClause::get_traversalSuccessorByIndex(size_t idx) {
6007 16 : switch (idx) {
6008 16 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
6009 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6010 0 : ROSE_ASSERT(false);
6011 : return NULL;
6012 : }
6013 : }
6014 : size_t
6015 0 : SgOmpPriorityClause::get_childIndex(SgNode *child) {
6016 0 : if (child == p_expression) return 0;
6017 0 : else return (size_t) -1;
6018 : }
6019 : vector<SgNode*>
6020 0 : SgOmpPartialClause::get_traversalSuccessorContainer() {
6021 0 : vector<SgNode*> traversalSuccessorContainer;
6022 0 : traversalSuccessorContainer.reserve(1);
6023 0 : traversalSuccessorContainer.push_back(p_expression);
6024 0 : return traversalSuccessorContainer;
6025 : }
6026 : vector<string>
6027 0 : SgOmpPartialClause::get_traversalSuccessorNamesContainer() {
6028 0 : vector<string> traversalSuccessorContainer;
6029 0 : traversalSuccessorContainer.push_back("p_expression");
6030 0 : return traversalSuccessorContainer;
6031 : }
6032 : size_t
6033 0 : SgOmpPartialClause::get_numberOfTraversalSuccessors() {
6034 0 : return 1;
6035 : }
6036 : SgNode *
6037 0 : SgOmpPartialClause::get_traversalSuccessorByIndex(size_t idx) {
6038 0 : switch (idx) {
6039 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
6040 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6041 0 : ROSE_ASSERT(false);
6042 : return NULL;
6043 : }
6044 : }
6045 : size_t
6046 0 : SgOmpPartialClause::get_childIndex(SgNode *child) {
6047 0 : if (child == p_expression) return 0;
6048 0 : else return (size_t) -1;
6049 : }
6050 : vector<SgNode*>
6051 0 : SgOmpSizesClause::get_traversalSuccessorContainer() {
6052 0 : vector<SgNode*> traversalSuccessorContainer;
6053 0 : traversalSuccessorContainer.reserve(1);
6054 0 : traversalSuccessorContainer.push_back(p_expression);
6055 0 : return traversalSuccessorContainer;
6056 : }
6057 : vector<string>
6058 0 : SgOmpSizesClause::get_traversalSuccessorNamesContainer() {
6059 0 : vector<string> traversalSuccessorContainer;
6060 0 : traversalSuccessorContainer.push_back("p_expression");
6061 0 : return traversalSuccessorContainer;
6062 : }
6063 : size_t
6064 0 : SgOmpSizesClause::get_numberOfTraversalSuccessors() {
6065 0 : return 1;
6066 : }
6067 : SgNode *
6068 0 : SgOmpSizesClause::get_traversalSuccessorByIndex(size_t idx) {
6069 0 : switch (idx) {
6070 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
6071 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6072 0 : ROSE_ASSERT(false);
6073 : return NULL;
6074 : }
6075 : }
6076 : size_t
6077 0 : SgOmpSizesClause::get_childIndex(SgNode *child) {
6078 0 : if (child == p_expression) return 0;
6079 0 : else return (size_t) -1;
6080 : }
6081 : vector<SgNode*>
6082 0 : SgOmpInbranchClause::get_traversalSuccessorContainer() {
6083 0 : vector<SgNode*> traversalSuccessorContainer;
6084 0 : return traversalSuccessorContainer;
6085 : }
6086 : vector<string>
6087 0 : SgOmpInbranchClause::get_traversalSuccessorNamesContainer() {
6088 0 : vector<string> traversalSuccessorContainer;
6089 0 : return traversalSuccessorContainer;
6090 : }
6091 : size_t
6092 0 : SgOmpInbranchClause::get_numberOfTraversalSuccessors() {
6093 0 : return 0;
6094 : }
6095 : SgNode *
6096 0 : SgOmpInbranchClause::get_traversalSuccessorByIndex(size_t idx) {
6097 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpInbranchClause" << " that has no successors!" << endl;
6098 0 : ROSE_ASSERT(false);
6099 : return NULL;
6100 : }
6101 : size_t
6102 0 : SgOmpInbranchClause::get_childIndex(SgNode *child) {
6103 0 : cout << "error: get_childIndex called on node of type " << "SgOmpInbranchClause" << " that has no successors!" << endl;
6104 0 : ROSE_ASSERT(false);
6105 : return 0;
6106 : }
6107 : vector<SgNode*>
6108 0 : SgOmpNotinbranchClause::get_traversalSuccessorContainer() {
6109 0 : vector<SgNode*> traversalSuccessorContainer;
6110 0 : return traversalSuccessorContainer;
6111 : }
6112 : vector<string>
6113 0 : SgOmpNotinbranchClause::get_traversalSuccessorNamesContainer() {
6114 0 : vector<string> traversalSuccessorContainer;
6115 0 : return traversalSuccessorContainer;
6116 : }
6117 : size_t
6118 0 : SgOmpNotinbranchClause::get_numberOfTraversalSuccessors() {
6119 0 : return 0;
6120 : }
6121 : SgNode *
6122 0 : SgOmpNotinbranchClause::get_traversalSuccessorByIndex(size_t idx) {
6123 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpNotinbranchClause" << " that has no successors!" << endl;
6124 0 : ROSE_ASSERT(false);
6125 : return NULL;
6126 : }
6127 : size_t
6128 0 : SgOmpNotinbranchClause::get_childIndex(SgNode *child) {
6129 0 : cout << "error: get_childIndex called on node of type " << "SgOmpNotinbranchClause" << " that has no successors!" << endl;
6130 0 : ROSE_ASSERT(false);
6131 : return 0;
6132 : }
6133 : vector<SgNode*>
6134 2 : SgOmpDefaultmapClause::get_traversalSuccessorContainer() {
6135 2 : vector<SgNode*> traversalSuccessorContainer;
6136 2 : return traversalSuccessorContainer;
6137 : }
6138 : vector<string>
6139 2 : SgOmpDefaultmapClause::get_traversalSuccessorNamesContainer() {
6140 2 : vector<string> traversalSuccessorContainer;
6141 2 : return traversalSuccessorContainer;
6142 : }
6143 : size_t
6144 16 : SgOmpDefaultmapClause::get_numberOfTraversalSuccessors() {
6145 16 : return 0;
6146 : }
6147 : SgNode *
6148 0 : SgOmpDefaultmapClause::get_traversalSuccessorByIndex(size_t idx) {
6149 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpDefaultmapClause" << " that has no successors!" << endl;
6150 0 : ROSE_ASSERT(false);
6151 : return NULL;
6152 : }
6153 : size_t
6154 0 : SgOmpDefaultmapClause::get_childIndex(SgNode *child) {
6155 0 : cout << "error: get_childIndex called on node of type " << "SgOmpDefaultmapClause" << " that has no successors!" << endl;
6156 0 : ROSE_ASSERT(false);
6157 : return 0;
6158 : }
6159 : vector<SgNode*>
6160 2 : SgOmpAtomicDefaultMemOrderClause::get_traversalSuccessorContainer() {
6161 2 : vector<SgNode*> traversalSuccessorContainer;
6162 2 : return traversalSuccessorContainer;
6163 : }
6164 : vector<string>
6165 2 : SgOmpAtomicDefaultMemOrderClause::get_traversalSuccessorNamesContainer() {
6166 2 : vector<string> traversalSuccessorContainer;
6167 2 : return traversalSuccessorContainer;
6168 : }
6169 : size_t
6170 15 : SgOmpAtomicDefaultMemOrderClause::get_numberOfTraversalSuccessors() {
6171 15 : return 0;
6172 : }
6173 : SgNode *
6174 0 : SgOmpAtomicDefaultMemOrderClause::get_traversalSuccessorByIndex(size_t idx) {
6175 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpAtomicDefaultMemOrderClause" << " that has no successors!" << endl;
6176 0 : ROSE_ASSERT(false);
6177 : return NULL;
6178 : }
6179 : size_t
6180 0 : SgOmpAtomicDefaultMemOrderClause::get_childIndex(SgNode *child) {
6181 0 : cout << "error: get_childIndex called on node of type " << "SgOmpAtomicDefaultMemOrderClause" << " that has no successors!" << endl;
6182 0 : ROSE_ASSERT(false);
6183 : return 0;
6184 : }
6185 : vector<SgNode*>
6186 4 : SgOmpExtImplementationDefinedRequirementClause::get_traversalSuccessorContainer() {
6187 4 : vector<SgNode*> traversalSuccessorContainer;
6188 4 : traversalSuccessorContainer.reserve(1);
6189 4 : traversalSuccessorContainer.push_back(p_implementation_defined_requirement);
6190 4 : return traversalSuccessorContainer;
6191 : }
6192 : vector<string>
6193 4 : SgOmpExtImplementationDefinedRequirementClause::get_traversalSuccessorNamesContainer() {
6194 4 : vector<string> traversalSuccessorContainer;
6195 8 : traversalSuccessorContainer.push_back("p_implementation_defined_requirement");
6196 4 : return traversalSuccessorContainer;
6197 : }
6198 : size_t
6199 30 : SgOmpExtImplementationDefinedRequirementClause::get_numberOfTraversalSuccessors() {
6200 30 : return 1;
6201 : }
6202 : SgNode *
6203 30 : SgOmpExtImplementationDefinedRequirementClause::get_traversalSuccessorByIndex(size_t idx) {
6204 30 : switch (idx) {
6205 30 : case 0: ROSE_ASSERT(p_implementation_defined_requirement == NULL || p_implementation_defined_requirement != NULL); return p_implementation_defined_requirement;
6206 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6207 0 : ROSE_ASSERT(false);
6208 : return NULL;
6209 : }
6210 : }
6211 : size_t
6212 0 : SgOmpExtImplementationDefinedRequirementClause::get_childIndex(SgNode *child) {
6213 0 : if (child == p_implementation_defined_requirement) return 0;
6214 0 : else return (size_t) -1;
6215 : }
6216 : vector<SgNode*>
6217 0 : SgOmpUsesAllocatorsDefination::get_traversalSuccessorContainer() {
6218 0 : vector<SgNode*> traversalSuccessorContainer;
6219 0 : return traversalSuccessorContainer;
6220 : }
6221 : vector<string>
6222 0 : SgOmpUsesAllocatorsDefination::get_traversalSuccessorNamesContainer() {
6223 0 : vector<string> traversalSuccessorContainer;
6224 0 : return traversalSuccessorContainer;
6225 : }
6226 : size_t
6227 0 : SgOmpUsesAllocatorsDefination::get_numberOfTraversalSuccessors() {
6228 0 : return 0;
6229 : }
6230 : SgNode *
6231 0 : SgOmpUsesAllocatorsDefination::get_traversalSuccessorByIndex(size_t idx) {
6232 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpUsesAllocatorsDefination" << " that has no successors!" << endl;
6233 0 : ROSE_ASSERT(false);
6234 : return NULL;
6235 : }
6236 : size_t
6237 0 : SgOmpUsesAllocatorsDefination::get_childIndex(SgNode *child) {
6238 0 : cout << "error: get_childIndex called on node of type " << "SgOmpUsesAllocatorsDefination" << " that has no successors!" << endl;
6239 0 : ROSE_ASSERT(false);
6240 : return 0;
6241 : }
6242 : vector<SgNode*>
6243 0 : SgOmpVariablesClause::get_traversalSuccessorContainer() {
6244 0 : vector<SgNode*> traversalSuccessorContainer;
6245 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
6246 0 : << "static: SgOmpVariablesClause" << endl << "dynamic: " << this->sage_class_name() << endl;
6247 0 : cerr << "Aborting ..." << endl;
6248 0 : ROSE_ASSERT(false);
6249 : return traversalSuccessorContainer;
6250 : }
6251 :
6252 : vector<string>
6253 0 : SgOmpVariablesClause::get_traversalSuccessorNamesContainer() {
6254 0 : vector<string> traversalSuccessorContainer;
6255 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
6256 0 : << "static: SgOmpVariablesClause" << endl << "dynamic: " << this->sage_class_name() << endl;
6257 0 : cerr << "Aborting ..." << endl;
6258 0 : ROSE_ASSERT(false);
6259 : return traversalSuccessorContainer;
6260 : }
6261 :
6262 : size_t
6263 0 : SgOmpVariablesClause::get_numberOfTraversalSuccessors() {
6264 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
6265 0 : << "static: SgOmpVariablesClause" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
6266 0 : cerr << "Aborting ..." << endl;
6267 0 : ROSE_ASSERT(false);
6268 : return 42;
6269 : }
6270 :
6271 : SgNode*
6272 0 : SgOmpVariablesClause::get_traversalSuccessorByIndex(size_t) {
6273 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
6274 0 : << "static: SgOmpVariablesClause" << endl << "dynamic: " << this->sage_class_name() << endl;
6275 0 : cerr << "Aborting ..." << endl;
6276 0 : ROSE_ASSERT(false);
6277 : return NULL;
6278 : }
6279 :
6280 : size_t
6281 0 : SgOmpVariablesClause::get_childIndex(SgNode *) {
6282 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
6283 0 : << "static: SgOmpVariablesClause" << endl << "dynamic: " << this->sage_class_name() << endl;
6284 0 : cerr << "Aborting ..." << endl;
6285 0 : ROSE_ASSERT(false);
6286 : return 42;
6287 : }
6288 :
6289 : vector<SgNode*>
6290 12 : SgOmpCopyprivateClause::get_traversalSuccessorContainer() {
6291 12 : vector<SgNode*> traversalSuccessorContainer;
6292 12 : traversalSuccessorContainer.reserve(1);
6293 12 : traversalSuccessorContainer.push_back(p_variables);
6294 12 : return traversalSuccessorContainer;
6295 : }
6296 : vector<string>
6297 12 : SgOmpCopyprivateClause::get_traversalSuccessorNamesContainer() {
6298 12 : vector<string> traversalSuccessorContainer;
6299 24 : traversalSuccessorContainer.push_back("p_variables");
6300 12 : return traversalSuccessorContainer;
6301 : }
6302 : size_t
6303 93 : SgOmpCopyprivateClause::get_numberOfTraversalSuccessors() {
6304 93 : return 1;
6305 : }
6306 : SgNode *
6307 93 : SgOmpCopyprivateClause::get_traversalSuccessorByIndex(size_t idx) {
6308 93 : switch (idx) {
6309 93 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6310 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6311 0 : ROSE_ASSERT(false);
6312 : return NULL;
6313 : }
6314 : }
6315 : size_t
6316 0 : SgOmpCopyprivateClause::get_childIndex(SgNode *child) {
6317 0 : if (child == p_variables) return 0;
6318 0 : else return (size_t) -1;
6319 : }
6320 : vector<SgNode*>
6321 111 : SgOmpPrivateClause::get_traversalSuccessorContainer() {
6322 111 : vector<SgNode*> traversalSuccessorContainer;
6323 111 : traversalSuccessorContainer.reserve(1);
6324 111 : traversalSuccessorContainer.push_back(p_variables);
6325 111 : return traversalSuccessorContainer;
6326 : }
6327 : vector<string>
6328 110 : SgOmpPrivateClause::get_traversalSuccessorNamesContainer() {
6329 110 : vector<string> traversalSuccessorContainer;
6330 220 : traversalSuccessorContainer.push_back("p_variables");
6331 110 : return traversalSuccessorContainer;
6332 : }
6333 : size_t
6334 872 : SgOmpPrivateClause::get_numberOfTraversalSuccessors() {
6335 872 : return 1;
6336 : }
6337 : SgNode *
6338 872 : SgOmpPrivateClause::get_traversalSuccessorByIndex(size_t idx) {
6339 872 : switch (idx) {
6340 872 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6341 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6342 0 : ROSE_ASSERT(false);
6343 : return NULL;
6344 : }
6345 : }
6346 : size_t
6347 0 : SgOmpPrivateClause::get_childIndex(SgNode *child) {
6348 0 : if (child == p_variables) return 0;
6349 0 : else return (size_t) -1;
6350 : }
6351 : vector<SgNode*>
6352 56 : SgOmpFirstprivateClause::get_traversalSuccessorContainer() {
6353 56 : vector<SgNode*> traversalSuccessorContainer;
6354 56 : traversalSuccessorContainer.reserve(1);
6355 56 : traversalSuccessorContainer.push_back(p_variables);
6356 56 : return traversalSuccessorContainer;
6357 : }
6358 : vector<string>
6359 56 : SgOmpFirstprivateClause::get_traversalSuccessorNamesContainer() {
6360 56 : vector<string> traversalSuccessorContainer;
6361 112 : traversalSuccessorContainer.push_back("p_variables");
6362 56 : return traversalSuccessorContainer;
6363 : }
6364 : size_t
6365 451 : SgOmpFirstprivateClause::get_numberOfTraversalSuccessors() {
6366 451 : return 1;
6367 : }
6368 : SgNode *
6369 451 : SgOmpFirstprivateClause::get_traversalSuccessorByIndex(size_t idx) {
6370 451 : switch (idx) {
6371 451 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6372 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6373 0 : ROSE_ASSERT(false);
6374 : return NULL;
6375 : }
6376 : }
6377 : size_t
6378 0 : SgOmpFirstprivateClause::get_childIndex(SgNode *child) {
6379 0 : if (child == p_variables) return 0;
6380 0 : else return (size_t) -1;
6381 : }
6382 : vector<SgNode*>
6383 0 : SgOmpNontemporalClause::get_traversalSuccessorContainer() {
6384 0 : vector<SgNode*> traversalSuccessorContainer;
6385 0 : traversalSuccessorContainer.reserve(1);
6386 0 : traversalSuccessorContainer.push_back(p_variables);
6387 0 : return traversalSuccessorContainer;
6388 : }
6389 : vector<string>
6390 0 : SgOmpNontemporalClause::get_traversalSuccessorNamesContainer() {
6391 0 : vector<string> traversalSuccessorContainer;
6392 0 : traversalSuccessorContainer.push_back("p_variables");
6393 0 : return traversalSuccessorContainer;
6394 : }
6395 : size_t
6396 0 : SgOmpNontemporalClause::get_numberOfTraversalSuccessors() {
6397 0 : return 1;
6398 : }
6399 : SgNode *
6400 0 : SgOmpNontemporalClause::get_traversalSuccessorByIndex(size_t idx) {
6401 0 : switch (idx) {
6402 0 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6403 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6404 0 : ROSE_ASSERT(false);
6405 : return NULL;
6406 : }
6407 : }
6408 : size_t
6409 0 : SgOmpNontemporalClause::get_childIndex(SgNode *child) {
6410 0 : if (child == p_variables) return 0;
6411 0 : else return (size_t) -1;
6412 : }
6413 : vector<SgNode*>
6414 0 : SgOmpInclusiveClause::get_traversalSuccessorContainer() {
6415 0 : vector<SgNode*> traversalSuccessorContainer;
6416 0 : traversalSuccessorContainer.reserve(1);
6417 0 : traversalSuccessorContainer.push_back(p_variables);
6418 0 : return traversalSuccessorContainer;
6419 : }
6420 : vector<string>
6421 0 : SgOmpInclusiveClause::get_traversalSuccessorNamesContainer() {
6422 0 : vector<string> traversalSuccessorContainer;
6423 0 : traversalSuccessorContainer.push_back("p_variables");
6424 0 : return traversalSuccessorContainer;
6425 : }
6426 : size_t
6427 0 : SgOmpInclusiveClause::get_numberOfTraversalSuccessors() {
6428 0 : return 1;
6429 : }
6430 : SgNode *
6431 0 : SgOmpInclusiveClause::get_traversalSuccessorByIndex(size_t idx) {
6432 0 : switch (idx) {
6433 0 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6434 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6435 0 : ROSE_ASSERT(false);
6436 : return NULL;
6437 : }
6438 : }
6439 : size_t
6440 0 : SgOmpInclusiveClause::get_childIndex(SgNode *child) {
6441 0 : if (child == p_variables) return 0;
6442 0 : else return (size_t) -1;
6443 : }
6444 : vector<SgNode*>
6445 0 : SgOmpExclusiveClause::get_traversalSuccessorContainer() {
6446 0 : vector<SgNode*> traversalSuccessorContainer;
6447 0 : traversalSuccessorContainer.reserve(1);
6448 0 : traversalSuccessorContainer.push_back(p_variables);
6449 0 : return traversalSuccessorContainer;
6450 : }
6451 : vector<string>
6452 0 : SgOmpExclusiveClause::get_traversalSuccessorNamesContainer() {
6453 0 : vector<string> traversalSuccessorContainer;
6454 0 : traversalSuccessorContainer.push_back("p_variables");
6455 0 : return traversalSuccessorContainer;
6456 : }
6457 : size_t
6458 0 : SgOmpExclusiveClause::get_numberOfTraversalSuccessors() {
6459 0 : return 1;
6460 : }
6461 : SgNode *
6462 0 : SgOmpExclusiveClause::get_traversalSuccessorByIndex(size_t idx) {
6463 0 : switch (idx) {
6464 0 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6465 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6466 0 : ROSE_ASSERT(false);
6467 : return NULL;
6468 : }
6469 : }
6470 : size_t
6471 0 : SgOmpExclusiveClause::get_childIndex(SgNode *child) {
6472 0 : if (child == p_variables) return 0;
6473 0 : else return (size_t) -1;
6474 : }
6475 : vector<SgNode*>
6476 0 : SgOmpIsDevicePtrClause::get_traversalSuccessorContainer() {
6477 0 : vector<SgNode*> traversalSuccessorContainer;
6478 0 : traversalSuccessorContainer.reserve(1);
6479 0 : traversalSuccessorContainer.push_back(p_variables);
6480 0 : return traversalSuccessorContainer;
6481 : }
6482 : vector<string>
6483 0 : SgOmpIsDevicePtrClause::get_traversalSuccessorNamesContainer() {
6484 0 : vector<string> traversalSuccessorContainer;
6485 0 : traversalSuccessorContainer.push_back("p_variables");
6486 0 : return traversalSuccessorContainer;
6487 : }
6488 : size_t
6489 0 : SgOmpIsDevicePtrClause::get_numberOfTraversalSuccessors() {
6490 0 : return 1;
6491 : }
6492 : SgNode *
6493 0 : SgOmpIsDevicePtrClause::get_traversalSuccessorByIndex(size_t idx) {
6494 0 : switch (idx) {
6495 0 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6496 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6497 0 : ROSE_ASSERT(false);
6498 : return NULL;
6499 : }
6500 : }
6501 : size_t
6502 0 : SgOmpIsDevicePtrClause::get_childIndex(SgNode *child) {
6503 0 : if (child == p_variables) return 0;
6504 0 : else return (size_t) -1;
6505 : }
6506 : vector<SgNode*>
6507 0 : SgOmpUseDevicePtrClause::get_traversalSuccessorContainer() {
6508 0 : vector<SgNode*> traversalSuccessorContainer;
6509 0 : traversalSuccessorContainer.reserve(1);
6510 0 : traversalSuccessorContainer.push_back(p_variables);
6511 0 : return traversalSuccessorContainer;
6512 : }
6513 : vector<string>
6514 0 : SgOmpUseDevicePtrClause::get_traversalSuccessorNamesContainer() {
6515 0 : vector<string> traversalSuccessorContainer;
6516 0 : traversalSuccessorContainer.push_back("p_variables");
6517 0 : return traversalSuccessorContainer;
6518 : }
6519 : size_t
6520 0 : SgOmpUseDevicePtrClause::get_numberOfTraversalSuccessors() {
6521 0 : return 1;
6522 : }
6523 : SgNode *
6524 0 : SgOmpUseDevicePtrClause::get_traversalSuccessorByIndex(size_t idx) {
6525 0 : switch (idx) {
6526 0 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6527 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6528 0 : ROSE_ASSERT(false);
6529 : return NULL;
6530 : }
6531 : }
6532 : size_t
6533 0 : SgOmpUseDevicePtrClause::get_childIndex(SgNode *child) {
6534 0 : if (child == p_variables) return 0;
6535 0 : else return (size_t) -1;
6536 : }
6537 : vector<SgNode*>
6538 0 : SgOmpUseDeviceAddrClause::get_traversalSuccessorContainer() {
6539 0 : vector<SgNode*> traversalSuccessorContainer;
6540 0 : traversalSuccessorContainer.reserve(1);
6541 0 : traversalSuccessorContainer.push_back(p_variables);
6542 0 : return traversalSuccessorContainer;
6543 : }
6544 : vector<string>
6545 0 : SgOmpUseDeviceAddrClause::get_traversalSuccessorNamesContainer() {
6546 0 : vector<string> traversalSuccessorContainer;
6547 0 : traversalSuccessorContainer.push_back("p_variables");
6548 0 : return traversalSuccessorContainer;
6549 : }
6550 : size_t
6551 0 : SgOmpUseDeviceAddrClause::get_numberOfTraversalSuccessors() {
6552 0 : return 1;
6553 : }
6554 : SgNode *
6555 0 : SgOmpUseDeviceAddrClause::get_traversalSuccessorByIndex(size_t idx) {
6556 0 : switch (idx) {
6557 0 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6558 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6559 0 : ROSE_ASSERT(false);
6560 : return NULL;
6561 : }
6562 : }
6563 : size_t
6564 0 : SgOmpUseDeviceAddrClause::get_childIndex(SgNode *child) {
6565 0 : if (child == p_variables) return 0;
6566 0 : else return (size_t) -1;
6567 : }
6568 : vector<SgNode*>
6569 100 : SgOmpSharedClause::get_traversalSuccessorContainer() {
6570 100 : vector<SgNode*> traversalSuccessorContainer;
6571 100 : traversalSuccessorContainer.reserve(1);
6572 100 : traversalSuccessorContainer.push_back(p_variables);
6573 100 : return traversalSuccessorContainer;
6574 : }
6575 : vector<string>
6576 100 : SgOmpSharedClause::get_traversalSuccessorNamesContainer() {
6577 100 : vector<string> traversalSuccessorContainer;
6578 200 : traversalSuccessorContainer.push_back("p_variables");
6579 100 : return traversalSuccessorContainer;
6580 : }
6581 : size_t
6582 780 : SgOmpSharedClause::get_numberOfTraversalSuccessors() {
6583 780 : return 1;
6584 : }
6585 : SgNode *
6586 780 : SgOmpSharedClause::get_traversalSuccessorByIndex(size_t idx) {
6587 780 : switch (idx) {
6588 780 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6589 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6590 0 : ROSE_ASSERT(false);
6591 : return NULL;
6592 : }
6593 : }
6594 : size_t
6595 0 : SgOmpSharedClause::get_childIndex(SgNode *child) {
6596 0 : if (child == p_variables) return 0;
6597 0 : else return (size_t) -1;
6598 : }
6599 : vector<SgNode*>
6600 2 : SgOmpCopyinClause::get_traversalSuccessorContainer() {
6601 2 : vector<SgNode*> traversalSuccessorContainer;
6602 2 : traversalSuccessorContainer.reserve(1);
6603 2 : traversalSuccessorContainer.push_back(p_variables);
6604 2 : return traversalSuccessorContainer;
6605 : }
6606 : vector<string>
6607 2 : SgOmpCopyinClause::get_traversalSuccessorNamesContainer() {
6608 2 : vector<string> traversalSuccessorContainer;
6609 4 : traversalSuccessorContainer.push_back("p_variables");
6610 2 : return traversalSuccessorContainer;
6611 : }
6612 : size_t
6613 15 : SgOmpCopyinClause::get_numberOfTraversalSuccessors() {
6614 15 : return 1;
6615 : }
6616 : SgNode *
6617 15 : SgOmpCopyinClause::get_traversalSuccessorByIndex(size_t idx) {
6618 15 : switch (idx) {
6619 15 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6620 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6621 0 : ROSE_ASSERT(false);
6622 : return NULL;
6623 : }
6624 : }
6625 : size_t
6626 0 : SgOmpCopyinClause::get_childIndex(SgNode *child) {
6627 0 : if (child == p_variables) return 0;
6628 0 : else return (size_t) -1;
6629 : }
6630 : vector<SgNode*>
6631 8 : SgOmpLastprivateClause::get_traversalSuccessorContainer() {
6632 8 : vector<SgNode*> traversalSuccessorContainer;
6633 8 : traversalSuccessorContainer.reserve(1);
6634 8 : traversalSuccessorContainer.push_back(p_variables);
6635 8 : return traversalSuccessorContainer;
6636 : }
6637 : vector<string>
6638 8 : SgOmpLastprivateClause::get_traversalSuccessorNamesContainer() {
6639 8 : vector<string> traversalSuccessorContainer;
6640 16 : traversalSuccessorContainer.push_back("p_variables");
6641 8 : return traversalSuccessorContainer;
6642 : }
6643 : size_t
6644 64 : SgOmpLastprivateClause::get_numberOfTraversalSuccessors() {
6645 64 : return 1;
6646 : }
6647 : SgNode *
6648 64 : SgOmpLastprivateClause::get_traversalSuccessorByIndex(size_t idx) {
6649 64 : switch (idx) {
6650 64 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6651 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6652 0 : ROSE_ASSERT(false);
6653 : return NULL;
6654 : }
6655 : }
6656 : size_t
6657 0 : SgOmpLastprivateClause::get_childIndex(SgNode *child) {
6658 0 : if (child == p_variables) return 0;
6659 0 : else return (size_t) -1;
6660 : }
6661 : vector<SgNode*>
6662 60 : SgOmpReductionClause::get_traversalSuccessorContainer() {
6663 60 : vector<SgNode*> traversalSuccessorContainer;
6664 60 : traversalSuccessorContainer.reserve(1);
6665 60 : traversalSuccessorContainer.push_back(p_variables);
6666 60 : return traversalSuccessorContainer;
6667 : }
6668 : vector<string>
6669 60 : SgOmpReductionClause::get_traversalSuccessorNamesContainer() {
6670 60 : vector<string> traversalSuccessorContainer;
6671 120 : traversalSuccessorContainer.push_back("p_variables");
6672 60 : return traversalSuccessorContainer;
6673 : }
6674 : size_t
6675 475 : SgOmpReductionClause::get_numberOfTraversalSuccessors() {
6676 475 : return 1;
6677 : }
6678 : SgNode *
6679 475 : SgOmpReductionClause::get_traversalSuccessorByIndex(size_t idx) {
6680 475 : switch (idx) {
6681 475 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6682 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6683 0 : ROSE_ASSERT(false);
6684 : return NULL;
6685 : }
6686 : }
6687 : size_t
6688 0 : SgOmpReductionClause::get_childIndex(SgNode *child) {
6689 0 : if (child == p_variables) return 0;
6690 0 : else return (size_t) -1;
6691 : }
6692 : vector<SgNode*>
6693 12 : SgOmpInReductionClause::get_traversalSuccessorContainer() {
6694 12 : vector<SgNode*> traversalSuccessorContainer;
6695 12 : traversalSuccessorContainer.reserve(1);
6696 12 : traversalSuccessorContainer.push_back(p_variables);
6697 12 : return traversalSuccessorContainer;
6698 : }
6699 : vector<string>
6700 12 : SgOmpInReductionClause::get_traversalSuccessorNamesContainer() {
6701 12 : vector<string> traversalSuccessorContainer;
6702 24 : traversalSuccessorContainer.push_back("p_variables");
6703 12 : return traversalSuccessorContainer;
6704 : }
6705 : size_t
6706 96 : SgOmpInReductionClause::get_numberOfTraversalSuccessors() {
6707 96 : return 1;
6708 : }
6709 : SgNode *
6710 96 : SgOmpInReductionClause::get_traversalSuccessorByIndex(size_t idx) {
6711 96 : switch (idx) {
6712 96 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6713 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6714 0 : ROSE_ASSERT(false);
6715 : return NULL;
6716 : }
6717 : }
6718 : size_t
6719 0 : SgOmpInReductionClause::get_childIndex(SgNode *child) {
6720 0 : if (child == p_variables) return 0;
6721 0 : else return (size_t) -1;
6722 : }
6723 : vector<SgNode*>
6724 0 : SgOmpTaskReductionClause::get_traversalSuccessorContainer() {
6725 0 : vector<SgNode*> traversalSuccessorContainer;
6726 0 : traversalSuccessorContainer.reserve(1);
6727 0 : traversalSuccessorContainer.push_back(p_variables);
6728 0 : return traversalSuccessorContainer;
6729 : }
6730 : vector<string>
6731 0 : SgOmpTaskReductionClause::get_traversalSuccessorNamesContainer() {
6732 0 : vector<string> traversalSuccessorContainer;
6733 0 : traversalSuccessorContainer.push_back("p_variables");
6734 0 : return traversalSuccessorContainer;
6735 : }
6736 : size_t
6737 0 : SgOmpTaskReductionClause::get_numberOfTraversalSuccessors() {
6738 0 : return 1;
6739 : }
6740 : SgNode *
6741 0 : SgOmpTaskReductionClause::get_traversalSuccessorByIndex(size_t idx) {
6742 0 : switch (idx) {
6743 0 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6744 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6745 0 : ROSE_ASSERT(false);
6746 : return NULL;
6747 : }
6748 : }
6749 : size_t
6750 0 : SgOmpTaskReductionClause::get_childIndex(SgNode *child) {
6751 0 : if (child == p_variables) return 0;
6752 0 : else return (size_t) -1;
6753 : }
6754 : vector<SgNode*>
6755 86 : SgOmpMapClause::get_traversalSuccessorContainer() {
6756 86 : vector<SgNode*> traversalSuccessorContainer;
6757 86 : traversalSuccessorContainer.reserve(1);
6758 86 : traversalSuccessorContainer.push_back(p_variables);
6759 86 : return traversalSuccessorContainer;
6760 : }
6761 : vector<string>
6762 86 : SgOmpMapClause::get_traversalSuccessorNamesContainer() {
6763 86 : vector<string> traversalSuccessorContainer;
6764 172 : traversalSuccessorContainer.push_back("p_variables");
6765 86 : return traversalSuccessorContainer;
6766 : }
6767 : size_t
6768 674 : SgOmpMapClause::get_numberOfTraversalSuccessors() {
6769 674 : return 1;
6770 : }
6771 : SgNode *
6772 674 : SgOmpMapClause::get_traversalSuccessorByIndex(size_t idx) {
6773 674 : switch (idx) {
6774 674 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6775 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6776 0 : ROSE_ASSERT(false);
6777 : return NULL;
6778 : }
6779 : }
6780 : size_t
6781 0 : SgOmpMapClause::get_childIndex(SgNode *child) {
6782 0 : if (child == p_variables) return 0;
6783 0 : else return (size_t) -1;
6784 : }
6785 : vector<SgNode*>
6786 68 : SgOmpAllocateClause::get_traversalSuccessorContainer() {
6787 68 : vector<SgNode*> traversalSuccessorContainer;
6788 68 : traversalSuccessorContainer.reserve(1);
6789 68 : traversalSuccessorContainer.push_back(p_variables);
6790 68 : return traversalSuccessorContainer;
6791 : }
6792 : vector<string>
6793 68 : SgOmpAllocateClause::get_traversalSuccessorNamesContainer() {
6794 68 : vector<string> traversalSuccessorContainer;
6795 136 : traversalSuccessorContainer.push_back("p_variables");
6796 68 : return traversalSuccessorContainer;
6797 : }
6798 : size_t
6799 500 : SgOmpAllocateClause::get_numberOfTraversalSuccessors() {
6800 500 : return 1;
6801 : }
6802 : SgNode *
6803 500 : SgOmpAllocateClause::get_traversalSuccessorByIndex(size_t idx) {
6804 500 : switch (idx) {
6805 500 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6806 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6807 0 : ROSE_ASSERT(false);
6808 : return NULL;
6809 : }
6810 : }
6811 : size_t
6812 0 : SgOmpAllocateClause::get_childIndex(SgNode *child) {
6813 0 : if (child == p_variables) return 0;
6814 0 : else return (size_t) -1;
6815 : }
6816 : vector<SgNode*>
6817 6 : SgOmpUniformClause::get_traversalSuccessorContainer() {
6818 6 : vector<SgNode*> traversalSuccessorContainer;
6819 6 : traversalSuccessorContainer.reserve(1);
6820 6 : traversalSuccessorContainer.push_back(p_variables);
6821 6 : return traversalSuccessorContainer;
6822 : }
6823 : vector<string>
6824 6 : SgOmpUniformClause::get_traversalSuccessorNamesContainer() {
6825 6 : vector<string> traversalSuccessorContainer;
6826 12 : traversalSuccessorContainer.push_back("p_variables");
6827 6 : return traversalSuccessorContainer;
6828 : }
6829 : size_t
6830 45 : SgOmpUniformClause::get_numberOfTraversalSuccessors() {
6831 45 : return 1;
6832 : }
6833 : SgNode *
6834 45 : SgOmpUniformClause::get_traversalSuccessorByIndex(size_t idx) {
6835 45 : switch (idx) {
6836 45 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6837 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6838 0 : ROSE_ASSERT(false);
6839 : return NULL;
6840 : }
6841 : }
6842 : size_t
6843 0 : SgOmpUniformClause::get_childIndex(SgNode *child) {
6844 0 : if (child == p_variables) return 0;
6845 0 : else return (size_t) -1;
6846 : }
6847 : vector<SgNode*>
6848 0 : SgOmpAlignedClause::get_traversalSuccessorContainer() {
6849 0 : vector<SgNode*> traversalSuccessorContainer;
6850 0 : traversalSuccessorContainer.reserve(2);
6851 0 : traversalSuccessorContainer.push_back(p_variables);
6852 0 : traversalSuccessorContainer.push_back(p_alignment);
6853 0 : return traversalSuccessorContainer;
6854 : }
6855 : vector<string>
6856 0 : SgOmpAlignedClause::get_traversalSuccessorNamesContainer() {
6857 0 : vector<string> traversalSuccessorContainer;
6858 0 : traversalSuccessorContainer.push_back("p_variables");
6859 0 : traversalSuccessorContainer.push_back("p_alignment");
6860 0 : return traversalSuccessorContainer;
6861 : }
6862 : size_t
6863 0 : SgOmpAlignedClause::get_numberOfTraversalSuccessors() {
6864 0 : return 2;
6865 : }
6866 : SgNode *
6867 0 : SgOmpAlignedClause::get_traversalSuccessorByIndex(size_t idx) {
6868 0 : switch (idx) {
6869 0 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6870 0 : case 1: ROSE_ASSERT(p_alignment == NULL || p_alignment != NULL); return p_alignment;
6871 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6872 0 : ROSE_ASSERT(false);
6873 : return NULL;
6874 : }
6875 : }
6876 : size_t
6877 0 : SgOmpAlignedClause::get_childIndex(SgNode *child) {
6878 0 : if (child == p_variables) return 0;
6879 0 : else if (child == p_alignment) return 1;
6880 0 : else return (size_t) -1;
6881 : }
6882 : vector<SgNode*>
6883 4 : SgOmpLinearClause::get_traversalSuccessorContainer() {
6884 4 : vector<SgNode*> traversalSuccessorContainer;
6885 4 : traversalSuccessorContainer.reserve(2);
6886 4 : traversalSuccessorContainer.push_back(p_variables);
6887 4 : traversalSuccessorContainer.push_back(p_step);
6888 4 : return traversalSuccessorContainer;
6889 : }
6890 : vector<string>
6891 4 : SgOmpLinearClause::get_traversalSuccessorNamesContainer() {
6892 4 : vector<string> traversalSuccessorContainer;
6893 8 : traversalSuccessorContainer.push_back("p_variables");
6894 8 : traversalSuccessorContainer.push_back("p_step");
6895 4 : return traversalSuccessorContainer;
6896 : }
6897 : size_t
6898 30 : SgOmpLinearClause::get_numberOfTraversalSuccessors() {
6899 30 : return 2;
6900 : }
6901 : SgNode *
6902 60 : SgOmpLinearClause::get_traversalSuccessorByIndex(size_t idx) {
6903 60 : switch (idx) {
6904 30 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6905 30 : case 1: ROSE_ASSERT(p_step == NULL || p_step != NULL); return p_step;
6906 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6907 0 : ROSE_ASSERT(false);
6908 : return NULL;
6909 : }
6910 : }
6911 : size_t
6912 0 : SgOmpLinearClause::get_childIndex(SgNode *child) {
6913 0 : if (child == p_variables) return 0;
6914 0 : else if (child == p_step) return 1;
6915 0 : else return (size_t) -1;
6916 : }
6917 : vector<SgNode*>
6918 34 : SgOmpDependClause::get_traversalSuccessorContainer() {
6919 34 : vector<SgNode*> traversalSuccessorContainer;
6920 34 : traversalSuccessorContainer.reserve(1);
6921 34 : traversalSuccessorContainer.push_back(p_variables);
6922 34 : return traversalSuccessorContainer;
6923 : }
6924 : vector<string>
6925 34 : SgOmpDependClause::get_traversalSuccessorNamesContainer() {
6926 34 : vector<string> traversalSuccessorContainer;
6927 68 : traversalSuccessorContainer.push_back("p_variables");
6928 34 : return traversalSuccessorContainer;
6929 : }
6930 : size_t
6931 270 : SgOmpDependClause::get_numberOfTraversalSuccessors() {
6932 270 : return 1;
6933 : }
6934 : SgNode *
6935 270 : SgOmpDependClause::get_traversalSuccessorByIndex(size_t idx) {
6936 270 : switch (idx) {
6937 270 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6938 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6939 0 : ROSE_ASSERT(false);
6940 : return NULL;
6941 : }
6942 : }
6943 : size_t
6944 0 : SgOmpDependClause::get_childIndex(SgNode *child) {
6945 0 : if (child == p_variables) return 0;
6946 0 : else return (size_t) -1;
6947 : }
6948 : vector<SgNode*>
6949 8 : SgOmpAffinityClause::get_traversalSuccessorContainer() {
6950 8 : vector<SgNode*> traversalSuccessorContainer;
6951 8 : traversalSuccessorContainer.reserve(1);
6952 8 : traversalSuccessorContainer.push_back(p_variables);
6953 8 : return traversalSuccessorContainer;
6954 : }
6955 : vector<string>
6956 8 : SgOmpAffinityClause::get_traversalSuccessorNamesContainer() {
6957 8 : vector<string> traversalSuccessorContainer;
6958 16 : traversalSuccessorContainer.push_back("p_variables");
6959 8 : return traversalSuccessorContainer;
6960 : }
6961 : size_t
6962 64 : SgOmpAffinityClause::get_numberOfTraversalSuccessors() {
6963 64 : return 1;
6964 : }
6965 : SgNode *
6966 64 : SgOmpAffinityClause::get_traversalSuccessorByIndex(size_t idx) {
6967 64 : switch (idx) {
6968 64 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
6969 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
6970 0 : ROSE_ASSERT(false);
6971 : return NULL;
6972 : }
6973 : }
6974 : size_t
6975 0 : SgOmpAffinityClause::get_childIndex(SgNode *child) {
6976 0 : if (child == p_variables) return 0;
6977 0 : else return (size_t) -1;
6978 : }
6979 : vector<SgNode*>
6980 0 : SgOmpToClause::get_traversalSuccessorContainer() {
6981 0 : vector<SgNode*> traversalSuccessorContainer;
6982 0 : traversalSuccessorContainer.reserve(1);
6983 0 : traversalSuccessorContainer.push_back(p_variables);
6984 0 : return traversalSuccessorContainer;
6985 : }
6986 : vector<string>
6987 0 : SgOmpToClause::get_traversalSuccessorNamesContainer() {
6988 0 : vector<string> traversalSuccessorContainer;
6989 0 : traversalSuccessorContainer.push_back("p_variables");
6990 0 : return traversalSuccessorContainer;
6991 : }
6992 : size_t
6993 0 : SgOmpToClause::get_numberOfTraversalSuccessors() {
6994 0 : return 1;
6995 : }
6996 : SgNode *
6997 0 : SgOmpToClause::get_traversalSuccessorByIndex(size_t idx) {
6998 0 : switch (idx) {
6999 0 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
7000 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
7001 0 : ROSE_ASSERT(false);
7002 : return NULL;
7003 : }
7004 : }
7005 : size_t
7006 0 : SgOmpToClause::get_childIndex(SgNode *child) {
7007 0 : if (child == p_variables) return 0;
7008 0 : else return (size_t) -1;
7009 : }
7010 : vector<SgNode*>
7011 0 : SgOmpFromClause::get_traversalSuccessorContainer() {
7012 0 : vector<SgNode*> traversalSuccessorContainer;
7013 0 : traversalSuccessorContainer.reserve(1);
7014 0 : traversalSuccessorContainer.push_back(p_variables);
7015 0 : return traversalSuccessorContainer;
7016 : }
7017 : vector<string>
7018 0 : SgOmpFromClause::get_traversalSuccessorNamesContainer() {
7019 0 : vector<string> traversalSuccessorContainer;
7020 0 : traversalSuccessorContainer.push_back("p_variables");
7021 0 : return traversalSuccessorContainer;
7022 : }
7023 : size_t
7024 0 : SgOmpFromClause::get_numberOfTraversalSuccessors() {
7025 0 : return 1;
7026 : }
7027 : SgNode *
7028 0 : SgOmpFromClause::get_traversalSuccessorByIndex(size_t idx) {
7029 0 : switch (idx) {
7030 0 : case 0: ROSE_ASSERT(p_variables == NULL || p_variables != NULL); return p_variables;
7031 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
7032 0 : ROSE_ASSERT(false);
7033 : return NULL;
7034 : }
7035 : }
7036 : size_t
7037 0 : SgOmpFromClause::get_childIndex(SgNode *child) {
7038 0 : if (child == p_variables) return 0;
7039 0 : else return (size_t) -1;
7040 : }
7041 : vector<SgNode*>
7042 12 : SgOmpScheduleClause::get_traversalSuccessorContainer() {
7043 12 : vector<SgNode*> traversalSuccessorContainer;
7044 12 : traversalSuccessorContainer.reserve(1);
7045 12 : traversalSuccessorContainer.push_back(p_chunk_size);
7046 12 : return traversalSuccessorContainer;
7047 : }
7048 : vector<string>
7049 12 : SgOmpScheduleClause::get_traversalSuccessorNamesContainer() {
7050 12 : vector<string> traversalSuccessorContainer;
7051 24 : traversalSuccessorContainer.push_back("p_chunk_size");
7052 12 : return traversalSuccessorContainer;
7053 : }
7054 : size_t
7055 84 : SgOmpScheduleClause::get_numberOfTraversalSuccessors() {
7056 84 : return 1;
7057 : }
7058 : SgNode *
7059 84 : SgOmpScheduleClause::get_traversalSuccessorByIndex(size_t idx) {
7060 84 : switch (idx) {
7061 84 : case 0: ROSE_ASSERT(p_chunk_size == NULL || p_chunk_size != NULL); return p_chunk_size;
7062 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
7063 0 : ROSE_ASSERT(false);
7064 : return NULL;
7065 : }
7066 : }
7067 : size_t
7068 0 : SgOmpScheduleClause::get_childIndex(SgNode *child) {
7069 0 : if (child == p_chunk_size) return 0;
7070 0 : else return (size_t) -1;
7071 : }
7072 : vector<SgNode*>
7073 8 : SgOmpMergeableClause::get_traversalSuccessorContainer() {
7074 8 : vector<SgNode*> traversalSuccessorContainer;
7075 8 : return traversalSuccessorContainer;
7076 : }
7077 : vector<string>
7078 8 : SgOmpMergeableClause::get_traversalSuccessorNamesContainer() {
7079 8 : vector<string> traversalSuccessorContainer;
7080 8 : return traversalSuccessorContainer;
7081 : }
7082 : size_t
7083 62 : SgOmpMergeableClause::get_numberOfTraversalSuccessors() {
7084 62 : return 0;
7085 : }
7086 : SgNode *
7087 0 : SgOmpMergeableClause::get_traversalSuccessorByIndex(size_t idx) {
7088 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpMergeableClause" << " that has no successors!" << endl;
7089 0 : ROSE_ASSERT(false);
7090 : return NULL;
7091 : }
7092 : size_t
7093 0 : SgOmpMergeableClause::get_childIndex(SgNode *child) {
7094 0 : cout << "error: get_childIndex called on node of type " << "SgOmpMergeableClause" << " that has no successors!" << endl;
7095 0 : ROSE_ASSERT(false);
7096 : return 0;
7097 : }
7098 : vector<SgNode*>
7099 0 : SgOmpWhenClause::get_traversalSuccessorContainer() {
7100 0 : vector<SgNode*> traversalSuccessorContainer;
7101 0 : traversalSuccessorContainer.reserve(7);
7102 0 : traversalSuccessorContainer.push_back(p_user_condition);
7103 0 : traversalSuccessorContainer.push_back(p_user_condition_score);
7104 0 : traversalSuccessorContainer.push_back(p_device_arch);
7105 0 : traversalSuccessorContainer.push_back(p_device_isa);
7106 0 : traversalSuccessorContainer.push_back(p_implementation_user_defined);
7107 0 : traversalSuccessorContainer.push_back(p_implementation_extension);
7108 0 : traversalSuccessorContainer.push_back(p_variant_directive);
7109 0 : return traversalSuccessorContainer;
7110 : }
7111 : vector<string>
7112 0 : SgOmpWhenClause::get_traversalSuccessorNamesContainer() {
7113 0 : vector<string> traversalSuccessorContainer;
7114 0 : traversalSuccessorContainer.push_back("p_user_condition");
7115 0 : traversalSuccessorContainer.push_back("p_user_condition_score");
7116 0 : traversalSuccessorContainer.push_back("p_device_arch");
7117 0 : traversalSuccessorContainer.push_back("p_device_isa");
7118 0 : traversalSuccessorContainer.push_back("p_implementation_user_defined");
7119 0 : traversalSuccessorContainer.push_back("p_implementation_extension");
7120 0 : traversalSuccessorContainer.push_back("p_variant_directive");
7121 0 : return traversalSuccessorContainer;
7122 : }
7123 : size_t
7124 0 : SgOmpWhenClause::get_numberOfTraversalSuccessors() {
7125 0 : return 7;
7126 : }
7127 : SgNode *
7128 0 : SgOmpWhenClause::get_traversalSuccessorByIndex(size_t idx) {
7129 0 : switch (idx) {
7130 0 : case 0: ROSE_ASSERT(p_user_condition == NULL || p_user_condition != NULL); return p_user_condition;
7131 0 : case 1: ROSE_ASSERT(p_user_condition_score == NULL || p_user_condition_score != NULL); return p_user_condition_score;
7132 0 : case 2: ROSE_ASSERT(p_device_arch == NULL || p_device_arch != NULL); return p_device_arch;
7133 0 : case 3: ROSE_ASSERT(p_device_isa == NULL || p_device_isa != NULL); return p_device_isa;
7134 0 : case 4: ROSE_ASSERT(p_implementation_user_defined == NULL || p_implementation_user_defined != NULL); return p_implementation_user_defined;
7135 0 : case 5: ROSE_ASSERT(p_implementation_extension == NULL || p_implementation_extension != NULL); return p_implementation_extension;
7136 0 : case 6: ROSE_ASSERT(p_variant_directive == NULL || p_variant_directive != NULL); return p_variant_directive;
7137 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
7138 0 : ROSE_ASSERT(false);
7139 : return NULL;
7140 : }
7141 : }
7142 : size_t
7143 0 : SgOmpWhenClause::get_childIndex(SgNode *child) {
7144 0 : if (child == p_user_condition) return 0;
7145 0 : else if (child == p_user_condition_score) return 1;
7146 0 : else if (child == p_device_arch) return 2;
7147 0 : else if (child == p_device_isa) return 3;
7148 0 : else if (child == p_implementation_user_defined) return 4;
7149 0 : else if (child == p_implementation_extension) return 5;
7150 0 : else if (child == p_variant_directive) return 6;
7151 0 : else return (size_t) -1;
7152 : }
7153 : vector<SgNode*>
7154 2 : SgOmpUsesAllocatorsClause::get_traversalSuccessorContainer() {
7155 2 : vector<SgNode*> traversalSuccessorContainer;
7156 2 : return traversalSuccessorContainer;
7157 : }
7158 : vector<string>
7159 2 : SgOmpUsesAllocatorsClause::get_traversalSuccessorNamesContainer() {
7160 2 : vector<string> traversalSuccessorContainer;
7161 2 : return traversalSuccessorContainer;
7162 : }
7163 : size_t
7164 16 : SgOmpUsesAllocatorsClause::get_numberOfTraversalSuccessors() {
7165 16 : return 0;
7166 : }
7167 : SgNode *
7168 0 : SgOmpUsesAllocatorsClause::get_traversalSuccessorByIndex(size_t idx) {
7169 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpUsesAllocatorsClause" << " that has no successors!" << endl;
7170 0 : ROSE_ASSERT(false);
7171 : return NULL;
7172 : }
7173 : size_t
7174 0 : SgOmpUsesAllocatorsClause::get_childIndex(SgNode *child) {
7175 0 : cout << "error: get_childIndex called on node of type " << "SgOmpUsesAllocatorsClause" << " that has no successors!" << endl;
7176 0 : ROSE_ASSERT(false);
7177 : return 0;
7178 : }
7179 : vector<SgNode*>
7180 0 : SgOmpFullClause::get_traversalSuccessorContainer() {
7181 0 : vector<SgNode*> traversalSuccessorContainer;
7182 0 : return traversalSuccessorContainer;
7183 : }
7184 : vector<string>
7185 0 : SgOmpFullClause::get_traversalSuccessorNamesContainer() {
7186 0 : vector<string> traversalSuccessorContainer;
7187 0 : return traversalSuccessorContainer;
7188 : }
7189 : size_t
7190 0 : SgOmpFullClause::get_numberOfTraversalSuccessors() {
7191 0 : return 0;
7192 : }
7193 : SgNode *
7194 0 : SgOmpFullClause::get_traversalSuccessorByIndex(size_t idx) {
7195 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpFullClause" << " that has no successors!" << endl;
7196 0 : ROSE_ASSERT(false);
7197 : return NULL;
7198 : }
7199 : size_t
7200 0 : SgOmpFullClause::get_childIndex(SgNode *child) {
7201 0 : cout << "error: get_childIndex called on node of type " << "SgOmpFullClause" << " that has no successors!" << endl;
7202 0 : ROSE_ASSERT(false);
7203 : return 0;
7204 : }
7205 : vector<SgNode*>
7206 0 : SgUpirBranchField::get_traversalSuccessorContainer() {
7207 0 : vector<SgNode*> traversalSuccessorContainer;
7208 0 : return traversalSuccessorContainer;
7209 : }
7210 : vector<string>
7211 0 : SgUpirBranchField::get_traversalSuccessorNamesContainer() {
7212 0 : vector<string> traversalSuccessorContainer;
7213 0 : return traversalSuccessorContainer;
7214 : }
7215 : size_t
7216 0 : SgUpirBranchField::get_numberOfTraversalSuccessors() {
7217 0 : return 0;
7218 : }
7219 : SgNode *
7220 0 : SgUpirBranchField::get_traversalSuccessorByIndex(size_t idx) {
7221 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUpirBranchField" << " that has no successors!" << endl;
7222 0 : ROSE_ASSERT(false);
7223 : return NULL;
7224 : }
7225 : size_t
7226 0 : SgUpirBranchField::get_childIndex(SgNode *child) {
7227 0 : cout << "error: get_childIndex called on node of type " << "SgUpirBranchField" << " that has no successors!" << endl;
7228 0 : ROSE_ASSERT(false);
7229 : return 0;
7230 : }
7231 : vector<SgNode*>
7232 0 : SgUpirNestedLevelField::get_traversalSuccessorContainer() {
7233 0 : vector<SgNode*> traversalSuccessorContainer;
7234 0 : return traversalSuccessorContainer;
7235 : }
7236 : vector<string>
7237 0 : SgUpirNestedLevelField::get_traversalSuccessorNamesContainer() {
7238 0 : vector<string> traversalSuccessorContainer;
7239 0 : return traversalSuccessorContainer;
7240 : }
7241 : size_t
7242 0 : SgUpirNestedLevelField::get_numberOfTraversalSuccessors() {
7243 0 : return 0;
7244 : }
7245 : SgNode *
7246 0 : SgUpirNestedLevelField::get_traversalSuccessorByIndex(size_t idx) {
7247 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUpirNestedLevelField" << " that has no successors!" << endl;
7248 0 : ROSE_ASSERT(false);
7249 : return NULL;
7250 : }
7251 : size_t
7252 0 : SgUpirNestedLevelField::get_childIndex(SgNode *child) {
7253 0 : cout << "error: get_childIndex called on node of type " << "SgUpirNestedLevelField" << " that has no successors!" << endl;
7254 0 : ROSE_ASSERT(false);
7255 : return 0;
7256 : }
7257 : vector<SgNode*>
7258 0 : SgUpirNestedParentField::get_traversalSuccessorContainer() {
7259 0 : vector<SgNode*> traversalSuccessorContainer;
7260 0 : return traversalSuccessorContainer;
7261 : }
7262 : vector<string>
7263 0 : SgUpirNestedParentField::get_traversalSuccessorNamesContainer() {
7264 0 : vector<string> traversalSuccessorContainer;
7265 0 : return traversalSuccessorContainer;
7266 : }
7267 : size_t
7268 0 : SgUpirNestedParentField::get_numberOfTraversalSuccessors() {
7269 0 : return 0;
7270 : }
7271 : SgNode *
7272 0 : SgUpirNestedParentField::get_traversalSuccessorByIndex(size_t idx) {
7273 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUpirNestedParentField" << " that has no successors!" << endl;
7274 0 : ROSE_ASSERT(false);
7275 : return NULL;
7276 : }
7277 : size_t
7278 0 : SgUpirNestedParentField::get_childIndex(SgNode *child) {
7279 0 : cout << "error: get_childIndex called on node of type " << "SgUpirNestedParentField" << " that has no successors!" << endl;
7280 0 : ROSE_ASSERT(false);
7281 : return 0;
7282 : }
7283 : vector<SgNode*>
7284 0 : SgUpirNestedChildField::get_traversalSuccessorContainer() {
7285 0 : vector<SgNode*> traversalSuccessorContainer;
7286 0 : return traversalSuccessorContainer;
7287 : }
7288 : vector<string>
7289 0 : SgUpirNestedChildField::get_traversalSuccessorNamesContainer() {
7290 0 : vector<string> traversalSuccessorContainer;
7291 0 : return traversalSuccessorContainer;
7292 : }
7293 : size_t
7294 0 : SgUpirNestedChildField::get_numberOfTraversalSuccessors() {
7295 0 : return 0;
7296 : }
7297 : SgNode *
7298 0 : SgUpirNestedChildField::get_traversalSuccessorByIndex(size_t idx) {
7299 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUpirNestedChildField" << " that has no successors!" << endl;
7300 0 : ROSE_ASSERT(false);
7301 : return NULL;
7302 : }
7303 : size_t
7304 0 : SgUpirNestedChildField::get_childIndex(SgNode *child) {
7305 0 : cout << "error: get_childIndex called on node of type " << "SgUpirNestedChildField" << " that has no successors!" << endl;
7306 0 : ROSE_ASSERT(false);
7307 : return 0;
7308 : }
7309 : vector<SgNode*>
7310 0 : SgUpirSyncField::get_traversalSuccessorContainer() {
7311 0 : vector<SgNode*> traversalSuccessorContainer;
7312 0 : return traversalSuccessorContainer;
7313 : }
7314 : vector<string>
7315 0 : SgUpirSyncField::get_traversalSuccessorNamesContainer() {
7316 0 : vector<string> traversalSuccessorContainer;
7317 0 : return traversalSuccessorContainer;
7318 : }
7319 : size_t
7320 0 : SgUpirSyncField::get_numberOfTraversalSuccessors() {
7321 0 : return 0;
7322 : }
7323 : SgNode *
7324 0 : SgUpirSyncField::get_traversalSuccessorByIndex(size_t idx) {
7325 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUpirSyncField" << " that has no successors!" << endl;
7326 0 : ROSE_ASSERT(false);
7327 : return NULL;
7328 : }
7329 : size_t
7330 0 : SgUpirSyncField::get_childIndex(SgNode *child) {
7331 0 : cout << "error: get_childIndex called on node of type " << "SgUpirSyncField" << " that has no successors!" << endl;
7332 0 : ROSE_ASSERT(false);
7333 : return 0;
7334 : }
7335 : vector<SgNode*>
7336 0 : SgUpirDataField::get_traversalSuccessorContainer() {
7337 0 : vector<SgNode*> traversalSuccessorContainer;
7338 0 : return traversalSuccessorContainer;
7339 : }
7340 : vector<string>
7341 0 : SgUpirDataField::get_traversalSuccessorNamesContainer() {
7342 0 : vector<string> traversalSuccessorContainer;
7343 0 : return traversalSuccessorContainer;
7344 : }
7345 : size_t
7346 0 : SgUpirDataField::get_numberOfTraversalSuccessors() {
7347 0 : return 0;
7348 : }
7349 : SgNode *
7350 0 : SgUpirDataField::get_traversalSuccessorByIndex(size_t idx) {
7351 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUpirDataField" << " that has no successors!" << endl;
7352 0 : ROSE_ASSERT(false);
7353 : return NULL;
7354 : }
7355 : size_t
7356 0 : SgUpirDataField::get_childIndex(SgNode *child) {
7357 0 : cout << "error: get_childIndex called on node of type " << "SgUpirDataField" << " that has no successors!" << endl;
7358 0 : ROSE_ASSERT(false);
7359 : return 0;
7360 : }
7361 : vector<SgNode*>
7362 0 : SgUpirTargetField::get_traversalSuccessorContainer() {
7363 0 : vector<SgNode*> traversalSuccessorContainer;
7364 0 : return traversalSuccessorContainer;
7365 : }
7366 : vector<string>
7367 0 : SgUpirTargetField::get_traversalSuccessorNamesContainer() {
7368 0 : vector<string> traversalSuccessorContainer;
7369 0 : return traversalSuccessorContainer;
7370 : }
7371 : size_t
7372 0 : SgUpirTargetField::get_numberOfTraversalSuccessors() {
7373 0 : return 0;
7374 : }
7375 : SgNode *
7376 0 : SgUpirTargetField::get_traversalSuccessorByIndex(size_t idx) {
7377 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUpirTargetField" << " that has no successors!" << endl;
7378 0 : ROSE_ASSERT(false);
7379 : return NULL;
7380 : }
7381 : size_t
7382 0 : SgUpirTargetField::get_childIndex(SgNode *child) {
7383 0 : cout << "error: get_childIndex called on node of type " << "SgUpirTargetField" << " that has no successors!" << endl;
7384 0 : ROSE_ASSERT(false);
7385 : return 0;
7386 : }
7387 : vector<SgNode*>
7388 0 : SgUpirDataItemField::get_traversalSuccessorContainer() {
7389 0 : vector<SgNode*> traversalSuccessorContainer;
7390 0 : traversalSuccessorContainer.reserve(6);
7391 0 : traversalSuccessorContainer.push_back(p_symbol);
7392 0 : traversalSuccessorContainer.push_back(p_mapper);
7393 0 : traversalSuccessorContainer.push_back(p_unit_id);
7394 0 : traversalSuccessorContainer.push_back(p_user_defined_allocator);
7395 0 : traversalSuccessorContainer.push_back(p_user_defined_deallocator);
7396 0 : traversalSuccessorContainer.push_back(p_memcpy_helper);
7397 0 : return traversalSuccessorContainer;
7398 : }
7399 : vector<string>
7400 0 : SgUpirDataItemField::get_traversalSuccessorNamesContainer() {
7401 0 : vector<string> traversalSuccessorContainer;
7402 0 : traversalSuccessorContainer.push_back("p_symbol");
7403 0 : traversalSuccessorContainer.push_back("p_mapper");
7404 0 : traversalSuccessorContainer.push_back("p_unit_id");
7405 0 : traversalSuccessorContainer.push_back("p_user_defined_allocator");
7406 0 : traversalSuccessorContainer.push_back("p_user_defined_deallocator");
7407 0 : traversalSuccessorContainer.push_back("p_memcpy_helper");
7408 0 : return traversalSuccessorContainer;
7409 : }
7410 : size_t
7411 0 : SgUpirDataItemField::get_numberOfTraversalSuccessors() {
7412 0 : return 6;
7413 : }
7414 : SgNode *
7415 0 : SgUpirDataItemField::get_traversalSuccessorByIndex(size_t idx) {
7416 0 : switch (idx) {
7417 0 : case 0: ROSE_ASSERT(p_symbol == NULL || p_symbol != NULL); return p_symbol;
7418 0 : case 1: ROSE_ASSERT(p_mapper == NULL || p_mapper != NULL); return p_mapper;
7419 0 : case 2: ROSE_ASSERT(p_unit_id == NULL || p_unit_id != NULL); return p_unit_id;
7420 0 : case 3: ROSE_ASSERT(p_user_defined_allocator == NULL || p_user_defined_allocator != NULL); return p_user_defined_allocator;
7421 0 : case 4: ROSE_ASSERT(p_user_defined_deallocator == NULL || p_user_defined_deallocator != NULL); return p_user_defined_deallocator;
7422 0 : case 5: ROSE_ASSERT(p_memcpy_helper == NULL || p_memcpy_helper != NULL); return p_memcpy_helper;
7423 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
7424 0 : ROSE_ASSERT(false);
7425 : return NULL;
7426 : }
7427 : }
7428 : size_t
7429 0 : SgUpirDataItemField::get_childIndex(SgNode *child) {
7430 0 : if (child == p_symbol) return 0;
7431 0 : else if (child == p_mapper) return 1;
7432 0 : else if (child == p_unit_id) return 2;
7433 0 : else if (child == p_user_defined_allocator) return 3;
7434 0 : else if (child == p_user_defined_deallocator) return 4;
7435 0 : else if (child == p_memcpy_helper) return 5;
7436 0 : else return (size_t) -1;
7437 : }
7438 : vector<SgNode*>
7439 0 : SgLambdaCapture::get_traversalSuccessorContainer() {
7440 0 : vector<SgNode*> traversalSuccessorContainer;
7441 0 : traversalSuccessorContainer.reserve(3);
7442 0 : traversalSuccessorContainer.push_back(p_capture_variable);
7443 0 : traversalSuccessorContainer.push_back(p_source_closure_variable);
7444 0 : traversalSuccessorContainer.push_back(p_closure_variable);
7445 0 : return traversalSuccessorContainer;
7446 : }
7447 : vector<string>
7448 0 : SgLambdaCapture::get_traversalSuccessorNamesContainer() {
7449 0 : vector<string> traversalSuccessorContainer;
7450 0 : traversalSuccessorContainer.push_back("p_capture_variable");
7451 0 : traversalSuccessorContainer.push_back("p_source_closure_variable");
7452 0 : traversalSuccessorContainer.push_back("p_closure_variable");
7453 0 : return traversalSuccessorContainer;
7454 : }
7455 : size_t
7456 0 : SgLambdaCapture::get_numberOfTraversalSuccessors() {
7457 0 : return 3;
7458 : }
7459 : SgNode *
7460 0 : SgLambdaCapture::get_traversalSuccessorByIndex(size_t idx) {
7461 0 : switch (idx) {
7462 0 : case 0: ROSE_ASSERT(p_capture_variable == NULL || p_capture_variable != NULL); return p_capture_variable;
7463 0 : case 1: ROSE_ASSERT(p_source_closure_variable == NULL || p_source_closure_variable != NULL); return p_source_closure_variable;
7464 0 : case 2: ROSE_ASSERT(p_closure_variable == NULL || p_closure_variable != NULL); return p_closure_variable;
7465 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
7466 0 : ROSE_ASSERT(false);
7467 : return NULL;
7468 : }
7469 : }
7470 : size_t
7471 0 : SgLambdaCapture::get_childIndex(SgNode *child) {
7472 0 : if (child == p_capture_variable) return 0;
7473 0 : else if (child == p_source_closure_variable) return 1;
7474 0 : else if (child == p_closure_variable) return 2;
7475 0 : else return (size_t) -1;
7476 : }
7477 : vector<SgNode*>
7478 0 : SgLambdaCaptureList::get_traversalSuccessorContainer() {
7479 0 : vector<SgNode*> traversalSuccessorContainer;
7480 0 : traversalSuccessorContainer.reserve(p_capture_list.size() + 0);
7481 0 : {
7482 0 : SgLambdaCapturePtrList::iterator iter;
7483 0 : for (iter = p_capture_list.begin(); iter != p_capture_list.end(); iter++)
7484 0 : traversalSuccessorContainer.push_back(*iter);
7485 : }
7486 0 : return traversalSuccessorContainer;
7487 : }
7488 : vector<string>
7489 0 : SgLambdaCaptureList::get_traversalSuccessorNamesContainer() {
7490 0 : vector<string> traversalSuccessorContainer;
7491 0 : int i = 0;
7492 0 : {
7493 0 : SgLambdaCapturePtrList::iterator iter;
7494 0 : for (iter = p_capture_list.begin(); iter != p_capture_list.end(); (iter++,i++)) {
7495 0 : char buf[20];
7496 0 : sprintf(buf,"*[%d]",i);
7497 0 : traversalSuccessorContainer.push_back(buf);
7498 : }
7499 : }
7500 0 : return traversalSuccessorContainer;
7501 : }
7502 : size_t
7503 0 : SgLambdaCaptureList::get_numberOfTraversalSuccessors() {
7504 0 : return p_capture_list.size() + 0;
7505 : }
7506 : SgNode *
7507 0 : SgLambdaCaptureList::get_traversalSuccessorByIndex(size_t idx) {
7508 0 : ROSE_ASSERT(idx < p_capture_list.size());
7509 0 : return p_capture_list[idx];
7510 : }
7511 : size_t
7512 0 : SgLambdaCaptureList::get_childIndex(SgNode *child) {
7513 0 : SgLambdaCapturePtrList::iterator itr = find(p_capture_list.begin(), p_capture_list.end(), child);
7514 0 : if (itr != p_capture_list.end()) return itr - p_capture_list.begin();
7515 : else return (size_t) -1;
7516 : }
7517 : vector<SgNode*>
7518 0 : SgStatement::get_traversalSuccessorContainer() {
7519 0 : vector<SgNode*> traversalSuccessorContainer;
7520 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
7521 0 : << "static: SgStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
7522 0 : cerr << "Aborting ..." << endl;
7523 0 : ROSE_ASSERT(false);
7524 : return traversalSuccessorContainer;
7525 : }
7526 :
7527 : vector<string>
7528 0 : SgStatement::get_traversalSuccessorNamesContainer() {
7529 0 : vector<string> traversalSuccessorContainer;
7530 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
7531 0 : << "static: SgStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
7532 0 : cerr << "Aborting ..." << endl;
7533 0 : ROSE_ASSERT(false);
7534 : return traversalSuccessorContainer;
7535 : }
7536 :
7537 : size_t
7538 0 : SgStatement::get_numberOfTraversalSuccessors() {
7539 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
7540 0 : << "static: SgStatement" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
7541 0 : cerr << "Aborting ..." << endl;
7542 0 : ROSE_ASSERT(false);
7543 : return 42;
7544 : }
7545 :
7546 : SgNode*
7547 0 : SgStatement::get_traversalSuccessorByIndex(size_t) {
7548 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
7549 0 : << "static: SgStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
7550 0 : cerr << "Aborting ..." << endl;
7551 0 : ROSE_ASSERT(false);
7552 : return NULL;
7553 : }
7554 :
7555 : size_t
7556 0 : SgStatement::get_childIndex(SgNode *) {
7557 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
7558 0 : << "static: SgStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
7559 0 : cerr << "Aborting ..." << endl;
7560 0 : ROSE_ASSERT(false);
7561 : return 42;
7562 : }
7563 :
7564 : vector<SgNode*>
7565 0 : SgScopeStatement::get_traversalSuccessorContainer() {
7566 0 : vector<SgNode*> traversalSuccessorContainer;
7567 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
7568 0 : << "static: SgScopeStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
7569 0 : cerr << "Aborting ..." << endl;
7570 0 : ROSE_ASSERT(false);
7571 : return traversalSuccessorContainer;
7572 : }
7573 :
7574 : vector<string>
7575 0 : SgScopeStatement::get_traversalSuccessorNamesContainer() {
7576 0 : vector<string> traversalSuccessorContainer;
7577 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
7578 0 : << "static: SgScopeStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
7579 0 : cerr << "Aborting ..." << endl;
7580 0 : ROSE_ASSERT(false);
7581 : return traversalSuccessorContainer;
7582 : }
7583 :
7584 : size_t
7585 0 : SgScopeStatement::get_numberOfTraversalSuccessors() {
7586 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
7587 0 : << "static: SgScopeStatement" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
7588 0 : cerr << "Aborting ..." << endl;
7589 0 : ROSE_ASSERT(false);
7590 : return 42;
7591 : }
7592 :
7593 : SgNode*
7594 0 : SgScopeStatement::get_traversalSuccessorByIndex(size_t) {
7595 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
7596 0 : << "static: SgScopeStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
7597 0 : cerr << "Aborting ..." << endl;
7598 0 : ROSE_ASSERT(false);
7599 : return NULL;
7600 : }
7601 :
7602 : size_t
7603 0 : SgScopeStatement::get_childIndex(SgNode *) {
7604 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
7605 0 : << "static: SgScopeStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
7606 0 : cerr << "Aborting ..." << endl;
7607 0 : ROSE_ASSERT(false);
7608 : return 42;
7609 : }
7610 :
7611 : vector<SgNode*>
7612 1704 : SgGlobal::get_traversalSuccessorContainer() {
7613 1704 : vector<SgNode*> traversalSuccessorContainer;
7614 1704 : traversalSuccessorContainer.reserve(p_declarations.size() + 0);
7615 1704 : {
7616 1704 : SgDeclarationStatementPtrList::iterator iter;
7617 7052230 : for (iter = p_declarations.begin(); iter != p_declarations.end(); iter++)
7618 7050520 : traversalSuccessorContainer.push_back(*iter);
7619 : }
7620 1704 : return traversalSuccessorContainer;
7621 : }
7622 : vector<string>
7623 8127 : SgGlobal::get_traversalSuccessorNamesContainer() {
7624 8127 : vector<string> traversalSuccessorContainer;
7625 8127 : int i = 0;
7626 8127 : {
7627 8127 : SgDeclarationStatementPtrList::iterator iter;
7628 28716300 : for (iter = p_declarations.begin(); iter != p_declarations.end(); (iter++,i++)) {
7629 28708200 : char buf[20];
7630 28708200 : sprintf(buf,"*[%d]",i);
7631 57416300 : traversalSuccessorContainer.push_back(buf);
7632 : }
7633 : }
7634 8127 : return traversalSuccessorContainer;
7635 : }
7636 : size_t
7637 31995 : SgGlobal::get_numberOfTraversalSuccessors() {
7638 31995 : return p_declarations.size() + 0;
7639 : }
7640 : SgNode *
7641 47419300 : SgGlobal::get_traversalSuccessorByIndex(size_t idx) {
7642 47419300 : ROSE_ASSERT(idx < p_declarations.size());
7643 47419300 : return p_declarations[idx];
7644 : }
7645 : size_t
7646 0 : SgGlobal::get_childIndex(SgNode *child) {
7647 0 : SgDeclarationStatementPtrList::iterator itr = find(p_declarations.begin(), p_declarations.end(), child);
7648 0 : if (itr != p_declarations.end()) return itr - p_declarations.begin();
7649 : else return (size_t) -1;
7650 : }
7651 : vector<SgNode*>
7652 873098 : SgBasicBlock::get_traversalSuccessorContainer() {
7653 873098 : vector<SgNode*> traversalSuccessorContainer;
7654 873098 : traversalSuccessorContainer.reserve(p_statements.size() + 0);
7655 873098 : {
7656 873098 : SgStatementPtrList::iterator iter;
7657 2158980 : for (iter = p_statements.begin(); iter != p_statements.end(); iter++)
7658 1285880 : traversalSuccessorContainer.push_back(*iter);
7659 : }
7660 873098 : return traversalSuccessorContainer;
7661 : }
7662 : vector<string>
7663 51723 : SgBasicBlock::get_traversalSuccessorNamesContainer() {
7664 51723 : vector<string> traversalSuccessorContainer;
7665 51723 : int i = 0;
7666 51723 : {
7667 51723 : SgStatementPtrList::iterator iter;
7668 174988 : for (iter = p_statements.begin(); iter != p_statements.end(); (iter++,i++)) {
7669 123265 : char buf[20];
7670 123265 : sprintf(buf,"*[%d]",i);
7671 246530 : traversalSuccessorContainer.push_back(buf);
7672 : }
7673 : }
7674 51723 : return traversalSuccessorContainer;
7675 : }
7676 : size_t
7677 1739270 : SgBasicBlock::get_numberOfTraversalSuccessors() {
7678 1739270 : return p_statements.size() + 0;
7679 : }
7680 : SgNode *
7681 2786070 : SgBasicBlock::get_traversalSuccessorByIndex(size_t idx) {
7682 2786070 : ROSE_ASSERT(idx < p_statements.size());
7683 2786070 : return p_statements[idx];
7684 : }
7685 : size_t
7686 0 : SgBasicBlock::get_childIndex(SgNode *child) {
7687 0 : SgStatementPtrList::iterator itr = find(p_statements.begin(), p_statements.end(), child);
7688 0 : if (itr != p_statements.end()) return itr - p_statements.begin();
7689 : else return (size_t) -1;
7690 : }
7691 : vector<SgNode*>
7692 91991 : SgIfStmt::get_traversalSuccessorContainer() {
7693 91991 : vector<SgNode*> traversalSuccessorContainer;
7694 91991 : traversalSuccessorContainer.reserve(3);
7695 91991 : traversalSuccessorContainer.push_back(p_conditional);
7696 91991 : traversalSuccessorContainer.push_back(p_true_body);
7697 91991 : traversalSuccessorContainer.push_back(p_false_body);
7698 91991 : return traversalSuccessorContainer;
7699 : }
7700 : vector<string>
7701 7774 : SgIfStmt::get_traversalSuccessorNamesContainer() {
7702 7774 : vector<string> traversalSuccessorContainer;
7703 15548 : traversalSuccessorContainer.push_back("p_conditional");
7704 15548 : traversalSuccessorContainer.push_back("p_true_body");
7705 15548 : traversalSuccessorContainer.push_back("p_false_body");
7706 7774 : return traversalSuccessorContainer;
7707 : }
7708 : size_t
7709 283795 : SgIfStmt::get_numberOfTraversalSuccessors() {
7710 283795 : return 3;
7711 : }
7712 : SgNode *
7713 849001 : SgIfStmt::get_traversalSuccessorByIndex(size_t idx) {
7714 849001 : switch (idx) {
7715 283051 : case 0: ROSE_ASSERT(p_conditional == NULL || p_conditional != NULL); return p_conditional;
7716 283051 : case 1: ROSE_ASSERT(p_true_body == NULL || p_true_body != NULL); return p_true_body;
7717 282899 : case 2: ROSE_ASSERT(p_false_body == NULL || p_false_body != NULL); return p_false_body;
7718 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
7719 0 : ROSE_ASSERT(false);
7720 : return NULL;
7721 : }
7722 : }
7723 : size_t
7724 0 : SgIfStmt::get_childIndex(SgNode *child) {
7725 0 : if (child == p_conditional) return 0;
7726 0 : else if (child == p_true_body) return 1;
7727 0 : else if (child == p_false_body) return 2;
7728 0 : else return (size_t) -1;
7729 : }
7730 : vector<SgNode*>
7731 33271 : SgForStatement::get_traversalSuccessorContainer() {
7732 33271 : vector<SgNode*> traversalSuccessorContainer;
7733 33271 : traversalSuccessorContainer.reserve(5);
7734 33271 : traversalSuccessorContainer.push_back(p_for_init_stmt);
7735 33271 : traversalSuccessorContainer.push_back(p_test);
7736 33271 : traversalSuccessorContainer.push_back(p_increment);
7737 33271 : traversalSuccessorContainer.push_back(p_loop_body);
7738 33271 : traversalSuccessorContainer.push_back(p_else_body);
7739 33271 : return traversalSuccessorContainer;
7740 : }
7741 : vector<string>
7742 1130 : SgForStatement::get_traversalSuccessorNamesContainer() {
7743 1130 : vector<string> traversalSuccessorContainer;
7744 2260 : traversalSuccessorContainer.push_back("p_for_init_stmt");
7745 2260 : traversalSuccessorContainer.push_back("p_test");
7746 2260 : traversalSuccessorContainer.push_back("p_increment");
7747 2260 : traversalSuccessorContainer.push_back("p_loop_body");
7748 2260 : traversalSuccessorContainer.push_back("p_else_body");
7749 1130 : return traversalSuccessorContainer;
7750 : }
7751 : size_t
7752 63777 : SgForStatement::get_numberOfTraversalSuccessors() {
7753 63777 : return 5;
7754 : }
7755 : SgNode *
7756 316035 : SgForStatement::get_traversalSuccessorByIndex(size_t idx) {
7757 316035 : switch (idx) {
7758 63227 : case 0: ROSE_ASSERT(p_for_init_stmt == NULL || p_for_init_stmt != NULL); return p_for_init_stmt;
7759 63227 : case 1: ROSE_ASSERT(p_test == NULL || p_test != NULL); return p_test;
7760 63227 : case 2: ROSE_ASSERT(p_increment == NULL || p_increment != NULL); return p_increment;
7761 63227 : case 3: ROSE_ASSERT(p_loop_body == NULL || p_loop_body != NULL); return p_loop_body;
7762 63127 : case 4: ROSE_ASSERT(p_else_body == NULL || p_else_body != NULL); return p_else_body;
7763 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
7764 0 : ROSE_ASSERT(false);
7765 : return NULL;
7766 : }
7767 : }
7768 : size_t
7769 0 : SgForStatement::get_childIndex(SgNode *child) {
7770 0 : if (child == p_for_init_stmt) return 0;
7771 0 : else if (child == p_test) return 1;
7772 0 : else if (child == p_increment) return 2;
7773 0 : else if (child == p_loop_body) return 3;
7774 0 : else if (child == p_else_body) return 4;
7775 0 : else return (size_t) -1;
7776 : }
7777 : vector<SgNode*>
7778 563599 : SgFunctionDefinition::get_traversalSuccessorContainer() {
7779 563599 : vector<SgNode*> traversalSuccessorContainer;
7780 563599 : traversalSuccessorContainer.reserve(1);
7781 563599 : traversalSuccessorContainer.push_back(p_body);
7782 563599 : return traversalSuccessorContainer;
7783 : }
7784 : vector<string>
7785 23456 : SgFunctionDefinition::get_traversalSuccessorNamesContainer() {
7786 23456 : vector<string> traversalSuccessorContainer;
7787 46912 : traversalSuccessorContainer.push_back("p_body");
7788 23456 : return traversalSuccessorContainer;
7789 : }
7790 : size_t
7791 1150360 : SgFunctionDefinition::get_numberOfTraversalSuccessors() {
7792 1150360 : return 1;
7793 : }
7794 : SgNode *
7795 1149540 : SgFunctionDefinition::get_traversalSuccessorByIndex(size_t idx) {
7796 1149540 : switch (idx) {
7797 1149540 : case 0: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
7798 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
7799 0 : ROSE_ASSERT(false);
7800 : return NULL;
7801 : }
7802 : }
7803 : size_t
7804 0 : SgFunctionDefinition::get_childIndex(SgNode *child) {
7805 0 : if (child == p_body) return 0;
7806 0 : else return (size_t) -1;
7807 : }
7808 : vector<SgNode*>
7809 209675 : SgTemplateFunctionDefinition::get_traversalSuccessorContainer() {
7810 209675 : vector<SgNode*> traversalSuccessorContainer;
7811 209675 : traversalSuccessorContainer.reserve(1);
7812 209675 : traversalSuccessorContainer.push_back(p_body);
7813 209675 : return traversalSuccessorContainer;
7814 : }
7815 : vector<string>
7816 4412 : SgTemplateFunctionDefinition::get_traversalSuccessorNamesContainer() {
7817 4412 : vector<string> traversalSuccessorContainer;
7818 8824 : traversalSuccessorContainer.push_back("p_body");
7819 4412 : return traversalSuccessorContainer;
7820 : }
7821 : size_t
7822 325498 : SgTemplateFunctionDefinition::get_numberOfTraversalSuccessors() {
7823 325498 : return 1;
7824 : }
7825 : SgNode *
7826 325182 : SgTemplateFunctionDefinition::get_traversalSuccessorByIndex(size_t idx) {
7827 325182 : switch (idx) {
7828 325182 : case 0: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
7829 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
7830 0 : ROSE_ASSERT(false);
7831 : return NULL;
7832 : }
7833 : }
7834 : size_t
7835 0 : SgTemplateFunctionDefinition::get_childIndex(SgNode *child) {
7836 0 : if (child == p_body) return 0;
7837 0 : else return (size_t) -1;
7838 : }
7839 : vector<SgNode*>
7840 70750 : SgClassDefinition::get_traversalSuccessorContainer() {
7841 70750 : vector<SgNode*> traversalSuccessorContainer;
7842 70750 : traversalSuccessorContainer.reserve(p_members.size() + 0);
7843 70750 : {
7844 70750 : SgDeclarationStatementPtrList::iterator iter;
7845 329012 : for (iter = p_members.begin(); iter != p_members.end(); iter++)
7846 258262 : traversalSuccessorContainer.push_back(*iter);
7847 : }
7848 70750 : return traversalSuccessorContainer;
7849 : }
7850 : vector<string>
7851 18919 : SgClassDefinition::get_traversalSuccessorNamesContainer() {
7852 18919 : vector<string> traversalSuccessorContainer;
7853 18919 : int i = 0;
7854 18919 : {
7855 18919 : SgDeclarationStatementPtrList::iterator iter;
7856 91702 : for (iter = p_members.begin(); iter != p_members.end(); (iter++,i++)) {
7857 72783 : char buf[20];
7858 72783 : sprintf(buf,"*[%d]",i);
7859 145566 : traversalSuccessorContainer.push_back(buf);
7860 : }
7861 : }
7862 18919 : return traversalSuccessorContainer;
7863 : }
7864 : size_t
7865 299724 : SgClassDefinition::get_numberOfTraversalSuccessors() {
7866 299724 : return p_members.size() + 0;
7867 : }
7868 : SgNode *
7869 1147180 : SgClassDefinition::get_traversalSuccessorByIndex(size_t idx) {
7870 1147180 : ROSE_ASSERT(idx < p_members.size());
7871 1147180 : return p_members[idx];
7872 : }
7873 : size_t
7874 0 : SgClassDefinition::get_childIndex(SgNode *child) {
7875 0 : SgDeclarationStatementPtrList::iterator itr = find(p_members.begin(), p_members.end(), child);
7876 0 : if (itr != p_members.end()) return itr - p_members.begin();
7877 : else return (size_t) -1;
7878 : }
7879 : vector<SgNode*>
7880 176922 : SgTemplateInstantiationDefn::get_traversalSuccessorContainer() {
7881 176922 : vector<SgNode*> traversalSuccessorContainer;
7882 176922 : traversalSuccessorContainer.reserve(p_members.size() + 0);
7883 176922 : {
7884 176922 : SgDeclarationStatementPtrList::iterator iter;
7885 692266 : for (iter = p_members.begin(); iter != p_members.end(); iter++)
7886 515344 : traversalSuccessorContainer.push_back(*iter);
7887 : }
7888 176922 : return traversalSuccessorContainer;
7889 : }
7890 : vector<string>
7891 10224 : SgTemplateInstantiationDefn::get_traversalSuccessorNamesContainer() {
7892 10224 : vector<string> traversalSuccessorContainer;
7893 10224 : int i = 0;
7894 10224 : {
7895 10224 : SgDeclarationStatementPtrList::iterator iter;
7896 63030 : for (iter = p_members.begin(); iter != p_members.end(); (iter++,i++)) {
7897 52806 : char buf[20];
7898 52806 : sprintf(buf,"*[%d]",i);
7899 105612 : traversalSuccessorContainer.push_back(buf);
7900 : }
7901 : }
7902 10224 : return traversalSuccessorContainer;
7903 : }
7904 : size_t
7905 370358 : SgTemplateInstantiationDefn::get_numberOfTraversalSuccessors() {
7906 370358 : return p_members.size() + 0;
7907 : }
7908 : SgNode *
7909 1389290 : SgTemplateInstantiationDefn::get_traversalSuccessorByIndex(size_t idx) {
7910 1389290 : ROSE_ASSERT(idx < p_members.size());
7911 1389290 : return p_members[idx];
7912 : }
7913 : size_t
7914 0 : SgTemplateInstantiationDefn::get_childIndex(SgNode *child) {
7915 0 : SgDeclarationStatementPtrList::iterator itr = find(p_members.begin(), p_members.end(), child);
7916 0 : if (itr != p_members.end()) return itr - p_members.begin();
7917 : else return (size_t) -1;
7918 : }
7919 : vector<SgNode*>
7920 252214 : SgTemplateClassDefinition::get_traversalSuccessorContainer() {
7921 252214 : vector<SgNode*> traversalSuccessorContainer;
7922 252214 : traversalSuccessorContainer.reserve(p_members.size() + 0);
7923 252214 : {
7924 252214 : SgDeclarationStatementPtrList::iterator iter;
7925 783353 : for (iter = p_members.begin(); iter != p_members.end(); iter++)
7926 531139 : traversalSuccessorContainer.push_back(*iter);
7927 : }
7928 252214 : return traversalSuccessorContainer;
7929 : }
7930 : vector<string>
7931 8676 : SgTemplateClassDefinition::get_traversalSuccessorNamesContainer() {
7932 8676 : vector<string> traversalSuccessorContainer;
7933 8676 : int i = 0;
7934 8676 : {
7935 8676 : SgDeclarationStatementPtrList::iterator iter;
7936 35781 : for (iter = p_members.begin(); iter != p_members.end(); (iter++,i++)) {
7937 27105 : char buf[20];
7938 27105 : sprintf(buf,"*[%d]",i);
7939 54210 : traversalSuccessorContainer.push_back(buf);
7940 : }
7941 : }
7942 8676 : return traversalSuccessorContainer;
7943 : }
7944 : size_t
7945 425565 : SgTemplateClassDefinition::get_numberOfTraversalSuccessors() {
7946 425565 : return p_members.size() + 0;
7947 : }
7948 : SgNode *
7949 982156 : SgTemplateClassDefinition::get_traversalSuccessorByIndex(size_t idx) {
7950 982156 : ROSE_ASSERT(idx < p_members.size());
7951 982156 : return p_members[idx];
7952 : }
7953 : size_t
7954 0 : SgTemplateClassDefinition::get_childIndex(SgNode *child) {
7955 0 : SgDeclarationStatementPtrList::iterator itr = find(p_members.begin(), p_members.end(), child);
7956 0 : if (itr != p_members.end()) return itr - p_members.begin();
7957 : else return (size_t) -1;
7958 : }
7959 : vector<SgNode*>
7960 7344 : SgWhileStmt::get_traversalSuccessorContainer() {
7961 7344 : vector<SgNode*> traversalSuccessorContainer;
7962 7344 : traversalSuccessorContainer.reserve(3);
7963 7344 : traversalSuccessorContainer.push_back(p_condition);
7964 7344 : traversalSuccessorContainer.push_back(p_body);
7965 7344 : traversalSuccessorContainer.push_back(p_else_body);
7966 7344 : return traversalSuccessorContainer;
7967 : }
7968 : vector<string>
7969 618 : SgWhileStmt::get_traversalSuccessorNamesContainer() {
7970 618 : vector<string> traversalSuccessorContainer;
7971 1236 : traversalSuccessorContainer.push_back("p_condition");
7972 1236 : traversalSuccessorContainer.push_back("p_body");
7973 1236 : traversalSuccessorContainer.push_back("p_else_body");
7974 618 : return traversalSuccessorContainer;
7975 : }
7976 : size_t
7977 22164 : SgWhileStmt::get_numberOfTraversalSuccessors() {
7978 22164 : return 3;
7979 : }
7980 : SgNode *
7981 66318 : SgWhileStmt::get_traversalSuccessorByIndex(size_t idx) {
7982 66318 : switch (idx) {
7983 22114 : case 0: ROSE_ASSERT(p_condition == NULL || p_condition != NULL); return p_condition;
7984 22114 : case 1: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
7985 22090 : case 2: ROSE_ASSERT(p_else_body == NULL || p_else_body != NULL); return p_else_body;
7986 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
7987 0 : ROSE_ASSERT(false);
7988 : return NULL;
7989 : }
7990 : }
7991 : size_t
7992 0 : SgWhileStmt::get_childIndex(SgNode *child) {
7993 0 : if (child == p_condition) return 0;
7994 0 : else if (child == p_body) return 1;
7995 0 : else if (child == p_else_body) return 2;
7996 0 : else return (size_t) -1;
7997 : }
7998 : vector<SgNode*>
7999 199 : SgDoWhileStmt::get_traversalSuccessorContainer() {
8000 199 : vector<SgNode*> traversalSuccessorContainer;
8001 199 : traversalSuccessorContainer.reserve(2);
8002 199 : traversalSuccessorContainer.push_back(p_body);
8003 199 : traversalSuccessorContainer.push_back(p_condition);
8004 199 : return traversalSuccessorContainer;
8005 : }
8006 : vector<string>
8007 86 : SgDoWhileStmt::get_traversalSuccessorNamesContainer() {
8008 86 : vector<string> traversalSuccessorContainer;
8009 172 : traversalSuccessorContainer.push_back("p_body");
8010 172 : traversalSuccessorContainer.push_back("p_condition");
8011 86 : return traversalSuccessorContainer;
8012 : }
8013 : size_t
8014 2278 : SgDoWhileStmt::get_numberOfTraversalSuccessors() {
8015 2278 : return 2;
8016 : }
8017 : SgNode *
8018 4556 : SgDoWhileStmt::get_traversalSuccessorByIndex(size_t idx) {
8019 4556 : switch (idx) {
8020 2278 : case 0: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
8021 2278 : case 1: ROSE_ASSERT(p_condition == NULL || p_condition != NULL); return p_condition;
8022 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
8023 0 : ROSE_ASSERT(false);
8024 : return NULL;
8025 : }
8026 : }
8027 : size_t
8028 0 : SgDoWhileStmt::get_childIndex(SgNode *child) {
8029 0 : if (child == p_body) return 0;
8030 0 : else if (child == p_condition) return 1;
8031 0 : else return (size_t) -1;
8032 : }
8033 : vector<SgNode*>
8034 7 : SgSwitchStatement::get_traversalSuccessorContainer() {
8035 7 : vector<SgNode*> traversalSuccessorContainer;
8036 7 : traversalSuccessorContainer.reserve(2);
8037 7 : traversalSuccessorContainer.push_back(p_item_selector);
8038 7 : traversalSuccessorContainer.push_back(p_body);
8039 7 : return traversalSuccessorContainer;
8040 : }
8041 : vector<string>
8042 0 : SgSwitchStatement::get_traversalSuccessorNamesContainer() {
8043 0 : vector<string> traversalSuccessorContainer;
8044 0 : traversalSuccessorContainer.push_back("p_item_selector");
8045 0 : traversalSuccessorContainer.push_back("p_body");
8046 0 : return traversalSuccessorContainer;
8047 : }
8048 : size_t
8049 38 : SgSwitchStatement::get_numberOfTraversalSuccessors() {
8050 38 : return 2;
8051 : }
8052 : SgNode *
8053 76 : SgSwitchStatement::get_traversalSuccessorByIndex(size_t idx) {
8054 76 : switch (idx) {
8055 38 : case 0: ROSE_ASSERT(p_item_selector == NULL || p_item_selector != NULL); return p_item_selector;
8056 38 : case 1: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
8057 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
8058 0 : ROSE_ASSERT(false);
8059 : return NULL;
8060 : }
8061 : }
8062 : size_t
8063 0 : SgSwitchStatement::get_childIndex(SgNode *child) {
8064 0 : if (child == p_item_selector) return 0;
8065 0 : else if (child == p_body) return 1;
8066 0 : else return (size_t) -1;
8067 : }
8068 : vector<SgNode*>
8069 19269 : SgCatchOptionStmt::get_traversalSuccessorContainer() {
8070 19269 : vector<SgNode*> traversalSuccessorContainer;
8071 19269 : traversalSuccessorContainer.reserve(2);
8072 19269 : traversalSuccessorContainer.push_back(p_condition);
8073 19269 : traversalSuccessorContainer.push_back(p_body);
8074 19269 : return traversalSuccessorContainer;
8075 : }
8076 : vector<string>
8077 1136 : SgCatchOptionStmt::get_traversalSuccessorNamesContainer() {
8078 1136 : vector<string> traversalSuccessorContainer;
8079 2272 : traversalSuccessorContainer.push_back("p_condition");
8080 2272 : traversalSuccessorContainer.push_back("p_body");
8081 1136 : return traversalSuccessorContainer;
8082 : }
8083 : size_t
8084 48099 : SgCatchOptionStmt::get_numberOfTraversalSuccessors() {
8085 48099 : return 2;
8086 : }
8087 : SgNode *
8088 95974 : SgCatchOptionStmt::get_traversalSuccessorByIndex(size_t idx) {
8089 95974 : switch (idx) {
8090 47987 : case 0: ROSE_ASSERT(p_condition == NULL || p_condition != NULL); return p_condition;
8091 47987 : case 1: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
8092 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
8093 0 : ROSE_ASSERT(false);
8094 : return NULL;
8095 : }
8096 : }
8097 : size_t
8098 0 : SgCatchOptionStmt::get_childIndex(SgNode *child) {
8099 0 : if (child == p_condition) return 0;
8100 0 : else if (child == p_body) return 1;
8101 0 : else return (size_t) -1;
8102 : }
8103 : vector<SgNode*>
8104 36352 : SgNamespaceDefinitionStatement::get_traversalSuccessorContainer() {
8105 36352 : vector<SgNode*> traversalSuccessorContainer;
8106 36352 : traversalSuccessorContainer.reserve(p_declarations.size() + 0);
8107 36352 : {
8108 36352 : SgDeclarationStatementPtrList::iterator iter;
8109 1083600 : for (iter = p_declarations.begin(); iter != p_declarations.end(); iter++)
8110 1047240 : traversalSuccessorContainer.push_back(*iter);
8111 : }
8112 36352 : return traversalSuccessorContainer;
8113 : }
8114 : vector<string>
8115 2412 : SgNamespaceDefinitionStatement::get_traversalSuccessorNamesContainer() {
8116 2412 : vector<string> traversalSuccessorContainer;
8117 2412 : int i = 0;
8118 2412 : {
8119 2412 : SgDeclarationStatementPtrList::iterator iter;
8120 56232 : for (iter = p_declarations.begin(); iter != p_declarations.end(); (iter++,i++)) {
8121 53820 : char buf[20];
8122 53820 : sprintf(buf,"*[%d]",i);
8123 107640 : traversalSuccessorContainer.push_back(buf);
8124 : }
8125 : }
8126 2412 : return traversalSuccessorContainer;
8127 : }
8128 : size_t
8129 80664 : SgNamespaceDefinitionStatement::get_numberOfTraversalSuccessors() {
8130 80664 : return p_declarations.size() + 0;
8131 : }
8132 : SgNode *
8133 1926400 : SgNamespaceDefinitionStatement::get_traversalSuccessorByIndex(size_t idx) {
8134 1926400 : ROSE_ASSERT(idx < p_declarations.size());
8135 1926400 : return p_declarations[idx];
8136 : }
8137 : size_t
8138 0 : SgNamespaceDefinitionStatement::get_childIndex(SgNode *child) {
8139 0 : SgDeclarationStatementPtrList::iterator itr = find(p_declarations.begin(), p_declarations.end(), child);
8140 0 : if (itr != p_declarations.end()) return itr - p_declarations.begin();
8141 : else return (size_t) -1;
8142 : }
8143 : vector<SgNode*>
8144 0 : SgBlockDataStatement::get_traversalSuccessorContainer() {
8145 0 : vector<SgNode*> traversalSuccessorContainer;
8146 0 : return traversalSuccessorContainer;
8147 : }
8148 : vector<string>
8149 0 : SgBlockDataStatement::get_traversalSuccessorNamesContainer() {
8150 0 : vector<string> traversalSuccessorContainer;
8151 0 : return traversalSuccessorContainer;
8152 : }
8153 : size_t
8154 0 : SgBlockDataStatement::get_numberOfTraversalSuccessors() {
8155 0 : return 0;
8156 : }
8157 : SgNode *
8158 0 : SgBlockDataStatement::get_traversalSuccessorByIndex(size_t idx) {
8159 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgBlockDataStatement" << " that has no successors!" << endl;
8160 0 : ROSE_ASSERT(false);
8161 : return NULL;
8162 : }
8163 : size_t
8164 0 : SgBlockDataStatement::get_childIndex(SgNode *child) {
8165 0 : cout << "error: get_childIndex called on node of type " << "SgBlockDataStatement" << " that has no successors!" << endl;
8166 0 : ROSE_ASSERT(false);
8167 : return 0;
8168 : }
8169 : vector<SgNode*>
8170 0 : SgAssociateStatement::get_traversalSuccessorContainer() {
8171 0 : vector<SgNode*> traversalSuccessorContainer;
8172 0 : traversalSuccessorContainer.reserve(1);
8173 0 : traversalSuccessorContainer.push_back(p_body);
8174 0 : return traversalSuccessorContainer;
8175 : }
8176 : vector<string>
8177 0 : SgAssociateStatement::get_traversalSuccessorNamesContainer() {
8178 0 : vector<string> traversalSuccessorContainer;
8179 0 : traversalSuccessorContainer.push_back("p_body");
8180 0 : return traversalSuccessorContainer;
8181 : }
8182 : size_t
8183 0 : SgAssociateStatement::get_numberOfTraversalSuccessors() {
8184 0 : return 1;
8185 : }
8186 : SgNode *
8187 0 : SgAssociateStatement::get_traversalSuccessorByIndex(size_t idx) {
8188 0 : switch (idx) {
8189 0 : case 0: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
8190 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
8191 0 : ROSE_ASSERT(false);
8192 : return NULL;
8193 : }
8194 : }
8195 : size_t
8196 0 : SgAssociateStatement::get_childIndex(SgNode *child) {
8197 0 : if (child == p_body) return 0;
8198 0 : else return (size_t) -1;
8199 : }
8200 : vector<SgNode*>
8201 88 : SgFortranDo::get_traversalSuccessorContainer() {
8202 88 : vector<SgNode*> traversalSuccessorContainer;
8203 88 : traversalSuccessorContainer.reserve(4);
8204 88 : traversalSuccessorContainer.push_back(p_initialization);
8205 88 : traversalSuccessorContainer.push_back(p_bound);
8206 88 : traversalSuccessorContainer.push_back(p_increment);
8207 88 : traversalSuccessorContainer.push_back(p_body);
8208 88 : return traversalSuccessorContainer;
8209 : }
8210 : vector<string>
8211 42 : SgFortranDo::get_traversalSuccessorNamesContainer() {
8212 42 : vector<string> traversalSuccessorContainer;
8213 84 : traversalSuccessorContainer.push_back("p_initialization");
8214 84 : traversalSuccessorContainer.push_back("p_bound");
8215 84 : traversalSuccessorContainer.push_back("p_increment");
8216 84 : traversalSuccessorContainer.push_back("p_body");
8217 42 : return traversalSuccessorContainer;
8218 : }
8219 : size_t
8220 886 : SgFortranDo::get_numberOfTraversalSuccessors() {
8221 886 : return 4;
8222 : }
8223 : SgNode *
8224 3544 : SgFortranDo::get_traversalSuccessorByIndex(size_t idx) {
8225 3544 : switch (idx) {
8226 886 : case 0: ROSE_ASSERT(p_initialization == NULL || p_initialization != NULL); return p_initialization;
8227 886 : case 1: ROSE_ASSERT(p_bound == NULL || p_bound != NULL); return p_bound;
8228 886 : case 2: ROSE_ASSERT(p_increment == NULL || p_increment != NULL); return p_increment;
8229 886 : case 3: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
8230 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
8231 0 : ROSE_ASSERT(false);
8232 : return NULL;
8233 : }
8234 : }
8235 : size_t
8236 0 : SgFortranDo::get_childIndex(SgNode *child) {
8237 0 : if (child == p_initialization) return 0;
8238 0 : else if (child == p_bound) return 1;
8239 0 : else if (child == p_increment) return 2;
8240 0 : else if (child == p_body) return 3;
8241 0 : else return (size_t) -1;
8242 : }
8243 : vector<SgNode*>
8244 0 : SgFortranNonblockedDo::get_traversalSuccessorContainer() {
8245 0 : vector<SgNode*> traversalSuccessorContainer;
8246 0 : traversalSuccessorContainer.reserve(4);
8247 0 : traversalSuccessorContainer.push_back(p_initialization);
8248 0 : traversalSuccessorContainer.push_back(p_bound);
8249 0 : traversalSuccessorContainer.push_back(p_increment);
8250 0 : traversalSuccessorContainer.push_back(p_body);
8251 0 : return traversalSuccessorContainer;
8252 : }
8253 : vector<string>
8254 0 : SgFortranNonblockedDo::get_traversalSuccessorNamesContainer() {
8255 0 : vector<string> traversalSuccessorContainer;
8256 0 : traversalSuccessorContainer.push_back("p_initialization");
8257 0 : traversalSuccessorContainer.push_back("p_bound");
8258 0 : traversalSuccessorContainer.push_back("p_increment");
8259 0 : traversalSuccessorContainer.push_back("p_body");
8260 0 : return traversalSuccessorContainer;
8261 : }
8262 : size_t
8263 0 : SgFortranNonblockedDo::get_numberOfTraversalSuccessors() {
8264 0 : return 4;
8265 : }
8266 : SgNode *
8267 0 : SgFortranNonblockedDo::get_traversalSuccessorByIndex(size_t idx) {
8268 0 : switch (idx) {
8269 0 : case 0: ROSE_ASSERT(p_initialization == NULL || p_initialization != NULL); return p_initialization;
8270 0 : case 1: ROSE_ASSERT(p_bound == NULL || p_bound != NULL); return p_bound;
8271 0 : case 2: ROSE_ASSERT(p_increment == NULL || p_increment != NULL); return p_increment;
8272 0 : case 3: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
8273 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
8274 0 : ROSE_ASSERT(false);
8275 : return NULL;
8276 : }
8277 : }
8278 : size_t
8279 0 : SgFortranNonblockedDo::get_childIndex(SgNode *child) {
8280 0 : if (child == p_initialization) return 0;
8281 0 : else if (child == p_bound) return 1;
8282 0 : else if (child == p_increment) return 2;
8283 0 : else if (child == p_body) return 3;
8284 0 : else return (size_t) -1;
8285 : }
8286 : vector<SgNode*>
8287 0 : SgForAllStatement::get_traversalSuccessorContainer() {
8288 0 : vector<SgNode*> traversalSuccessorContainer;
8289 0 : traversalSuccessorContainer.reserve(2);
8290 0 : traversalSuccessorContainer.push_back(p_forall_header);
8291 0 : traversalSuccessorContainer.push_back(p_body);
8292 0 : return traversalSuccessorContainer;
8293 : }
8294 : vector<string>
8295 0 : SgForAllStatement::get_traversalSuccessorNamesContainer() {
8296 0 : vector<string> traversalSuccessorContainer;
8297 0 : traversalSuccessorContainer.push_back("p_forall_header");
8298 0 : traversalSuccessorContainer.push_back("p_body");
8299 0 : return traversalSuccessorContainer;
8300 : }
8301 : size_t
8302 0 : SgForAllStatement::get_numberOfTraversalSuccessors() {
8303 0 : return 2;
8304 : }
8305 : SgNode *
8306 0 : SgForAllStatement::get_traversalSuccessorByIndex(size_t idx) {
8307 0 : switch (idx) {
8308 0 : case 0: ROSE_ASSERT(p_forall_header == NULL || p_forall_header != NULL); return p_forall_header;
8309 0 : case 1: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
8310 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
8311 0 : ROSE_ASSERT(false);
8312 : return NULL;
8313 : }
8314 : }
8315 : size_t
8316 0 : SgForAllStatement::get_childIndex(SgNode *child) {
8317 0 : if (child == p_forall_header) return 0;
8318 0 : else if (child == p_body) return 1;
8319 0 : else return (size_t) -1;
8320 : }
8321 : vector<SgNode*>
8322 0 : SgUpcForAllStatement::get_traversalSuccessorContainer() {
8323 0 : vector<SgNode*> traversalSuccessorContainer;
8324 0 : traversalSuccessorContainer.reserve(5);
8325 0 : traversalSuccessorContainer.push_back(p_for_init_stmt);
8326 0 : traversalSuccessorContainer.push_back(p_test);
8327 0 : traversalSuccessorContainer.push_back(p_increment);
8328 0 : traversalSuccessorContainer.push_back(p_affinity);
8329 0 : traversalSuccessorContainer.push_back(p_loop_body);
8330 0 : return traversalSuccessorContainer;
8331 : }
8332 : vector<string>
8333 0 : SgUpcForAllStatement::get_traversalSuccessorNamesContainer() {
8334 0 : vector<string> traversalSuccessorContainer;
8335 0 : traversalSuccessorContainer.push_back("p_for_init_stmt");
8336 0 : traversalSuccessorContainer.push_back("p_test");
8337 0 : traversalSuccessorContainer.push_back("p_increment");
8338 0 : traversalSuccessorContainer.push_back("p_affinity");
8339 0 : traversalSuccessorContainer.push_back("p_loop_body");
8340 0 : return traversalSuccessorContainer;
8341 : }
8342 : size_t
8343 0 : SgUpcForAllStatement::get_numberOfTraversalSuccessors() {
8344 0 : return 5;
8345 : }
8346 : SgNode *
8347 0 : SgUpcForAllStatement::get_traversalSuccessorByIndex(size_t idx) {
8348 0 : switch (idx) {
8349 0 : case 0: ROSE_ASSERT(p_for_init_stmt == NULL || p_for_init_stmt != NULL); return p_for_init_stmt;
8350 0 : case 1: ROSE_ASSERT(p_test == NULL || p_test != NULL); return p_test;
8351 0 : case 2: ROSE_ASSERT(p_increment == NULL || p_increment != NULL); return p_increment;
8352 0 : case 3: ROSE_ASSERT(p_affinity == NULL || p_affinity != NULL); return p_affinity;
8353 0 : case 4: ROSE_ASSERT(p_loop_body == NULL || p_loop_body != NULL); return p_loop_body;
8354 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
8355 0 : ROSE_ASSERT(false);
8356 : return NULL;
8357 : }
8358 : }
8359 : size_t
8360 0 : SgUpcForAllStatement::get_childIndex(SgNode *child) {
8361 0 : if (child == p_for_init_stmt) return 0;
8362 0 : else if (child == p_test) return 1;
8363 0 : else if (child == p_increment) return 2;
8364 0 : else if (child == p_affinity) return 3;
8365 0 : else if (child == p_loop_body) return 4;
8366 0 : else return (size_t) -1;
8367 : }
8368 : vector<SgNode*>
8369 0 : SgCAFWithTeamStatement::get_traversalSuccessorContainer() {
8370 0 : vector<SgNode*> traversalSuccessorContainer;
8371 0 : traversalSuccessorContainer.reserve(1);
8372 0 : traversalSuccessorContainer.push_back(p_body);
8373 0 : return traversalSuccessorContainer;
8374 : }
8375 : vector<string>
8376 0 : SgCAFWithTeamStatement::get_traversalSuccessorNamesContainer() {
8377 0 : vector<string> traversalSuccessorContainer;
8378 0 : traversalSuccessorContainer.push_back("p_body");
8379 0 : return traversalSuccessorContainer;
8380 : }
8381 : size_t
8382 0 : SgCAFWithTeamStatement::get_numberOfTraversalSuccessors() {
8383 0 : return 1;
8384 : }
8385 : SgNode *
8386 0 : SgCAFWithTeamStatement::get_traversalSuccessorByIndex(size_t idx) {
8387 0 : switch (idx) {
8388 0 : case 0: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
8389 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
8390 0 : ROSE_ASSERT(false);
8391 : return NULL;
8392 : }
8393 : }
8394 : size_t
8395 0 : SgCAFWithTeamStatement::get_childIndex(SgNode *child) {
8396 0 : if (child == p_body) return 0;
8397 0 : else return (size_t) -1;
8398 : }
8399 : vector<SgNode*>
8400 0 : SgFunctionParameterScope::get_traversalSuccessorContainer() {
8401 0 : vector<SgNode*> traversalSuccessorContainer;
8402 0 : traversalSuccessorContainer.reserve(p_declarations.size() + 0);
8403 0 : {
8404 0 : SgDeclarationStatementPtrList::iterator iter;
8405 0 : for (iter = p_declarations.begin(); iter != p_declarations.end(); iter++)
8406 0 : traversalSuccessorContainer.push_back(*iter);
8407 : }
8408 0 : return traversalSuccessorContainer;
8409 : }
8410 : vector<string>
8411 0 : SgFunctionParameterScope::get_traversalSuccessorNamesContainer() {
8412 0 : vector<string> traversalSuccessorContainer;
8413 0 : int i = 0;
8414 0 : {
8415 0 : SgDeclarationStatementPtrList::iterator iter;
8416 0 : for (iter = p_declarations.begin(); iter != p_declarations.end(); (iter++,i++)) {
8417 0 : char buf[20];
8418 0 : sprintf(buf,"*[%d]",i);
8419 0 : traversalSuccessorContainer.push_back(buf);
8420 : }
8421 : }
8422 0 : return traversalSuccessorContainer;
8423 : }
8424 : size_t
8425 0 : SgFunctionParameterScope::get_numberOfTraversalSuccessors() {
8426 0 : return p_declarations.size() + 0;
8427 : }
8428 : SgNode *
8429 0 : SgFunctionParameterScope::get_traversalSuccessorByIndex(size_t idx) {
8430 0 : ROSE_ASSERT(idx < p_declarations.size());
8431 0 : return p_declarations[idx];
8432 : }
8433 : size_t
8434 0 : SgFunctionParameterScope::get_childIndex(SgNode *child) {
8435 0 : SgDeclarationStatementPtrList::iterator itr = find(p_declarations.begin(), p_declarations.end(), child);
8436 0 : if (itr != p_declarations.end()) return itr - p_declarations.begin();
8437 : else return (size_t) -1;
8438 : }
8439 : vector<SgNode*>
8440 0 : SgDeclarationScope::get_traversalSuccessorContainer() {
8441 0 : vector<SgNode*> traversalSuccessorContainer;
8442 0 : return traversalSuccessorContainer;
8443 : }
8444 : vector<string>
8445 0 : SgDeclarationScope::get_traversalSuccessorNamesContainer() {
8446 0 : vector<string> traversalSuccessorContainer;
8447 0 : return traversalSuccessorContainer;
8448 : }
8449 : size_t
8450 0 : SgDeclarationScope::get_numberOfTraversalSuccessors() {
8451 0 : return 0;
8452 : }
8453 : SgNode *
8454 0 : SgDeclarationScope::get_traversalSuccessorByIndex(size_t idx) {
8455 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgDeclarationScope" << " that has no successors!" << endl;
8456 0 : ROSE_ASSERT(false);
8457 : return NULL;
8458 : }
8459 : size_t
8460 0 : SgDeclarationScope::get_childIndex(SgNode *child) {
8461 0 : cout << "error: get_childIndex called on node of type " << "SgDeclarationScope" << " that has no successors!" << endl;
8462 0 : ROSE_ASSERT(false);
8463 : return 0;
8464 : }
8465 : vector<SgNode*>
8466 0 : SgRangeBasedForStatement::get_traversalSuccessorContainer() {
8467 0 : vector<SgNode*> traversalSuccessorContainer;
8468 0 : traversalSuccessorContainer.reserve(7);
8469 0 : traversalSuccessorContainer.push_back(p_iterator_declaration);
8470 0 : traversalSuccessorContainer.push_back(p_range_declaration);
8471 0 : traversalSuccessorContainer.push_back(p_begin_declaration);
8472 0 : traversalSuccessorContainer.push_back(p_end_declaration);
8473 0 : traversalSuccessorContainer.push_back(p_not_equal_expression);
8474 0 : traversalSuccessorContainer.push_back(p_increment_expression);
8475 0 : traversalSuccessorContainer.push_back(p_loop_body);
8476 0 : return traversalSuccessorContainer;
8477 : }
8478 : vector<string>
8479 0 : SgRangeBasedForStatement::get_traversalSuccessorNamesContainer() {
8480 0 : vector<string> traversalSuccessorContainer;
8481 0 : traversalSuccessorContainer.push_back("p_iterator_declaration");
8482 0 : traversalSuccessorContainer.push_back("p_range_declaration");
8483 0 : traversalSuccessorContainer.push_back("p_begin_declaration");
8484 0 : traversalSuccessorContainer.push_back("p_end_declaration");
8485 0 : traversalSuccessorContainer.push_back("p_not_equal_expression");
8486 0 : traversalSuccessorContainer.push_back("p_increment_expression");
8487 0 : traversalSuccessorContainer.push_back("p_loop_body");
8488 0 : return traversalSuccessorContainer;
8489 : }
8490 : size_t
8491 0 : SgRangeBasedForStatement::get_numberOfTraversalSuccessors() {
8492 0 : return 7;
8493 : }
8494 : SgNode *
8495 0 : SgRangeBasedForStatement::get_traversalSuccessorByIndex(size_t idx) {
8496 0 : switch (idx) {
8497 0 : case 0: ROSE_ASSERT(p_iterator_declaration == NULL || p_iterator_declaration != NULL); return p_iterator_declaration;
8498 0 : case 1: ROSE_ASSERT(p_range_declaration == NULL || p_range_declaration != NULL); return p_range_declaration;
8499 0 : case 2: ROSE_ASSERT(p_begin_declaration == NULL || p_begin_declaration != NULL); return p_begin_declaration;
8500 0 : case 3: ROSE_ASSERT(p_end_declaration == NULL || p_end_declaration != NULL); return p_end_declaration;
8501 0 : case 4: ROSE_ASSERT(p_not_equal_expression == NULL || p_not_equal_expression != NULL); return p_not_equal_expression;
8502 0 : case 5: ROSE_ASSERT(p_increment_expression == NULL || p_increment_expression != NULL); return p_increment_expression;
8503 0 : case 6: ROSE_ASSERT(p_loop_body == NULL || p_loop_body != NULL); return p_loop_body;
8504 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
8505 0 : ROSE_ASSERT(false);
8506 : return NULL;
8507 : }
8508 : }
8509 : size_t
8510 0 : SgRangeBasedForStatement::get_childIndex(SgNode *child) {
8511 0 : if (child == p_iterator_declaration) return 0;
8512 0 : else if (child == p_range_declaration) return 1;
8513 0 : else if (child == p_begin_declaration) return 2;
8514 0 : else if (child == p_end_declaration) return 3;
8515 0 : else if (child == p_not_equal_expression) return 4;
8516 0 : else if (child == p_increment_expression) return 5;
8517 0 : else if (child == p_loop_body) return 6;
8518 0 : else return (size_t) -1;
8519 : }
8520 : vector<SgNode*>
8521 0 : SgFunctionTypeTable::get_traversalSuccessorContainer() {
8522 0 : vector<SgNode*> traversalSuccessorContainer;
8523 0 : return traversalSuccessorContainer;
8524 : }
8525 : vector<string>
8526 0 : SgFunctionTypeTable::get_traversalSuccessorNamesContainer() {
8527 0 : vector<string> traversalSuccessorContainer;
8528 0 : return traversalSuccessorContainer;
8529 : }
8530 : size_t
8531 0 : SgFunctionTypeTable::get_numberOfTraversalSuccessors() {
8532 0 : return 0;
8533 : }
8534 : SgNode *
8535 0 : SgFunctionTypeTable::get_traversalSuccessorByIndex(size_t idx) {
8536 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgFunctionTypeTable" << " that has no successors!" << endl;
8537 0 : ROSE_ASSERT(false);
8538 : return NULL;
8539 : }
8540 : size_t
8541 0 : SgFunctionTypeTable::get_childIndex(SgNode *child) {
8542 0 : cout << "error: get_childIndex called on node of type " << "SgFunctionTypeTable" << " that has no successors!" << endl;
8543 0 : ROSE_ASSERT(false);
8544 : return 0;
8545 : }
8546 : vector<SgNode*>
8547 0 : SgDeclarationStatement::get_traversalSuccessorContainer() {
8548 0 : vector<SgNode*> traversalSuccessorContainer;
8549 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
8550 0 : << "static: SgDeclarationStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
8551 0 : cerr << "Aborting ..." << endl;
8552 0 : ROSE_ASSERT(false);
8553 : return traversalSuccessorContainer;
8554 : }
8555 :
8556 : vector<string>
8557 0 : SgDeclarationStatement::get_traversalSuccessorNamesContainer() {
8558 0 : vector<string> traversalSuccessorContainer;
8559 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
8560 0 : << "static: SgDeclarationStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
8561 0 : cerr << "Aborting ..." << endl;
8562 0 : ROSE_ASSERT(false);
8563 : return traversalSuccessorContainer;
8564 : }
8565 :
8566 : size_t
8567 0 : SgDeclarationStatement::get_numberOfTraversalSuccessors() {
8568 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
8569 0 : << "static: SgDeclarationStatement" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
8570 0 : cerr << "Aborting ..." << endl;
8571 0 : ROSE_ASSERT(false);
8572 : return 42;
8573 : }
8574 :
8575 : SgNode*
8576 0 : SgDeclarationStatement::get_traversalSuccessorByIndex(size_t) {
8577 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
8578 0 : << "static: SgDeclarationStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
8579 0 : cerr << "Aborting ..." << endl;
8580 0 : ROSE_ASSERT(false);
8581 : return NULL;
8582 : }
8583 :
8584 : size_t
8585 0 : SgDeclarationStatement::get_childIndex(SgNode *) {
8586 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
8587 0 : << "static: SgDeclarationStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
8588 0 : cerr << "Aborting ..." << endl;
8589 0 : ROSE_ASSERT(false);
8590 : return 42;
8591 : }
8592 :
8593 : vector<SgNode*>
8594 8838080 : SgFunctionParameterList::get_traversalSuccessorContainer() {
8595 8838080 : vector<SgNode*> traversalSuccessorContainer;
8596 8838080 : traversalSuccessorContainer.reserve(p_args.size() + 0);
8597 8838080 : {
8598 8838080 : SgInitializedNamePtrList::iterator iter;
8599 30431000 : for (iter = p_args.begin(); iter != p_args.end(); iter++)
8600 21593000 : traversalSuccessorContainer.push_back(*iter);
8601 : }
8602 8838080 : return traversalSuccessorContainer;
8603 : }
8604 : vector<string>
8605 3196970 : SgFunctionParameterList::get_traversalSuccessorNamesContainer() {
8606 3196970 : vector<string> traversalSuccessorContainer;
8607 3196970 : int i = 0;
8608 3196970 : {
8609 3196970 : SgInitializedNamePtrList::iterator iter;
8610 11985100 : for (iter = p_args.begin(); iter != p_args.end(); (iter++,i++)) {
8611 8788180 : char buf[20];
8612 8788180 : sprintf(buf,"*[%d]",i);
8613 17576400 : traversalSuccessorContainer.push_back(buf);
8614 : }
8615 : }
8616 3196970 : return traversalSuccessorContainer;
8617 : }
8618 : size_t
8619 50132000 : SgFunctionParameterList::get_numberOfTraversalSuccessors() {
8620 50132000 : return p_args.size() + 0;
8621 : }
8622 : SgNode *
8623 133489000 : SgFunctionParameterList::get_traversalSuccessorByIndex(size_t idx) {
8624 133489000 : ROSE_ASSERT(idx < p_args.size());
8625 133489000 : return p_args[idx];
8626 : }
8627 : size_t
8628 0 : SgFunctionParameterList::get_childIndex(SgNode *child) {
8629 0 : SgInitializedNamePtrList::iterator itr = find(p_args.begin(), p_args.end(), child);
8630 0 : if (itr != p_args.end()) return itr - p_args.begin();
8631 : else return (size_t) -1;
8632 : }
8633 : vector<SgNode*>
8634 358142 : SgVariableDeclaration::get_traversalSuccessorContainer() {
8635 358142 : vector<SgNode*> traversalSuccessorContainer;
8636 358142 : traversalSuccessorContainer.reserve(p_variables.size() + 1);
8637 358142 : traversalSuccessorContainer.push_back(compute_baseTypeDefiningDeclaration());
8638 358142 : {
8639 358142 : SgInitializedNamePtrList::iterator iter;
8640 716434 : for (iter = p_variables.begin(); iter != p_variables.end(); iter++)
8641 358292 : traversalSuccessorContainer.push_back(*iter);
8642 : }
8643 358142 : return traversalSuccessorContainer;
8644 : }
8645 : vector<string>
8646 58416 : SgVariableDeclaration::get_traversalSuccessorNamesContainer() {
8647 58416 : vector<string> traversalSuccessorContainer;
8648 58416 : int i = 1;
8649 116832 : traversalSuccessorContainer.push_back("p_baseTypeDefiningDeclaration");
8650 58416 : {
8651 58416 : SgInitializedNamePtrList::iterator iter;
8652 116892 : for (iter = p_variables.begin(); iter != p_variables.end(); (iter++,i++)) {
8653 58476 : char buf[20];
8654 58476 : sprintf(buf,"*[%d]",i);
8655 116952 : traversalSuccessorContainer.push_back(buf);
8656 : }
8657 : }
8658 58416 : return traversalSuccessorContainer;
8659 : }
8660 : size_t
8661 1504640 : SgVariableDeclaration::get_numberOfTraversalSuccessors() {
8662 1504640 : return p_variables.size() + 1;
8663 : }
8664 : SgNode *
8665 3007830 : SgVariableDeclaration::get_traversalSuccessorByIndex(size_t idx) {
8666 3007830 : if (idx == 0) return compute_baseTypeDefiningDeclaration();
8667 1505030 : else return p_variables[idx-1];
8668 : }
8669 : size_t
8670 85 : SgVariableDeclaration::get_childIndex(SgNode *child) {
8671 85 : if (child == compute_baseTypeDefiningDeclaration()) return 0;
8672 : else {
8673 85 : SgInitializedNamePtrList::iterator itr = find(p_variables.begin(), p_variables.end(), child);
8674 85 : if (itr != p_variables.end()) return (itr - p_variables.begin()) + 1;
8675 : else return (size_t) -1;
8676 : }
8677 : }
8678 : vector<SgNode*>
8679 27592 : SgTemplateVariableDeclaration::get_traversalSuccessorContainer() {
8680 27592 : vector<SgNode*> traversalSuccessorContainer;
8681 27592 : traversalSuccessorContainer.reserve(p_variables.size() + 1);
8682 27592 : traversalSuccessorContainer.push_back(compute_baseTypeDefiningDeclaration());
8683 27592 : {
8684 27592 : SgInitializedNamePtrList::iterator iter;
8685 55184 : for (iter = p_variables.begin(); iter != p_variables.end(); iter++)
8686 27592 : traversalSuccessorContainer.push_back(*iter);
8687 : }
8688 27592 : return traversalSuccessorContainer;
8689 : }
8690 : vector<string>
8691 1320 : SgTemplateVariableDeclaration::get_traversalSuccessorNamesContainer() {
8692 1320 : vector<string> traversalSuccessorContainer;
8693 1320 : int i = 1;
8694 2640 : traversalSuccessorContainer.push_back("p_baseTypeDefiningDeclaration");
8695 1320 : {
8696 1320 : SgInitializedNamePtrList::iterator iter;
8697 2640 : for (iter = p_variables.begin(); iter != p_variables.end(); (iter++,i++)) {
8698 1320 : char buf[20];
8699 1320 : sprintf(buf,"*[%d]",i);
8700 2640 : traversalSuccessorContainer.push_back(buf);
8701 : }
8702 : }
8703 1320 : return traversalSuccessorContainer;
8704 : }
8705 : size_t
8706 60531 : SgTemplateVariableDeclaration::get_numberOfTraversalSuccessors() {
8707 60531 : return p_variables.size() + 1;
8708 : }
8709 : SgNode *
8710 120792 : SgTemplateVariableDeclaration::get_traversalSuccessorByIndex(size_t idx) {
8711 120792 : if (idx == 0) return compute_baseTypeDefiningDeclaration();
8712 60441 : else return p_variables[idx-1];
8713 : }
8714 : size_t
8715 0 : SgTemplateVariableDeclaration::get_childIndex(SgNode *child) {
8716 0 : if (child == compute_baseTypeDefiningDeclaration()) return 0;
8717 : else {
8718 0 : SgInitializedNamePtrList::iterator itr = find(p_variables.begin(), p_variables.end(), child);
8719 0 : if (itr != p_variables.end()) return (itr - p_variables.begin()) + 1;
8720 : else return (size_t) -1;
8721 : }
8722 : }
8723 : vector<SgNode*>
8724 0 : SgVariableDefinition::get_traversalSuccessorContainer() {
8725 0 : vector<SgNode*> traversalSuccessorContainer;
8726 0 : traversalSuccessorContainer.reserve(2);
8727 0 : traversalSuccessorContainer.push_back(p_vardefn);
8728 0 : traversalSuccessorContainer.push_back(p_bitfield);
8729 0 : return traversalSuccessorContainer;
8730 : }
8731 : vector<string>
8732 0 : SgVariableDefinition::get_traversalSuccessorNamesContainer() {
8733 0 : vector<string> traversalSuccessorContainer;
8734 0 : traversalSuccessorContainer.push_back("p_vardefn");
8735 0 : traversalSuccessorContainer.push_back("p_bitfield");
8736 0 : return traversalSuccessorContainer;
8737 : }
8738 : size_t
8739 0 : SgVariableDefinition::get_numberOfTraversalSuccessors() {
8740 0 : return 2;
8741 : }
8742 : SgNode *
8743 0 : SgVariableDefinition::get_traversalSuccessorByIndex(size_t idx) {
8744 0 : switch (idx) {
8745 0 : case 0: ROSE_ASSERT(p_vardefn == NULL || p_vardefn != NULL); return p_vardefn;
8746 0 : case 1: ROSE_ASSERT(p_bitfield == NULL || p_bitfield != NULL); return p_bitfield;
8747 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
8748 0 : ROSE_ASSERT(false);
8749 : return NULL;
8750 : }
8751 : }
8752 : size_t
8753 0 : SgVariableDefinition::get_childIndex(SgNode *child) {
8754 0 : if (child == p_vardefn) return 0;
8755 0 : else if (child == p_bitfield) return 1;
8756 0 : else return (size_t) -1;
8757 : }
8758 : vector<SgNode*>
8759 0 : SgClinkageDeclarationStatement::get_traversalSuccessorContainer() {
8760 0 : vector<SgNode*> traversalSuccessorContainer;
8761 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
8762 0 : << "static: SgClinkageDeclarationStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
8763 0 : cerr << "Aborting ..." << endl;
8764 0 : ROSE_ASSERT(false);
8765 : return traversalSuccessorContainer;
8766 : }
8767 :
8768 : vector<string>
8769 0 : SgClinkageDeclarationStatement::get_traversalSuccessorNamesContainer() {
8770 0 : vector<string> traversalSuccessorContainer;
8771 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
8772 0 : << "static: SgClinkageDeclarationStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
8773 0 : cerr << "Aborting ..." << endl;
8774 0 : ROSE_ASSERT(false);
8775 : return traversalSuccessorContainer;
8776 : }
8777 :
8778 : size_t
8779 0 : SgClinkageDeclarationStatement::get_numberOfTraversalSuccessors() {
8780 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
8781 0 : << "static: SgClinkageDeclarationStatement" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
8782 0 : cerr << "Aborting ..." << endl;
8783 0 : ROSE_ASSERT(false);
8784 : return 42;
8785 : }
8786 :
8787 : SgNode*
8788 0 : SgClinkageDeclarationStatement::get_traversalSuccessorByIndex(size_t) {
8789 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
8790 0 : << "static: SgClinkageDeclarationStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
8791 0 : cerr << "Aborting ..." << endl;
8792 0 : ROSE_ASSERT(false);
8793 : return NULL;
8794 : }
8795 :
8796 : size_t
8797 0 : SgClinkageDeclarationStatement::get_childIndex(SgNode *) {
8798 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
8799 0 : << "static: SgClinkageDeclarationStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
8800 0 : cerr << "Aborting ..." << endl;
8801 0 : ROSE_ASSERT(false);
8802 : return 42;
8803 : }
8804 :
8805 : vector<SgNode*>
8806 0 : SgClinkageStartStatement::get_traversalSuccessorContainer() {
8807 0 : vector<SgNode*> traversalSuccessorContainer;
8808 0 : return traversalSuccessorContainer;
8809 : }
8810 : vector<string>
8811 0 : SgClinkageStartStatement::get_traversalSuccessorNamesContainer() {
8812 0 : vector<string> traversalSuccessorContainer;
8813 0 : return traversalSuccessorContainer;
8814 : }
8815 : size_t
8816 0 : SgClinkageStartStatement::get_numberOfTraversalSuccessors() {
8817 0 : return 0;
8818 : }
8819 : SgNode *
8820 0 : SgClinkageStartStatement::get_traversalSuccessorByIndex(size_t idx) {
8821 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgClinkageStartStatement" << " that has no successors!" << endl;
8822 0 : ROSE_ASSERT(false);
8823 : return NULL;
8824 : }
8825 : size_t
8826 0 : SgClinkageStartStatement::get_childIndex(SgNode *child) {
8827 0 : cout << "error: get_childIndex called on node of type " << "SgClinkageStartStatement" << " that has no successors!" << endl;
8828 0 : ROSE_ASSERT(false);
8829 : return 0;
8830 : }
8831 : vector<SgNode*>
8832 0 : SgClinkageEndStatement::get_traversalSuccessorContainer() {
8833 0 : vector<SgNode*> traversalSuccessorContainer;
8834 0 : return traversalSuccessorContainer;
8835 : }
8836 : vector<string>
8837 0 : SgClinkageEndStatement::get_traversalSuccessorNamesContainer() {
8838 0 : vector<string> traversalSuccessorContainer;
8839 0 : return traversalSuccessorContainer;
8840 : }
8841 : size_t
8842 0 : SgClinkageEndStatement::get_numberOfTraversalSuccessors() {
8843 0 : return 0;
8844 : }
8845 : SgNode *
8846 0 : SgClinkageEndStatement::get_traversalSuccessorByIndex(size_t idx) {
8847 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgClinkageEndStatement" << " that has no successors!" << endl;
8848 0 : ROSE_ASSERT(false);
8849 : return NULL;
8850 : }
8851 : size_t
8852 0 : SgClinkageEndStatement::get_childIndex(SgNode *child) {
8853 0 : cout << "error: get_childIndex called on node of type " << "SgClinkageEndStatement" << " that has no successors!" << endl;
8854 0 : ROSE_ASSERT(false);
8855 : return 0;
8856 : }
8857 : vector<SgNode*>
8858 30848 : SgEnumDeclaration::get_traversalSuccessorContainer() {
8859 30848 : vector<SgNode*> traversalSuccessorContainer;
8860 30848 : traversalSuccessorContainer.reserve(p_enumerators.size() + 0);
8861 30848 : {
8862 30848 : SgInitializedNamePtrList::iterator iter;
8863 84508 : for (iter = p_enumerators.begin(); iter != p_enumerators.end(); iter++)
8864 53660 : traversalSuccessorContainer.push_back(*iter);
8865 : }
8866 30848 : return traversalSuccessorContainer;
8867 : }
8868 : vector<string>
8869 3792 : SgEnumDeclaration::get_traversalSuccessorNamesContainer() {
8870 3792 : vector<string> traversalSuccessorContainer;
8871 3792 : int i = 0;
8872 3792 : {
8873 3792 : SgInitializedNamePtrList::iterator iter;
8874 22962 : for (iter = p_enumerators.begin(); iter != p_enumerators.end(); (iter++,i++)) {
8875 19170 : char buf[20];
8876 19170 : sprintf(buf,"*[%d]",i);
8877 38340 : traversalSuccessorContainer.push_back(buf);
8878 : }
8879 : }
8880 3792 : return traversalSuccessorContainer;
8881 : }
8882 : size_t
8883 82392 : SgEnumDeclaration::get_numberOfTraversalSuccessors() {
8884 82392 : return p_enumerators.size() + 0;
8885 : }
8886 : SgNode *
8887 291162 : SgEnumDeclaration::get_traversalSuccessorByIndex(size_t idx) {
8888 291162 : ROSE_ASSERT(idx < p_enumerators.size());
8889 291162 : return p_enumerators[idx];
8890 : }
8891 : size_t
8892 0 : SgEnumDeclaration::get_childIndex(SgNode *child) {
8893 0 : SgInitializedNamePtrList::iterator itr = find(p_enumerators.begin(), p_enumerators.end(), child);
8894 0 : if (itr != p_enumerators.end()) return itr - p_enumerators.begin();
8895 : else return (size_t) -1;
8896 : }
8897 : vector<SgNode*>
8898 0 : SgAsmStmt::get_traversalSuccessorContainer() {
8899 0 : vector<SgNode*> traversalSuccessorContainer;
8900 0 : traversalSuccessorContainer.reserve(p_operands.size() + 0);
8901 0 : {
8902 0 : SgExpressionPtrList::iterator iter;
8903 0 : for (iter = p_operands.begin(); iter != p_operands.end(); iter++)
8904 0 : traversalSuccessorContainer.push_back(*iter);
8905 : }
8906 0 : return traversalSuccessorContainer;
8907 : }
8908 : vector<string>
8909 0 : SgAsmStmt::get_traversalSuccessorNamesContainer() {
8910 0 : vector<string> traversalSuccessorContainer;
8911 0 : int i = 0;
8912 0 : {
8913 0 : SgExpressionPtrList::iterator iter;
8914 0 : for (iter = p_operands.begin(); iter != p_operands.end(); (iter++,i++)) {
8915 0 : char buf[20];
8916 0 : sprintf(buf,"*[%d]",i);
8917 0 : traversalSuccessorContainer.push_back(buf);
8918 : }
8919 : }
8920 0 : return traversalSuccessorContainer;
8921 : }
8922 : size_t
8923 0 : SgAsmStmt::get_numberOfTraversalSuccessors() {
8924 0 : return p_operands.size() + 0;
8925 : }
8926 : SgNode *
8927 0 : SgAsmStmt::get_traversalSuccessorByIndex(size_t idx) {
8928 0 : ROSE_ASSERT(idx < p_operands.size());
8929 0 : return p_operands[idx];
8930 : }
8931 : size_t
8932 0 : SgAsmStmt::get_childIndex(SgNode *child) {
8933 0 : SgExpressionPtrList::iterator itr = find(p_operands.begin(), p_operands.end(), child);
8934 0 : if (itr != p_operands.end()) return itr - p_operands.begin();
8935 : else return (size_t) -1;
8936 : }
8937 : vector<SgNode*>
8938 2873 : SgAttributeSpecificationStatement::get_traversalSuccessorContainer() {
8939 2873 : vector<SgNode*> traversalSuccessorContainer;
8940 2873 : return traversalSuccessorContainer;
8941 : }
8942 : vector<string>
8943 1102 : SgAttributeSpecificationStatement::get_traversalSuccessorNamesContainer() {
8944 1102 : vector<string> traversalSuccessorContainer;
8945 1102 : return traversalSuccessorContainer;
8946 : }
8947 : size_t
8948 23755 : SgAttributeSpecificationStatement::get_numberOfTraversalSuccessors() {
8949 23755 : return 0;
8950 : }
8951 : SgNode *
8952 0 : SgAttributeSpecificationStatement::get_traversalSuccessorByIndex(size_t idx) {
8953 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgAttributeSpecificationStatement" << " that has no successors!" << endl;
8954 0 : ROSE_ASSERT(false);
8955 : return NULL;
8956 : }
8957 : size_t
8958 0 : SgAttributeSpecificationStatement::get_childIndex(SgNode *child) {
8959 0 : cout << "error: get_childIndex called on node of type " << "SgAttributeSpecificationStatement" << " that has no successors!" << endl;
8960 0 : ROSE_ASSERT(false);
8961 : return 0;
8962 : }
8963 : vector<SgNode*>
8964 0 : SgFormatStatement::get_traversalSuccessorContainer() {
8965 0 : vector<SgNode*> traversalSuccessorContainer;
8966 0 : return traversalSuccessorContainer;
8967 : }
8968 : vector<string>
8969 0 : SgFormatStatement::get_traversalSuccessorNamesContainer() {
8970 0 : vector<string> traversalSuccessorContainer;
8971 0 : return traversalSuccessorContainer;
8972 : }
8973 : size_t
8974 0 : SgFormatStatement::get_numberOfTraversalSuccessors() {
8975 0 : return 0;
8976 : }
8977 : SgNode *
8978 0 : SgFormatStatement::get_traversalSuccessorByIndex(size_t idx) {
8979 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgFormatStatement" << " that has no successors!" << endl;
8980 0 : ROSE_ASSERT(false);
8981 : return NULL;
8982 : }
8983 : size_t
8984 0 : SgFormatStatement::get_childIndex(SgNode *child) {
8985 0 : cout << "error: get_childIndex called on node of type " << "SgFormatStatement" << " that has no successors!" << endl;
8986 0 : ROSE_ASSERT(false);
8987 : return 0;
8988 : }
8989 : vector<SgNode*>
8990 0 : SgTemplateDeclaration::get_traversalSuccessorContainer() {
8991 0 : vector<SgNode*> traversalSuccessorContainer;
8992 0 : return traversalSuccessorContainer;
8993 : }
8994 : vector<string>
8995 0 : SgTemplateDeclaration::get_traversalSuccessorNamesContainer() {
8996 0 : vector<string> traversalSuccessorContainer;
8997 0 : return traversalSuccessorContainer;
8998 : }
8999 : size_t
9000 0 : SgTemplateDeclaration::get_numberOfTraversalSuccessors() {
9001 0 : return 0;
9002 : }
9003 : SgNode *
9004 0 : SgTemplateDeclaration::get_traversalSuccessorByIndex(size_t idx) {
9005 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgTemplateDeclaration" << " that has no successors!" << endl;
9006 0 : ROSE_ASSERT(false);
9007 : return NULL;
9008 : }
9009 : size_t
9010 0 : SgTemplateDeclaration::get_childIndex(SgNode *child) {
9011 0 : cout << "error: get_childIndex called on node of type " << "SgTemplateDeclaration" << " that has no successors!" << endl;
9012 0 : ROSE_ASSERT(false);
9013 : return 0;
9014 : }
9015 : vector<SgNode*>
9016 3866 : SgTemplateInstantiationDirectiveStatement::get_traversalSuccessorContainer() {
9017 3866 : vector<SgNode*> traversalSuccessorContainer;
9018 3866 : traversalSuccessorContainer.reserve(1);
9019 3866 : traversalSuccessorContainer.push_back(p_declaration);
9020 3866 : return traversalSuccessorContainer;
9021 : }
9022 : vector<string>
9023 1492 : SgTemplateInstantiationDirectiveStatement::get_traversalSuccessorNamesContainer() {
9024 1492 : vector<string> traversalSuccessorContainer;
9025 2984 : traversalSuccessorContainer.push_back("p_declaration");
9026 1492 : return traversalSuccessorContainer;
9027 : }
9028 : size_t
9029 39094 : SgTemplateInstantiationDirectiveStatement::get_numberOfTraversalSuccessors() {
9030 39094 : return 1;
9031 : }
9032 : SgNode *
9033 39092 : SgTemplateInstantiationDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
9034 39092 : switch (idx) {
9035 39092 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
9036 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9037 0 : ROSE_ASSERT(false);
9038 : return NULL;
9039 : }
9040 : }
9041 : size_t
9042 0 : SgTemplateInstantiationDirectiveStatement::get_childIndex(SgNode *child) {
9043 0 : if (child == p_declaration) return 0;
9044 0 : else return (size_t) -1;
9045 : }
9046 : vector<SgNode*>
9047 0 : SgUseStatement::get_traversalSuccessorContainer() {
9048 0 : vector<SgNode*> traversalSuccessorContainer;
9049 0 : traversalSuccessorContainer.reserve(p_rename_list.size() + 0);
9050 0 : {
9051 0 : SgRenamePairPtrList::iterator iter;
9052 0 : for (iter = p_rename_list.begin(); iter != p_rename_list.end(); iter++)
9053 0 : traversalSuccessorContainer.push_back(*iter);
9054 : }
9055 0 : return traversalSuccessorContainer;
9056 : }
9057 : vector<string>
9058 0 : SgUseStatement::get_traversalSuccessorNamesContainer() {
9059 0 : vector<string> traversalSuccessorContainer;
9060 0 : int i = 0;
9061 0 : {
9062 0 : SgRenamePairPtrList::iterator iter;
9063 0 : for (iter = p_rename_list.begin(); iter != p_rename_list.end(); (iter++,i++)) {
9064 0 : char buf[20];
9065 0 : sprintf(buf,"*[%d]",i);
9066 0 : traversalSuccessorContainer.push_back(buf);
9067 : }
9068 : }
9069 0 : return traversalSuccessorContainer;
9070 : }
9071 : size_t
9072 0 : SgUseStatement::get_numberOfTraversalSuccessors() {
9073 0 : return p_rename_list.size() + 0;
9074 : }
9075 : SgNode *
9076 0 : SgUseStatement::get_traversalSuccessorByIndex(size_t idx) {
9077 0 : ROSE_ASSERT(idx < p_rename_list.size());
9078 0 : return p_rename_list[idx];
9079 : }
9080 : size_t
9081 0 : SgUseStatement::get_childIndex(SgNode *child) {
9082 0 : SgRenamePairPtrList::iterator itr = find(p_rename_list.begin(), p_rename_list.end(), child);
9083 0 : if (itr != p_rename_list.end()) return itr - p_rename_list.begin();
9084 : else return (size_t) -1;
9085 : }
9086 : vector<SgNode*>
9087 0 : SgParameterStatement::get_traversalSuccessorContainer() {
9088 0 : vector<SgNode*> traversalSuccessorContainer;
9089 0 : return traversalSuccessorContainer;
9090 : }
9091 : vector<string>
9092 0 : SgParameterStatement::get_traversalSuccessorNamesContainer() {
9093 0 : vector<string> traversalSuccessorContainer;
9094 0 : return traversalSuccessorContainer;
9095 : }
9096 : size_t
9097 0 : SgParameterStatement::get_numberOfTraversalSuccessors() {
9098 0 : return 0;
9099 : }
9100 : SgNode *
9101 0 : SgParameterStatement::get_traversalSuccessorByIndex(size_t idx) {
9102 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgParameterStatement" << " that has no successors!" << endl;
9103 0 : ROSE_ASSERT(false);
9104 : return NULL;
9105 : }
9106 : size_t
9107 0 : SgParameterStatement::get_childIndex(SgNode *child) {
9108 0 : cout << "error: get_childIndex called on node of type " << "SgParameterStatement" << " that has no successors!" << endl;
9109 0 : ROSE_ASSERT(false);
9110 : return 0;
9111 : }
9112 : vector<SgNode*>
9113 35726 : SgNamespaceDeclarationStatement::get_traversalSuccessorContainer() {
9114 35726 : vector<SgNode*> traversalSuccessorContainer;
9115 35726 : traversalSuccessorContainer.reserve(1);
9116 35726 : traversalSuccessorContainer.push_back(p_definition);
9117 35726 : return traversalSuccessorContainer;
9118 : }
9119 : vector<string>
9120 1630 : SgNamespaceDeclarationStatement::get_traversalSuccessorNamesContainer() {
9121 1630 : vector<string> traversalSuccessorContainer;
9122 3260 : traversalSuccessorContainer.push_back("p_definition");
9123 1630 : return traversalSuccessorContainer;
9124 : }
9125 : size_t
9126 75403 : SgNamespaceDeclarationStatement::get_numberOfTraversalSuccessors() {
9127 75403 : return 1;
9128 : }
9129 : SgNode *
9130 75344 : SgNamespaceDeclarationStatement::get_traversalSuccessorByIndex(size_t idx) {
9131 75344 : switch (idx) {
9132 75344 : case 0: ROSE_ASSERT(p_definition == NULL || p_definition != NULL); return p_definition;
9133 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9134 0 : ROSE_ASSERT(false);
9135 : return NULL;
9136 : }
9137 : }
9138 : size_t
9139 0 : SgNamespaceDeclarationStatement::get_childIndex(SgNode *child) {
9140 0 : if (child == p_definition) return 0;
9141 0 : else return (size_t) -1;
9142 : }
9143 : vector<SgNode*>
9144 0 : SgEquivalenceStatement::get_traversalSuccessorContainer() {
9145 0 : vector<SgNode*> traversalSuccessorContainer;
9146 0 : return traversalSuccessorContainer;
9147 : }
9148 : vector<string>
9149 0 : SgEquivalenceStatement::get_traversalSuccessorNamesContainer() {
9150 0 : vector<string> traversalSuccessorContainer;
9151 0 : return traversalSuccessorContainer;
9152 : }
9153 : size_t
9154 0 : SgEquivalenceStatement::get_numberOfTraversalSuccessors() {
9155 0 : return 0;
9156 : }
9157 : SgNode *
9158 0 : SgEquivalenceStatement::get_traversalSuccessorByIndex(size_t idx) {
9159 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgEquivalenceStatement" << " that has no successors!" << endl;
9160 0 : ROSE_ASSERT(false);
9161 : return NULL;
9162 : }
9163 : size_t
9164 0 : SgEquivalenceStatement::get_childIndex(SgNode *child) {
9165 0 : cout << "error: get_childIndex called on node of type " << "SgEquivalenceStatement" << " that has no successors!" << endl;
9166 0 : ROSE_ASSERT(false);
9167 : return 0;
9168 : }
9169 : vector<SgNode*>
9170 0 : SgInterfaceStatement::get_traversalSuccessorContainer() {
9171 0 : vector<SgNode*> traversalSuccessorContainer;
9172 0 : traversalSuccessorContainer.reserve(p_interface_body_list.size() + 0);
9173 0 : {
9174 0 : SgInterfaceBodyPtrList::iterator iter;
9175 0 : for (iter = p_interface_body_list.begin(); iter != p_interface_body_list.end(); iter++)
9176 0 : traversalSuccessorContainer.push_back(*iter);
9177 : }
9178 0 : return traversalSuccessorContainer;
9179 : }
9180 : vector<string>
9181 0 : SgInterfaceStatement::get_traversalSuccessorNamesContainer() {
9182 0 : vector<string> traversalSuccessorContainer;
9183 0 : int i = 0;
9184 0 : {
9185 0 : SgInterfaceBodyPtrList::iterator iter;
9186 0 : for (iter = p_interface_body_list.begin(); iter != p_interface_body_list.end(); (iter++,i++)) {
9187 0 : char buf[20];
9188 0 : sprintf(buf,"*[%d]",i);
9189 0 : traversalSuccessorContainer.push_back(buf);
9190 : }
9191 : }
9192 0 : return traversalSuccessorContainer;
9193 : }
9194 : size_t
9195 0 : SgInterfaceStatement::get_numberOfTraversalSuccessors() {
9196 0 : return p_interface_body_list.size() + 0;
9197 : }
9198 : SgNode *
9199 0 : SgInterfaceStatement::get_traversalSuccessorByIndex(size_t idx) {
9200 0 : ROSE_ASSERT(idx < p_interface_body_list.size());
9201 0 : return p_interface_body_list[idx];
9202 : }
9203 : size_t
9204 0 : SgInterfaceStatement::get_childIndex(SgNode *child) {
9205 0 : SgInterfaceBodyPtrList::iterator itr = find(p_interface_body_list.begin(), p_interface_body_list.end(), child);
9206 0 : if (itr != p_interface_body_list.end()) return itr - p_interface_body_list.begin();
9207 : else return (size_t) -1;
9208 : }
9209 : vector<SgNode*>
9210 0 : SgNamespaceAliasDeclarationStatement::get_traversalSuccessorContainer() {
9211 0 : vector<SgNode*> traversalSuccessorContainer;
9212 0 : return traversalSuccessorContainer;
9213 : }
9214 : vector<string>
9215 0 : SgNamespaceAliasDeclarationStatement::get_traversalSuccessorNamesContainer() {
9216 0 : vector<string> traversalSuccessorContainer;
9217 0 : return traversalSuccessorContainer;
9218 : }
9219 : size_t
9220 0 : SgNamespaceAliasDeclarationStatement::get_numberOfTraversalSuccessors() {
9221 0 : return 0;
9222 : }
9223 : SgNode *
9224 0 : SgNamespaceAliasDeclarationStatement::get_traversalSuccessorByIndex(size_t idx) {
9225 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgNamespaceAliasDeclarationStatement" << " that has no successors!" << endl;
9226 0 : ROSE_ASSERT(false);
9227 : return NULL;
9228 : }
9229 : size_t
9230 0 : SgNamespaceAliasDeclarationStatement::get_childIndex(SgNode *child) {
9231 0 : cout << "error: get_childIndex called on node of type " << "SgNamespaceAliasDeclarationStatement" << " that has no successors!" << endl;
9232 0 : ROSE_ASSERT(false);
9233 : return 0;
9234 : }
9235 : vector<SgNode*>
9236 32 : SgCommonBlock::get_traversalSuccessorContainer() {
9237 32 : vector<SgNode*> traversalSuccessorContainer;
9238 32 : traversalSuccessorContainer.reserve(p_block_list.size() + 0);
9239 32 : {
9240 32 : SgCommonBlockObjectPtrList::iterator iter;
9241 64 : for (iter = p_block_list.begin(); iter != p_block_list.end(); iter++)
9242 32 : traversalSuccessorContainer.push_back(*iter);
9243 : }
9244 32 : return traversalSuccessorContainer;
9245 : }
9246 : vector<string>
9247 18 : SgCommonBlock::get_traversalSuccessorNamesContainer() {
9248 18 : vector<string> traversalSuccessorContainer;
9249 18 : int i = 0;
9250 18 : {
9251 18 : SgCommonBlockObjectPtrList::iterator iter;
9252 36 : for (iter = p_block_list.begin(); iter != p_block_list.end(); (iter++,i++)) {
9253 18 : char buf[20];
9254 18 : sprintf(buf,"*[%d]",i);
9255 36 : traversalSuccessorContainer.push_back(buf);
9256 : }
9257 : }
9258 18 : return traversalSuccessorContainer;
9259 : }
9260 : size_t
9261 233 : SgCommonBlock::get_numberOfTraversalSuccessors() {
9262 233 : return p_block_list.size() + 0;
9263 : }
9264 : SgNode *
9265 233 : SgCommonBlock::get_traversalSuccessorByIndex(size_t idx) {
9266 233 : ROSE_ASSERT(idx < p_block_list.size());
9267 233 : return p_block_list[idx];
9268 : }
9269 : size_t
9270 0 : SgCommonBlock::get_childIndex(SgNode *child) {
9271 0 : SgCommonBlockObjectPtrList::iterator itr = find(p_block_list.begin(), p_block_list.end(), child);
9272 0 : if (itr != p_block_list.end()) return itr - p_block_list.begin();
9273 : else return (size_t) -1;
9274 : }
9275 : vector<SgNode*>
9276 702466 : SgTypedefDeclaration::get_traversalSuccessorContainer() {
9277 702466 : vector<SgNode*> traversalSuccessorContainer;
9278 702466 : traversalSuccessorContainer.reserve(1);
9279 702466 : traversalSuccessorContainer.push_back(compute_baseTypeDefiningDeclaration());
9280 702466 : return traversalSuccessorContainer;
9281 : }
9282 : vector<string>
9283 98814 : SgTypedefDeclaration::get_traversalSuccessorNamesContainer() {
9284 98814 : vector<string> traversalSuccessorContainer;
9285 197628 : traversalSuccessorContainer.push_back("p_declaration");
9286 98814 : return traversalSuccessorContainer;
9287 : }
9288 : size_t
9289 2555270 : SgTypedefDeclaration::get_numberOfTraversalSuccessors() {
9290 2555270 : return 1;
9291 : }
9292 : SgNode *
9293 2554330 : SgTypedefDeclaration::get_traversalSuccessorByIndex(size_t idx) {
9294 2554330 : switch (idx) {
9295 2554330 : case 0: return compute_baseTypeDefiningDeclaration();
9296 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9297 0 : ROSE_ASSERT(false);
9298 : return NULL;
9299 : }
9300 : }
9301 : size_t
9302 0 : SgTypedefDeclaration::get_childIndex(SgNode *child) {
9303 0 : if (child == compute_baseTypeDefiningDeclaration()) return 0;
9304 0 : else if (child == p_declaration) return 1;
9305 0 : else return (size_t) -1;
9306 : }
9307 : vector<SgNode*>
9308 39457 : SgTemplateTypedefDeclaration::get_traversalSuccessorContainer() {
9309 39457 : vector<SgNode*> traversalSuccessorContainer;
9310 39457 : traversalSuccessorContainer.reserve(1);
9311 39457 : traversalSuccessorContainer.push_back(p_declaration);
9312 39457 : return traversalSuccessorContainer;
9313 : }
9314 : vector<string>
9315 1224 : SgTemplateTypedefDeclaration::get_traversalSuccessorNamesContainer() {
9316 1224 : vector<string> traversalSuccessorContainer;
9317 2448 : traversalSuccessorContainer.push_back("p_declaration");
9318 1224 : return traversalSuccessorContainer;
9319 : }
9320 : size_t
9321 70033 : SgTemplateTypedefDeclaration::get_numberOfTraversalSuccessors() {
9322 70033 : return 1;
9323 : }
9324 : SgNode *
9325 69967 : SgTemplateTypedefDeclaration::get_traversalSuccessorByIndex(size_t idx) {
9326 69967 : switch (idx) {
9327 69967 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
9328 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9329 0 : ROSE_ASSERT(false);
9330 : return NULL;
9331 : }
9332 : }
9333 : size_t
9334 0 : SgTemplateTypedefDeclaration::get_childIndex(SgNode *child) {
9335 0 : if (child == p_declaration) return 0;
9336 0 : else return (size_t) -1;
9337 : }
9338 : vector<SgNode*>
9339 0 : SgTemplateInstantiationTypedefDeclaration::get_traversalSuccessorContainer() {
9340 0 : vector<SgNode*> traversalSuccessorContainer;
9341 0 : traversalSuccessorContainer.reserve(1);
9342 0 : traversalSuccessorContainer.push_back(p_declaration);
9343 0 : return traversalSuccessorContainer;
9344 : }
9345 : vector<string>
9346 0 : SgTemplateInstantiationTypedefDeclaration::get_traversalSuccessorNamesContainer() {
9347 0 : vector<string> traversalSuccessorContainer;
9348 0 : traversalSuccessorContainer.push_back("p_declaration");
9349 0 : return traversalSuccessorContainer;
9350 : }
9351 : size_t
9352 0 : SgTemplateInstantiationTypedefDeclaration::get_numberOfTraversalSuccessors() {
9353 0 : return 1;
9354 : }
9355 : SgNode *
9356 0 : SgTemplateInstantiationTypedefDeclaration::get_traversalSuccessorByIndex(size_t idx) {
9357 0 : switch (idx) {
9358 0 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
9359 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9360 0 : ROSE_ASSERT(false);
9361 : return NULL;
9362 : }
9363 : }
9364 : size_t
9365 0 : SgTemplateInstantiationTypedefDeclaration::get_childIndex(SgNode *child) {
9366 0 : if (child == p_declaration) return 0;
9367 0 : else return (size_t) -1;
9368 : }
9369 : vector<SgNode*>
9370 0 : SgStatementFunctionStatement::get_traversalSuccessorContainer() {
9371 0 : vector<SgNode*> traversalSuccessorContainer;
9372 0 : traversalSuccessorContainer.reserve(2);
9373 0 : traversalSuccessorContainer.push_back(p_function);
9374 0 : traversalSuccessorContainer.push_back(p_expression);
9375 0 : return traversalSuccessorContainer;
9376 : }
9377 : vector<string>
9378 0 : SgStatementFunctionStatement::get_traversalSuccessorNamesContainer() {
9379 0 : vector<string> traversalSuccessorContainer;
9380 0 : traversalSuccessorContainer.push_back("p_function");
9381 0 : traversalSuccessorContainer.push_back("p_expression");
9382 0 : return traversalSuccessorContainer;
9383 : }
9384 : size_t
9385 0 : SgStatementFunctionStatement::get_numberOfTraversalSuccessors() {
9386 0 : return 2;
9387 : }
9388 : SgNode *
9389 0 : SgStatementFunctionStatement::get_traversalSuccessorByIndex(size_t idx) {
9390 0 : switch (idx) {
9391 0 : case 0: ROSE_ASSERT(p_function == NULL || p_function != NULL); return p_function;
9392 0 : case 1: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
9393 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9394 0 : ROSE_ASSERT(false);
9395 : return NULL;
9396 : }
9397 : }
9398 : size_t
9399 0 : SgStatementFunctionStatement::get_childIndex(SgNode *child) {
9400 0 : if (child == p_function) return 0;
9401 0 : else if (child == p_expression) return 1;
9402 0 : else return (size_t) -1;
9403 : }
9404 : vector<SgNode*>
9405 889037 : SgCtorInitializerList::get_traversalSuccessorContainer() {
9406 889037 : vector<SgNode*> traversalSuccessorContainer;
9407 889037 : traversalSuccessorContainer.reserve(p_ctors.size() + 0);
9408 889037 : {
9409 889037 : SgInitializedNamePtrList::iterator iter;
9410 971969 : for (iter = p_ctors.begin(); iter != p_ctors.end(); iter++)
9411 82932 : traversalSuccessorContainer.push_back(*iter);
9412 : }
9413 889037 : return traversalSuccessorContainer;
9414 : }
9415 : vector<string>
9416 50103 : SgCtorInitializerList::get_traversalSuccessorNamesContainer() {
9417 50103 : vector<string> traversalSuccessorContainer;
9418 50103 : int i = 0;
9419 50103 : {
9420 50103 : SgInitializedNamePtrList::iterator iter;
9421 55188 : for (iter = p_ctors.begin(); iter != p_ctors.end(); (iter++,i++)) {
9422 5085 : char buf[20];
9423 5085 : sprintf(buf,"*[%d]",i);
9424 10170 : traversalSuccessorContainer.push_back(buf);
9425 : }
9426 : }
9427 50103 : return traversalSuccessorContainer;
9428 : }
9429 : size_t
9430 2171830 : SgCtorInitializerList::get_numberOfTraversalSuccessors() {
9431 2171830 : return p_ctors.size() + 0;
9432 : }
9433 : SgNode *
9434 169042 : SgCtorInitializerList::get_traversalSuccessorByIndex(size_t idx) {
9435 169042 : ROSE_ASSERT(idx < p_ctors.size());
9436 169042 : return p_ctors[idx];
9437 : }
9438 : size_t
9439 0 : SgCtorInitializerList::get_childIndex(SgNode *child) {
9440 0 : SgInitializedNamePtrList::iterator itr = find(p_ctors.begin(), p_ctors.end(), child);
9441 0 : if (itr != p_ctors.end()) return itr - p_ctors.begin();
9442 : else return (size_t) -1;
9443 : }
9444 : vector<SgNode*>
9445 28584 : SgPragmaDeclaration::get_traversalSuccessorContainer() {
9446 28584 : vector<SgNode*> traversalSuccessorContainer;
9447 28584 : traversalSuccessorContainer.reserve(1);
9448 28584 : traversalSuccessorContainer.push_back(p_pragma);
9449 28584 : return traversalSuccessorContainer;
9450 : }
9451 : vector<string>
9452 1276 : SgPragmaDeclaration::get_traversalSuccessorNamesContainer() {
9453 1276 : vector<string> traversalSuccessorContainer;
9454 2552 : traversalSuccessorContainer.push_back("p_pragma");
9455 1276 : return traversalSuccessorContainer;
9456 : }
9457 : size_t
9458 77181 : SgPragmaDeclaration::get_numberOfTraversalSuccessors() {
9459 77181 : return 1;
9460 : }
9461 : SgNode *
9462 77136 : SgPragmaDeclaration::get_traversalSuccessorByIndex(size_t idx) {
9463 77136 : switch (idx) {
9464 77136 : case 0: ROSE_ASSERT(p_pragma == NULL || p_pragma != NULL); return p_pragma;
9465 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9466 0 : ROSE_ASSERT(false);
9467 : return NULL;
9468 : }
9469 : }
9470 : size_t
9471 0 : SgPragmaDeclaration::get_childIndex(SgNode *child) {
9472 0 : if (child == p_pragma) return 0;
9473 0 : else return (size_t) -1;
9474 : }
9475 : vector<SgNode*>
9476 598 : SgUsingDirectiveStatement::get_traversalSuccessorContainer() {
9477 598 : vector<SgNode*> traversalSuccessorContainer;
9478 598 : return traversalSuccessorContainer;
9479 : }
9480 : vector<string>
9481 24 : SgUsingDirectiveStatement::get_traversalSuccessorNamesContainer() {
9482 24 : vector<string> traversalSuccessorContainer;
9483 24 : return traversalSuccessorContainer;
9484 : }
9485 : size_t
9486 1169 : SgUsingDirectiveStatement::get_numberOfTraversalSuccessors() {
9487 1169 : return 0;
9488 : }
9489 : SgNode *
9490 0 : SgUsingDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
9491 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUsingDirectiveStatement" << " that has no successors!" << endl;
9492 0 : ROSE_ASSERT(false);
9493 : return NULL;
9494 : }
9495 : size_t
9496 0 : SgUsingDirectiveStatement::get_childIndex(SgNode *child) {
9497 0 : cout << "error: get_childIndex called on node of type " << "SgUsingDirectiveStatement" << " that has no successors!" << endl;
9498 0 : ROSE_ASSERT(false);
9499 : return 0;
9500 : }
9501 : vector<SgNode*>
9502 82059 : SgClassDeclaration::get_traversalSuccessorContainer() {
9503 82059 : vector<SgNode*> traversalSuccessorContainer;
9504 82059 : traversalSuccessorContainer.reserve(2);
9505 82059 : traversalSuccessorContainer.push_back(compute_classDefinition());
9506 82059 : traversalSuccessorContainer.push_back(p_decoratorList);
9507 82059 : return traversalSuccessorContainer;
9508 : }
9509 : vector<string>
9510 14974 : SgClassDeclaration::get_traversalSuccessorNamesContainer() {
9511 14974 : vector<string> traversalSuccessorContainer;
9512 29948 : traversalSuccessorContainer.push_back("p_definition");
9513 29948 : traversalSuccessorContainer.push_back("p_decoratorList");
9514 14974 : return traversalSuccessorContainer;
9515 : }
9516 : size_t
9517 379897 : SgClassDeclaration::get_numberOfTraversalSuccessors() {
9518 379897 : return 2;
9519 : }
9520 : SgNode *
9521 759192 : SgClassDeclaration::get_traversalSuccessorByIndex(size_t idx) {
9522 759192 : switch (idx) {
9523 379687 : case 0: return compute_classDefinition();
9524 379505 : case 1: ROSE_ASSERT(p_decoratorList == NULL || p_decoratorList != NULL); return p_decoratorList;
9525 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9526 0 : ROSE_ASSERT(false);
9527 : return NULL;
9528 : }
9529 : }
9530 : size_t
9531 0 : SgClassDeclaration::get_childIndex(SgNode *child) {
9532 0 : if (child == compute_classDefinition()) return 0;
9533 0 : else if (child == p_decoratorList) return 1;
9534 0 : else return (size_t) -1;
9535 : }
9536 : vector<SgNode*>
9537 286303 : SgTemplateClassDeclaration::get_traversalSuccessorContainer() {
9538 286303 : vector<SgNode*> traversalSuccessorContainer;
9539 286303 : traversalSuccessorContainer.reserve(2);
9540 286303 : traversalSuccessorContainer.push_back(p_definition);
9541 286303 : traversalSuccessorContainer.push_back(p_decoratorList);
9542 286303 : return traversalSuccessorContainer;
9543 : }
9544 : vector<string>
9545 8532 : SgTemplateClassDeclaration::get_traversalSuccessorNamesContainer() {
9546 8532 : vector<string> traversalSuccessorContainer;
9547 17064 : traversalSuccessorContainer.push_back("p_definition");
9548 17064 : traversalSuccessorContainer.push_back("p_decoratorList");
9549 8532 : return traversalSuccessorContainer;
9550 : }
9551 : size_t
9552 500699 : SgTemplateClassDeclaration::get_numberOfTraversalSuccessors() {
9553 500699 : return 2;
9554 : }
9555 : SgNode *
9556 998634 : SgTemplateClassDeclaration::get_traversalSuccessorByIndex(size_t idx) {
9557 998634 : switch (idx) {
9558 499741 : case 0: ROSE_ASSERT(p_definition == NULL || p_definition != NULL); return p_definition;
9559 498893 : case 1: ROSE_ASSERT(p_decoratorList == NULL || p_decoratorList != NULL); return p_decoratorList;
9560 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9561 0 : ROSE_ASSERT(false);
9562 : return NULL;
9563 : }
9564 : }
9565 : size_t
9566 0 : SgTemplateClassDeclaration::get_childIndex(SgNode *child) {
9567 0 : if (child == p_definition) return 0;
9568 0 : else if (child == p_decoratorList) return 1;
9569 0 : else return (size_t) -1;
9570 : }
9571 : vector<SgNode*>
9572 244061 : SgTemplateInstantiationDecl::get_traversalSuccessorContainer() {
9573 244061 : vector<SgNode*> traversalSuccessorContainer;
9574 244061 : traversalSuccessorContainer.reserve(2);
9575 244061 : traversalSuccessorContainer.push_back(compute_classDefinition());
9576 244061 : traversalSuccessorContainer.push_back(p_decoratorList);
9577 244061 : return traversalSuccessorContainer;
9578 : }
9579 : vector<string>
9580 11674 : SgTemplateInstantiationDecl::get_traversalSuccessorNamesContainer() {
9581 11674 : vector<string> traversalSuccessorContainer;
9582 23348 : traversalSuccessorContainer.push_back("p_definition");
9583 23348 : traversalSuccessorContainer.push_back("p_decoratorList");
9584 11674 : return traversalSuccessorContainer;
9585 : }
9586 : size_t
9587 545786 : SgTemplateInstantiationDecl::get_numberOfTraversalSuccessors() {
9588 545786 : return 2;
9589 : }
9590 : SgNode *
9591 1089420 : SgTemplateInstantiationDecl::get_traversalSuccessorByIndex(size_t idx) {
9592 1089420 : switch (idx) {
9593 544996 : case 0: return compute_classDefinition();
9594 544420 : case 1: ROSE_ASSERT(p_decoratorList == NULL || p_decoratorList != NULL); return p_decoratorList;
9595 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9596 0 : ROSE_ASSERT(false);
9597 : return NULL;
9598 : }
9599 : }
9600 : size_t
9601 0 : SgTemplateInstantiationDecl::get_childIndex(SgNode *child) {
9602 0 : if (child == compute_classDefinition()) return 0;
9603 0 : else if (child == p_decoratorList) return 1;
9604 0 : else return (size_t) -1;
9605 : }
9606 : vector<SgNode*>
9607 0 : SgDerivedTypeStatement::get_traversalSuccessorContainer() {
9608 0 : vector<SgNode*> traversalSuccessorContainer;
9609 0 : traversalSuccessorContainer.reserve(2);
9610 0 : traversalSuccessorContainer.push_back(p_definition);
9611 0 : traversalSuccessorContainer.push_back(p_decoratorList);
9612 0 : return traversalSuccessorContainer;
9613 : }
9614 : vector<string>
9615 0 : SgDerivedTypeStatement::get_traversalSuccessorNamesContainer() {
9616 0 : vector<string> traversalSuccessorContainer;
9617 0 : traversalSuccessorContainer.push_back("p_definition");
9618 0 : traversalSuccessorContainer.push_back("p_decoratorList");
9619 0 : return traversalSuccessorContainer;
9620 : }
9621 : size_t
9622 0 : SgDerivedTypeStatement::get_numberOfTraversalSuccessors() {
9623 0 : return 2;
9624 : }
9625 : SgNode *
9626 0 : SgDerivedTypeStatement::get_traversalSuccessorByIndex(size_t idx) {
9627 0 : switch (idx) {
9628 0 : case 0: ROSE_ASSERT(p_definition == NULL || p_definition != NULL); return p_definition;
9629 0 : case 1: ROSE_ASSERT(p_decoratorList == NULL || p_decoratorList != NULL); return p_decoratorList;
9630 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9631 0 : ROSE_ASSERT(false);
9632 : return NULL;
9633 : }
9634 : }
9635 : size_t
9636 0 : SgDerivedTypeStatement::get_childIndex(SgNode *child) {
9637 0 : if (child == p_definition) return 0;
9638 0 : else if (child == p_decoratorList) return 1;
9639 0 : else return (size_t) -1;
9640 : }
9641 : vector<SgNode*>
9642 0 : SgModuleStatement::get_traversalSuccessorContainer() {
9643 0 : vector<SgNode*> traversalSuccessorContainer;
9644 0 : traversalSuccessorContainer.reserve(2);
9645 0 : traversalSuccessorContainer.push_back(p_definition);
9646 0 : traversalSuccessorContainer.push_back(p_decoratorList);
9647 0 : return traversalSuccessorContainer;
9648 : }
9649 : vector<string>
9650 0 : SgModuleStatement::get_traversalSuccessorNamesContainer() {
9651 0 : vector<string> traversalSuccessorContainer;
9652 0 : traversalSuccessorContainer.push_back("p_definition");
9653 0 : traversalSuccessorContainer.push_back("p_decoratorList");
9654 0 : return traversalSuccessorContainer;
9655 : }
9656 : size_t
9657 0 : SgModuleStatement::get_numberOfTraversalSuccessors() {
9658 0 : return 2;
9659 : }
9660 : SgNode *
9661 0 : SgModuleStatement::get_traversalSuccessorByIndex(size_t idx) {
9662 0 : switch (idx) {
9663 0 : case 0: ROSE_ASSERT(p_definition == NULL || p_definition != NULL); return p_definition;
9664 0 : case 1: ROSE_ASSERT(p_decoratorList == NULL || p_decoratorList != NULL); return p_decoratorList;
9665 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9666 0 : ROSE_ASSERT(false);
9667 : return NULL;
9668 : }
9669 : }
9670 : size_t
9671 0 : SgModuleStatement::get_childIndex(SgNode *child) {
9672 0 : if (child == p_definition) return 0;
9673 0 : else if (child == p_decoratorList) return 1;
9674 0 : else return (size_t) -1;
9675 : }
9676 : vector<SgNode*>
9677 30 : SgImplicitStatement::get_traversalSuccessorContainer() {
9678 30 : vector<SgNode*> traversalSuccessorContainer;
9679 30 : traversalSuccessorContainer.reserve(p_variables.size() + 0);
9680 30 : {
9681 30 : SgInitializedNamePtrList::iterator iter;
9682 30 : for (iter = p_variables.begin(); iter != p_variables.end(); iter++)
9683 0 : traversalSuccessorContainer.push_back(*iter);
9684 : }
9685 30 : return traversalSuccessorContainer;
9686 : }
9687 : vector<string>
9688 12 : SgImplicitStatement::get_traversalSuccessorNamesContainer() {
9689 12 : vector<string> traversalSuccessorContainer;
9690 12 : int i = 0;
9691 12 : {
9692 12 : SgInitializedNamePtrList::iterator iter;
9693 12 : for (iter = p_variables.begin(); iter != p_variables.end(); (iter++,i++)) {
9694 0 : char buf[20];
9695 0 : sprintf(buf,"*[%d]",i);
9696 0 : traversalSuccessorContainer.push_back(buf);
9697 : }
9698 : }
9699 12 : return traversalSuccessorContainer;
9700 : }
9701 : size_t
9702 258 : SgImplicitStatement::get_numberOfTraversalSuccessors() {
9703 258 : return p_variables.size() + 0;
9704 : }
9705 : SgNode *
9706 0 : SgImplicitStatement::get_traversalSuccessorByIndex(size_t idx) {
9707 0 : ROSE_ASSERT(idx < p_variables.size());
9708 0 : return p_variables[idx];
9709 : }
9710 : size_t
9711 0 : SgImplicitStatement::get_childIndex(SgNode *child) {
9712 0 : SgInitializedNamePtrList::iterator itr = find(p_variables.begin(), p_variables.end(), child);
9713 0 : if (itr != p_variables.end()) return itr - p_variables.begin();
9714 : else return (size_t) -1;
9715 : }
9716 : vector<SgNode*>
9717 170039 : SgUsingDeclarationStatement::get_traversalSuccessorContainer() {
9718 170039 : vector<SgNode*> traversalSuccessorContainer;
9719 170039 : return traversalSuccessorContainer;
9720 : }
9721 : vector<string>
9722 4480 : SgUsingDeclarationStatement::get_traversalSuccessorNamesContainer() {
9723 4480 : vector<string> traversalSuccessorContainer;
9724 4480 : return traversalSuccessorContainer;
9725 : }
9726 : size_t
9727 277476 : SgUsingDeclarationStatement::get_numberOfTraversalSuccessors() {
9728 277476 : return 0;
9729 : }
9730 : SgNode *
9731 0 : SgUsingDeclarationStatement::get_traversalSuccessorByIndex(size_t idx) {
9732 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUsingDeclarationStatement" << " that has no successors!" << endl;
9733 0 : ROSE_ASSERT(false);
9734 : return NULL;
9735 : }
9736 : size_t
9737 0 : SgUsingDeclarationStatement::get_childIndex(SgNode *child) {
9738 0 : cout << "error: get_childIndex called on node of type " << "SgUsingDeclarationStatement" << " that has no successors!" << endl;
9739 0 : ROSE_ASSERT(false);
9740 : return 0;
9741 : }
9742 : vector<SgNode*>
9743 0 : SgNamelistStatement::get_traversalSuccessorContainer() {
9744 0 : vector<SgNode*> traversalSuccessorContainer;
9745 0 : return traversalSuccessorContainer;
9746 : }
9747 : vector<string>
9748 0 : SgNamelistStatement::get_traversalSuccessorNamesContainer() {
9749 0 : vector<string> traversalSuccessorContainer;
9750 0 : return traversalSuccessorContainer;
9751 : }
9752 : size_t
9753 0 : SgNamelistStatement::get_numberOfTraversalSuccessors() {
9754 0 : return 0;
9755 : }
9756 : SgNode *
9757 0 : SgNamelistStatement::get_traversalSuccessorByIndex(size_t idx) {
9758 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgNamelistStatement" << " that has no successors!" << endl;
9759 0 : ROSE_ASSERT(false);
9760 : return NULL;
9761 : }
9762 : size_t
9763 0 : SgNamelistStatement::get_childIndex(SgNode *child) {
9764 0 : cout << "error: get_childIndex called on node of type " << "SgNamelistStatement" << " that has no successors!" << endl;
9765 0 : ROSE_ASSERT(false);
9766 : return 0;
9767 : }
9768 : vector<SgNode*>
9769 0 : SgImportStatement::get_traversalSuccessorContainer() {
9770 0 : vector<SgNode*> traversalSuccessorContainer;
9771 0 : return traversalSuccessorContainer;
9772 : }
9773 : vector<string>
9774 0 : SgImportStatement::get_traversalSuccessorNamesContainer() {
9775 0 : vector<string> traversalSuccessorContainer;
9776 0 : return traversalSuccessorContainer;
9777 : }
9778 : size_t
9779 0 : SgImportStatement::get_numberOfTraversalSuccessors() {
9780 0 : return 0;
9781 : }
9782 : SgNode *
9783 0 : SgImportStatement::get_traversalSuccessorByIndex(size_t idx) {
9784 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgImportStatement" << " that has no successors!" << endl;
9785 0 : ROSE_ASSERT(false);
9786 : return NULL;
9787 : }
9788 : size_t
9789 0 : SgImportStatement::get_childIndex(SgNode *child) {
9790 0 : cout << "error: get_childIndex called on node of type " << "SgImportStatement" << " that has no successors!" << endl;
9791 0 : ROSE_ASSERT(false);
9792 : return 0;
9793 : }
9794 : vector<SgNode*>
9795 7728290 : SgFunctionDeclaration::get_traversalSuccessorContainer() {
9796 7728290 : vector<SgNode*> traversalSuccessorContainer;
9797 7728290 : traversalSuccessorContainer.reserve(3);
9798 7728290 : traversalSuccessorContainer.push_back(p_parameterList);
9799 7728290 : traversalSuccessorContainer.push_back(p_decoratorList);
9800 7728290 : traversalSuccessorContainer.push_back(p_definition);
9801 7728290 : return traversalSuccessorContainer;
9802 : }
9803 : vector<string>
9804 2097890 : SgFunctionDeclaration::get_traversalSuccessorNamesContainer() {
9805 2097890 : vector<string> traversalSuccessorContainer;
9806 4195780 : traversalSuccessorContainer.push_back("p_parameterList");
9807 4195780 : traversalSuccessorContainer.push_back("p_decoratorList");
9808 4195780 : traversalSuccessorContainer.push_back("p_definition");
9809 2097890 : return traversalSuccessorContainer;
9810 : }
9811 : size_t
9812 46160300 : SgFunctionDeclaration::get_numberOfTraversalSuccessors() {
9813 46160300 : return 3;
9814 : }
9815 : SgNode *
9816 138410000 : SgFunctionDeclaration::get_traversalSuccessorByIndex(size_t idx) {
9817 138410000 : switch (idx) {
9818 46143600 : case 0: ROSE_ASSERT(p_parameterList == NULL || p_parameterList != NULL); return p_parameterList;
9819 46132800 : case 1: ROSE_ASSERT(p_decoratorList == NULL || p_decoratorList != NULL); return p_decoratorList;
9820 46133200 : case 2: ROSE_ASSERT(p_definition == NULL || p_definition != NULL); return p_definition;
9821 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9822 0 : ROSE_ASSERT(false);
9823 : return NULL;
9824 : }
9825 : }
9826 : size_t
9827 0 : SgFunctionDeclaration::get_childIndex(SgNode *child) {
9828 0 : if (child == p_parameterList) return 0;
9829 0 : else if (child == p_decoratorList) return 1;
9830 0 : else if (child == p_definition) return 2;
9831 0 : else return (size_t) -1;
9832 : }
9833 : vector<SgNode*>
9834 222869 : SgTemplateFunctionDeclaration::get_traversalSuccessorContainer() {
9835 222869 : vector<SgNode*> traversalSuccessorContainer;
9836 222869 : traversalSuccessorContainer.reserve(3);
9837 222869 : traversalSuccessorContainer.push_back(p_parameterList);
9838 222869 : traversalSuccessorContainer.push_back(p_decoratorList);
9839 222869 : traversalSuccessorContainer.push_back(p_definition);
9840 222869 : return traversalSuccessorContainer;
9841 : }
9842 : vector<string>
9843 5344 : SgTemplateFunctionDeclaration::get_traversalSuccessorNamesContainer() {
9844 5344 : vector<string> traversalSuccessorContainer;
9845 10688 : traversalSuccessorContainer.push_back("p_parameterList");
9846 10688 : traversalSuccessorContainer.push_back("p_decoratorList");
9847 10688 : traversalSuccessorContainer.push_back("p_definition");
9848 5344 : return traversalSuccessorContainer;
9849 : }
9850 : size_t
9851 365574 : SgTemplateFunctionDeclaration::get_numberOfTraversalSuccessors() {
9852 365574 : return 3;
9853 : }
9854 : SgNode *
9855 1091140 : SgTemplateFunctionDeclaration::get_traversalSuccessorByIndex(size_t idx) {
9856 1091140 : switch (idx) {
9857 363946 : case 0: ROSE_ASSERT(p_parameterList == NULL || p_parameterList != NULL); return p_parameterList;
9858 363282 : case 1: ROSE_ASSERT(p_decoratorList == NULL || p_decoratorList != NULL); return p_decoratorList;
9859 363914 : case 2: ROSE_ASSERT(p_definition == NULL || p_definition != NULL); return p_definition;
9860 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9861 0 : ROSE_ASSERT(false);
9862 : return NULL;
9863 : }
9864 : }
9865 : size_t
9866 0 : SgTemplateFunctionDeclaration::get_childIndex(SgNode *child) {
9867 0 : if (child == p_parameterList) return 0;
9868 0 : else if (child == p_decoratorList) return 1;
9869 0 : else if (child == p_definition) return 2;
9870 0 : else return (size_t) -1;
9871 : }
9872 : vector<SgNode*>
9873 98846 : SgMemberFunctionDeclaration::get_traversalSuccessorContainer() {
9874 98846 : vector<SgNode*> traversalSuccessorContainer;
9875 98846 : traversalSuccessorContainer.reserve(4);
9876 98846 : traversalSuccessorContainer.push_back(p_parameterList);
9877 98846 : traversalSuccessorContainer.push_back(p_decoratorList);
9878 98846 : traversalSuccessorContainer.push_back(p_definition);
9879 98846 : traversalSuccessorContainer.push_back(p_CtorInitializerList);
9880 98846 : return traversalSuccessorContainer;
9881 : }
9882 : vector<string>
9883 6214 : SgMemberFunctionDeclaration::get_traversalSuccessorNamesContainer() {
9884 6214 : vector<string> traversalSuccessorContainer;
9885 12428 : traversalSuccessorContainer.push_back("p_parameterList");
9886 12428 : traversalSuccessorContainer.push_back("p_decoratorList");
9887 12428 : traversalSuccessorContainer.push_back("p_definition");
9888 12428 : traversalSuccessorContainer.push_back("p_CtorInitializerList");
9889 6214 : return traversalSuccessorContainer;
9890 : }
9891 : size_t
9892 259836 : SgMemberFunctionDeclaration::get_numberOfTraversalSuccessors() {
9893 259836 : return 4;
9894 : }
9895 : SgNode *
9896 1034750 : SgMemberFunctionDeclaration::get_traversalSuccessorByIndex(size_t idx) {
9897 1034750 : switch (idx) {
9898 258776 : case 0: ROSE_ASSERT(p_parameterList == NULL || p_parameterList != NULL); return p_parameterList;
9899 258494 : case 1: ROSE_ASSERT(p_decoratorList == NULL || p_decoratorList != NULL); return p_decoratorList;
9900 258708 : case 2: ROSE_ASSERT(p_definition == NULL || p_definition != NULL); return p_definition;
9901 258776 : case 3: ROSE_ASSERT(p_CtorInitializerList == NULL || p_CtorInitializerList != NULL); return p_CtorInitializerList;
9902 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9903 0 : ROSE_ASSERT(false);
9904 : return NULL;
9905 : }
9906 : }
9907 : size_t
9908 0 : SgMemberFunctionDeclaration::get_childIndex(SgNode *child) {
9909 0 : if (child == p_parameterList) return 0;
9910 0 : else if (child == p_decoratorList) return 1;
9911 0 : else if (child == p_definition) return 2;
9912 0 : else if (child == p_CtorInitializerList) return 3;
9913 0 : else return (size_t) -1;
9914 : }
9915 : vector<SgNode*>
9916 580599 : SgTemplateMemberFunctionDeclaration::get_traversalSuccessorContainer() {
9917 580599 : vector<SgNode*> traversalSuccessorContainer;
9918 580599 : traversalSuccessorContainer.reserve(4);
9919 580599 : traversalSuccessorContainer.push_back(p_parameterList);
9920 580599 : traversalSuccessorContainer.push_back(p_decoratorList);
9921 580599 : traversalSuccessorContainer.push_back(p_definition);
9922 580599 : traversalSuccessorContainer.push_back(p_CtorInitializerList);
9923 580599 : return traversalSuccessorContainer;
9924 : }
9925 : vector<string>
9926 22168 : SgTemplateMemberFunctionDeclaration::get_traversalSuccessorNamesContainer() {
9927 22168 : vector<string> traversalSuccessorContainer;
9928 44336 : traversalSuccessorContainer.push_back("p_parameterList");
9929 44336 : traversalSuccessorContainer.push_back("p_decoratorList");
9930 44336 : traversalSuccessorContainer.push_back("p_definition");
9931 44336 : traversalSuccessorContainer.push_back("p_CtorInitializerList");
9932 22168 : return traversalSuccessorContainer;
9933 : }
9934 : size_t
9935 1159440 : SgTemplateMemberFunctionDeclaration::get_numberOfTraversalSuccessors() {
9936 1159440 : return 4;
9937 : }
9938 : SgNode *
9939 4609720 : SgTemplateMemberFunctionDeclaration::get_traversalSuccessorByIndex(size_t idx) {
9940 4609720 : switch (idx) {
9941 1153090 : case 0: ROSE_ASSERT(p_parameterList == NULL || p_parameterList != NULL); return p_parameterList;
9942 1151290 : case 1: ROSE_ASSERT(p_decoratorList == NULL || p_decoratorList != NULL); return p_decoratorList;
9943 1152240 : case 2: ROSE_ASSERT(p_definition == NULL || p_definition != NULL); return p_definition;
9944 1153090 : case 3: ROSE_ASSERT(p_CtorInitializerList == NULL || p_CtorInitializerList != NULL); return p_CtorInitializerList;
9945 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9946 0 : ROSE_ASSERT(false);
9947 : return NULL;
9948 : }
9949 : }
9950 : size_t
9951 0 : SgTemplateMemberFunctionDeclaration::get_childIndex(SgNode *child) {
9952 0 : if (child == p_parameterList) return 0;
9953 0 : else if (child == p_decoratorList) return 1;
9954 0 : else if (child == p_definition) return 2;
9955 0 : else if (child == p_CtorInitializerList) return 3;
9956 0 : else return (size_t) -1;
9957 : }
9958 : vector<SgNode*>
9959 209592 : SgTemplateInstantiationMemberFunctionDecl::get_traversalSuccessorContainer() {
9960 209592 : vector<SgNode*> traversalSuccessorContainer;
9961 209592 : traversalSuccessorContainer.reserve(4);
9962 209592 : traversalSuccessorContainer.push_back(p_parameterList);
9963 209592 : traversalSuccessorContainer.push_back(p_decoratorList);
9964 209592 : traversalSuccessorContainer.push_back(p_definition);
9965 209592 : traversalSuccessorContainer.push_back(p_CtorInitializerList);
9966 209592 : return traversalSuccessorContainer;
9967 : }
9968 : vector<string>
9969 20616 : SgTemplateInstantiationMemberFunctionDecl::get_traversalSuccessorNamesContainer() {
9970 20616 : vector<string> traversalSuccessorContainer;
9971 41232 : traversalSuccessorContainer.push_back("p_parameterList");
9972 41232 : traversalSuccessorContainer.push_back("p_decoratorList");
9973 41232 : traversalSuccessorContainer.push_back("p_definition");
9974 41232 : traversalSuccessorContainer.push_back("p_CtorInitializerList");
9975 20616 : return traversalSuccessorContainer;
9976 : }
9977 : size_t
9978 748091 : SgTemplateInstantiationMemberFunctionDecl::get_numberOfTraversalSuccessors() {
9979 748091 : return 4;
9980 : }
9981 : SgNode *
9982 2986260 : SgTemplateInstantiationMemberFunctionDecl::get_traversalSuccessorByIndex(size_t idx) {
9983 2986260 : switch (idx) {
9984 746763 : case 0: ROSE_ASSERT(p_parameterList == NULL || p_parameterList != NULL); return p_parameterList;
9985 746339 : case 1: ROSE_ASSERT(p_decoratorList == NULL || p_decoratorList != NULL); return p_decoratorList;
9986 746395 : case 2: ROSE_ASSERT(p_definition == NULL || p_definition != NULL); return p_definition;
9987 746763 : case 3: ROSE_ASSERT(p_CtorInitializerList == NULL || p_CtorInitializerList != NULL); return p_CtorInitializerList;
9988 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
9989 0 : ROSE_ASSERT(false);
9990 : return NULL;
9991 : }
9992 : }
9993 : size_t
9994 0 : SgTemplateInstantiationMemberFunctionDecl::get_childIndex(SgNode *child) {
9995 0 : if (child == p_parameterList) return 0;
9996 0 : else if (child == p_decoratorList) return 1;
9997 0 : else if (child == p_definition) return 2;
9998 0 : else if (child == p_CtorInitializerList) return 3;
9999 0 : else return (size_t) -1;
10000 : }
10001 : vector<SgNode*>
10002 11761 : SgTemplateInstantiationFunctionDecl::get_traversalSuccessorContainer() {
10003 11761 : vector<SgNode*> traversalSuccessorContainer;
10004 11761 : traversalSuccessorContainer.reserve(3);
10005 11761 : traversalSuccessorContainer.push_back(p_parameterList);
10006 11761 : traversalSuccessorContainer.push_back(p_decoratorList);
10007 11761 : traversalSuccessorContainer.push_back(p_definition);
10008 11761 : return traversalSuccessorContainer;
10009 : }
10010 : vector<string>
10011 2944 : SgTemplateInstantiationFunctionDecl::get_traversalSuccessorNamesContainer() {
10012 2944 : vector<string> traversalSuccessorContainer;
10013 5888 : traversalSuccessorContainer.push_back("p_parameterList");
10014 5888 : traversalSuccessorContainer.push_back("p_decoratorList");
10015 5888 : traversalSuccessorContainer.push_back("p_definition");
10016 2944 : return traversalSuccessorContainer;
10017 : }
10018 : size_t
10019 87053 : SgTemplateInstantiationFunctionDecl::get_numberOfTraversalSuccessors() {
10020 87053 : return 3;
10021 : }
10022 : SgNode *
10023 261039 : SgTemplateInstantiationFunctionDecl::get_traversalSuccessorByIndex(size_t idx) {
10024 261039 : switch (idx) {
10025 87021 : case 0: ROSE_ASSERT(p_parameterList == NULL || p_parameterList != NULL); return p_parameterList;
10026 87005 : case 1: ROSE_ASSERT(p_decoratorList == NULL || p_decoratorList != NULL); return p_decoratorList;
10027 87013 : case 2: ROSE_ASSERT(p_definition == NULL || p_definition != NULL); return p_definition;
10028 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
10029 0 : ROSE_ASSERT(false);
10030 : return NULL;
10031 : }
10032 : }
10033 : size_t
10034 0 : SgTemplateInstantiationFunctionDecl::get_childIndex(SgNode *child) {
10035 0 : if (child == p_parameterList) return 0;
10036 0 : else if (child == p_decoratorList) return 1;
10037 0 : else if (child == p_definition) return 2;
10038 0 : else return (size_t) -1;
10039 : }
10040 : vector<SgNode*>
10041 103 : SgProgramHeaderStatement::get_traversalSuccessorContainer() {
10042 103 : vector<SgNode*> traversalSuccessorContainer;
10043 103 : traversalSuccessorContainer.reserve(3);
10044 103 : traversalSuccessorContainer.push_back(p_parameterList);
10045 103 : traversalSuccessorContainer.push_back(p_decoratorList);
10046 103 : traversalSuccessorContainer.push_back(p_definition);
10047 103 : return traversalSuccessorContainer;
10048 : }
10049 : vector<string>
10050 52 : SgProgramHeaderStatement::get_traversalSuccessorNamesContainer() {
10051 52 : vector<string> traversalSuccessorContainer;
10052 104 : traversalSuccessorContainer.push_back("p_parameterList");
10053 104 : traversalSuccessorContainer.push_back("p_decoratorList");
10054 104 : traversalSuccessorContainer.push_back("p_definition");
10055 52 : return traversalSuccessorContainer;
10056 : }
10057 : size_t
10058 1092 : SgProgramHeaderStatement::get_numberOfTraversalSuccessors() {
10059 1092 : return 3;
10060 : }
10061 : SgNode *
10062 3276 : SgProgramHeaderStatement::get_traversalSuccessorByIndex(size_t idx) {
10063 3276 : switch (idx) {
10064 1092 : case 0: ROSE_ASSERT(p_parameterList == NULL || p_parameterList != NULL); return p_parameterList;
10065 1092 : case 1: ROSE_ASSERT(p_decoratorList == NULL || p_decoratorList != NULL); return p_decoratorList;
10066 1092 : case 2: ROSE_ASSERT(p_definition == NULL || p_definition != NULL); return p_definition;
10067 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
10068 0 : ROSE_ASSERT(false);
10069 : return NULL;
10070 : }
10071 : }
10072 : size_t
10073 0 : SgProgramHeaderStatement::get_childIndex(SgNode *child) {
10074 0 : if (child == p_parameterList) return 0;
10075 0 : else if (child == p_decoratorList) return 1;
10076 0 : else if (child == p_definition) return 2;
10077 0 : else return (size_t) -1;
10078 : }
10079 : vector<SgNode*>
10080 73 : SgProcedureHeaderStatement::get_traversalSuccessorContainer() {
10081 73 : vector<SgNode*> traversalSuccessorContainer;
10082 73 : traversalSuccessorContainer.reserve(4);
10083 73 : traversalSuccessorContainer.push_back(p_parameterList);
10084 73 : traversalSuccessorContainer.push_back(p_decoratorList);
10085 73 : traversalSuccessorContainer.push_back(p_definition);
10086 73 : traversalSuccessorContainer.push_back(p_result_name);
10087 73 : return traversalSuccessorContainer;
10088 : }
10089 : vector<string>
10090 36 : SgProcedureHeaderStatement::get_traversalSuccessorNamesContainer() {
10091 36 : vector<string> traversalSuccessorContainer;
10092 72 : traversalSuccessorContainer.push_back("p_parameterList");
10093 72 : traversalSuccessorContainer.push_back("p_decoratorList");
10094 72 : traversalSuccessorContainer.push_back("p_definition");
10095 72 : traversalSuccessorContainer.push_back("p_result_name");
10096 36 : return traversalSuccessorContainer;
10097 : }
10098 : size_t
10099 615 : SgProcedureHeaderStatement::get_numberOfTraversalSuccessors() {
10100 615 : return 4;
10101 : }
10102 : SgNode *
10103 2460 : SgProcedureHeaderStatement::get_traversalSuccessorByIndex(size_t idx) {
10104 2460 : switch (idx) {
10105 615 : case 0: ROSE_ASSERT(p_parameterList == NULL || p_parameterList != NULL); return p_parameterList;
10106 615 : case 1: ROSE_ASSERT(p_decoratorList == NULL || p_decoratorList != NULL); return p_decoratorList;
10107 615 : case 2: ROSE_ASSERT(p_definition == NULL || p_definition != NULL); return p_definition;
10108 615 : case 3: ROSE_ASSERT(p_result_name == NULL || p_result_name != NULL); return p_result_name;
10109 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
10110 0 : ROSE_ASSERT(false);
10111 : return NULL;
10112 : }
10113 : }
10114 : size_t
10115 0 : SgProcedureHeaderStatement::get_childIndex(SgNode *child) {
10116 0 : if (child == p_parameterList) return 0;
10117 0 : else if (child == p_decoratorList) return 1;
10118 0 : else if (child == p_definition) return 2;
10119 0 : else if (child == p_result_name) return 3;
10120 0 : else return (size_t) -1;
10121 : }
10122 : vector<SgNode*>
10123 0 : SgEntryStatement::get_traversalSuccessorContainer() {
10124 0 : vector<SgNode*> traversalSuccessorContainer;
10125 0 : traversalSuccessorContainer.reserve(4);
10126 0 : traversalSuccessorContainer.push_back(p_parameterList);
10127 0 : traversalSuccessorContainer.push_back(p_decoratorList);
10128 0 : traversalSuccessorContainer.push_back(p_definition);
10129 0 : traversalSuccessorContainer.push_back(p_result_name);
10130 0 : return traversalSuccessorContainer;
10131 : }
10132 : vector<string>
10133 0 : SgEntryStatement::get_traversalSuccessorNamesContainer() {
10134 0 : vector<string> traversalSuccessorContainer;
10135 0 : traversalSuccessorContainer.push_back("p_parameterList");
10136 0 : traversalSuccessorContainer.push_back("p_decoratorList");
10137 0 : traversalSuccessorContainer.push_back("p_definition");
10138 0 : traversalSuccessorContainer.push_back("p_result_name");
10139 0 : return traversalSuccessorContainer;
10140 : }
10141 : size_t
10142 0 : SgEntryStatement::get_numberOfTraversalSuccessors() {
10143 0 : return 4;
10144 : }
10145 : SgNode *
10146 0 : SgEntryStatement::get_traversalSuccessorByIndex(size_t idx) {
10147 0 : switch (idx) {
10148 0 : case 0: ROSE_ASSERT(p_parameterList == NULL || p_parameterList != NULL); return p_parameterList;
10149 0 : case 1: ROSE_ASSERT(p_decoratorList == NULL || p_decoratorList != NULL); return p_decoratorList;
10150 0 : case 2: ROSE_ASSERT(p_definition == NULL || p_definition != NULL); return p_definition;
10151 0 : case 3: ROSE_ASSERT(p_result_name == NULL || p_result_name != NULL); return p_result_name;
10152 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
10153 0 : ROSE_ASSERT(false);
10154 : return NULL;
10155 : }
10156 : }
10157 : size_t
10158 0 : SgEntryStatement::get_childIndex(SgNode *child) {
10159 0 : if (child == p_parameterList) return 0;
10160 0 : else if (child == p_decoratorList) return 1;
10161 0 : else if (child == p_definition) return 2;
10162 0 : else if (child == p_result_name) return 3;
10163 0 : else return (size_t) -1;
10164 : }
10165 : vector<SgNode*>
10166 0 : SgContainsStatement::get_traversalSuccessorContainer() {
10167 0 : vector<SgNode*> traversalSuccessorContainer;
10168 0 : return traversalSuccessorContainer;
10169 : }
10170 : vector<string>
10171 0 : SgContainsStatement::get_traversalSuccessorNamesContainer() {
10172 0 : vector<string> traversalSuccessorContainer;
10173 0 : return traversalSuccessorContainer;
10174 : }
10175 : size_t
10176 0 : SgContainsStatement::get_numberOfTraversalSuccessors() {
10177 0 : return 0;
10178 : }
10179 : SgNode *
10180 0 : SgContainsStatement::get_traversalSuccessorByIndex(size_t idx) {
10181 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgContainsStatement" << " that has no successors!" << endl;
10182 0 : ROSE_ASSERT(false);
10183 : return NULL;
10184 : }
10185 : size_t
10186 0 : SgContainsStatement::get_childIndex(SgNode *child) {
10187 0 : cout << "error: get_childIndex called on node of type " << "SgContainsStatement" << " that has no successors!" << endl;
10188 0 : ROSE_ASSERT(false);
10189 : return 0;
10190 : }
10191 : vector<SgNode*>
10192 0 : SgC_PreprocessorDirectiveStatement::get_traversalSuccessorContainer() {
10193 0 : vector<SgNode*> traversalSuccessorContainer;
10194 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
10195 0 : << "static: SgC_PreprocessorDirectiveStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
10196 0 : cerr << "Aborting ..." << endl;
10197 0 : ROSE_ASSERT(false);
10198 : return traversalSuccessorContainer;
10199 : }
10200 :
10201 : vector<string>
10202 0 : SgC_PreprocessorDirectiveStatement::get_traversalSuccessorNamesContainer() {
10203 0 : vector<string> traversalSuccessorContainer;
10204 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
10205 0 : << "static: SgC_PreprocessorDirectiveStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
10206 0 : cerr << "Aborting ..." << endl;
10207 0 : ROSE_ASSERT(false);
10208 : return traversalSuccessorContainer;
10209 : }
10210 :
10211 : size_t
10212 0 : SgC_PreprocessorDirectiveStatement::get_numberOfTraversalSuccessors() {
10213 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
10214 0 : << "static: SgC_PreprocessorDirectiveStatement" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
10215 0 : cerr << "Aborting ..." << endl;
10216 0 : ROSE_ASSERT(false);
10217 : return 42;
10218 : }
10219 :
10220 : SgNode*
10221 0 : SgC_PreprocessorDirectiveStatement::get_traversalSuccessorByIndex(size_t) {
10222 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
10223 0 : << "static: SgC_PreprocessorDirectiveStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
10224 0 : cerr << "Aborting ..." << endl;
10225 0 : ROSE_ASSERT(false);
10226 : return NULL;
10227 : }
10228 :
10229 : size_t
10230 0 : SgC_PreprocessorDirectiveStatement::get_childIndex(SgNode *) {
10231 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
10232 0 : << "static: SgC_PreprocessorDirectiveStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
10233 0 : cerr << "Aborting ..." << endl;
10234 0 : ROSE_ASSERT(false);
10235 : return 42;
10236 : }
10237 :
10238 : vector<SgNode*>
10239 0 : SgIncludeDirectiveStatement::get_traversalSuccessorContainer() {
10240 0 : vector<SgNode*> traversalSuccessorContainer;
10241 0 : traversalSuccessorContainer.reserve(1);
10242 0 : traversalSuccessorContainer.push_back(p_headerFileBody);
10243 0 : return traversalSuccessorContainer;
10244 : }
10245 : vector<string>
10246 0 : SgIncludeDirectiveStatement::get_traversalSuccessorNamesContainer() {
10247 0 : vector<string> traversalSuccessorContainer;
10248 0 : traversalSuccessorContainer.push_back("p_headerFileBody");
10249 0 : return traversalSuccessorContainer;
10250 : }
10251 : size_t
10252 0 : SgIncludeDirectiveStatement::get_numberOfTraversalSuccessors() {
10253 0 : return 1;
10254 : }
10255 : SgNode *
10256 0 : SgIncludeDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10257 0 : switch (idx) {
10258 0 : case 0: ROSE_ASSERT(p_headerFileBody == NULL || p_headerFileBody != NULL); return p_headerFileBody;
10259 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
10260 0 : ROSE_ASSERT(false);
10261 : return NULL;
10262 : }
10263 : }
10264 : size_t
10265 0 : SgIncludeDirectiveStatement::get_childIndex(SgNode *child) {
10266 0 : if (child == p_headerFileBody) return 0;
10267 0 : else return (size_t) -1;
10268 : }
10269 : vector<SgNode*>
10270 0 : SgDefineDirectiveStatement::get_traversalSuccessorContainer() {
10271 0 : vector<SgNode*> traversalSuccessorContainer;
10272 0 : return traversalSuccessorContainer;
10273 : }
10274 : vector<string>
10275 0 : SgDefineDirectiveStatement::get_traversalSuccessorNamesContainer() {
10276 0 : vector<string> traversalSuccessorContainer;
10277 0 : return traversalSuccessorContainer;
10278 : }
10279 : size_t
10280 0 : SgDefineDirectiveStatement::get_numberOfTraversalSuccessors() {
10281 0 : return 0;
10282 : }
10283 : SgNode *
10284 0 : SgDefineDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10285 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgDefineDirectiveStatement" << " that has no successors!" << endl;
10286 0 : ROSE_ASSERT(false);
10287 : return NULL;
10288 : }
10289 : size_t
10290 0 : SgDefineDirectiveStatement::get_childIndex(SgNode *child) {
10291 0 : cout << "error: get_childIndex called on node of type " << "SgDefineDirectiveStatement" << " that has no successors!" << endl;
10292 0 : ROSE_ASSERT(false);
10293 : return 0;
10294 : }
10295 : vector<SgNode*>
10296 0 : SgUndefDirectiveStatement::get_traversalSuccessorContainer() {
10297 0 : vector<SgNode*> traversalSuccessorContainer;
10298 0 : return traversalSuccessorContainer;
10299 : }
10300 : vector<string>
10301 0 : SgUndefDirectiveStatement::get_traversalSuccessorNamesContainer() {
10302 0 : vector<string> traversalSuccessorContainer;
10303 0 : return traversalSuccessorContainer;
10304 : }
10305 : size_t
10306 0 : SgUndefDirectiveStatement::get_numberOfTraversalSuccessors() {
10307 0 : return 0;
10308 : }
10309 : SgNode *
10310 0 : SgUndefDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10311 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUndefDirectiveStatement" << " that has no successors!" << endl;
10312 0 : ROSE_ASSERT(false);
10313 : return NULL;
10314 : }
10315 : size_t
10316 0 : SgUndefDirectiveStatement::get_childIndex(SgNode *child) {
10317 0 : cout << "error: get_childIndex called on node of type " << "SgUndefDirectiveStatement" << " that has no successors!" << endl;
10318 0 : ROSE_ASSERT(false);
10319 : return 0;
10320 : }
10321 : vector<SgNode*>
10322 0 : SgIfdefDirectiveStatement::get_traversalSuccessorContainer() {
10323 0 : vector<SgNode*> traversalSuccessorContainer;
10324 0 : return traversalSuccessorContainer;
10325 : }
10326 : vector<string>
10327 0 : SgIfdefDirectiveStatement::get_traversalSuccessorNamesContainer() {
10328 0 : vector<string> traversalSuccessorContainer;
10329 0 : return traversalSuccessorContainer;
10330 : }
10331 : size_t
10332 0 : SgIfdefDirectiveStatement::get_numberOfTraversalSuccessors() {
10333 0 : return 0;
10334 : }
10335 : SgNode *
10336 0 : SgIfdefDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10337 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgIfdefDirectiveStatement" << " that has no successors!" << endl;
10338 0 : ROSE_ASSERT(false);
10339 : return NULL;
10340 : }
10341 : size_t
10342 0 : SgIfdefDirectiveStatement::get_childIndex(SgNode *child) {
10343 0 : cout << "error: get_childIndex called on node of type " << "SgIfdefDirectiveStatement" << " that has no successors!" << endl;
10344 0 : ROSE_ASSERT(false);
10345 : return 0;
10346 : }
10347 : vector<SgNode*>
10348 0 : SgIfndefDirectiveStatement::get_traversalSuccessorContainer() {
10349 0 : vector<SgNode*> traversalSuccessorContainer;
10350 0 : return traversalSuccessorContainer;
10351 : }
10352 : vector<string>
10353 0 : SgIfndefDirectiveStatement::get_traversalSuccessorNamesContainer() {
10354 0 : vector<string> traversalSuccessorContainer;
10355 0 : return traversalSuccessorContainer;
10356 : }
10357 : size_t
10358 0 : SgIfndefDirectiveStatement::get_numberOfTraversalSuccessors() {
10359 0 : return 0;
10360 : }
10361 : SgNode *
10362 0 : SgIfndefDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10363 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgIfndefDirectiveStatement" << " that has no successors!" << endl;
10364 0 : ROSE_ASSERT(false);
10365 : return NULL;
10366 : }
10367 : size_t
10368 0 : SgIfndefDirectiveStatement::get_childIndex(SgNode *child) {
10369 0 : cout << "error: get_childIndex called on node of type " << "SgIfndefDirectiveStatement" << " that has no successors!" << endl;
10370 0 : ROSE_ASSERT(false);
10371 : return 0;
10372 : }
10373 : vector<SgNode*>
10374 0 : SgIfDirectiveStatement::get_traversalSuccessorContainer() {
10375 0 : vector<SgNode*> traversalSuccessorContainer;
10376 0 : return traversalSuccessorContainer;
10377 : }
10378 : vector<string>
10379 0 : SgIfDirectiveStatement::get_traversalSuccessorNamesContainer() {
10380 0 : vector<string> traversalSuccessorContainer;
10381 0 : return traversalSuccessorContainer;
10382 : }
10383 : size_t
10384 0 : SgIfDirectiveStatement::get_numberOfTraversalSuccessors() {
10385 0 : return 0;
10386 : }
10387 : SgNode *
10388 0 : SgIfDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10389 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgIfDirectiveStatement" << " that has no successors!" << endl;
10390 0 : ROSE_ASSERT(false);
10391 : return NULL;
10392 : }
10393 : size_t
10394 0 : SgIfDirectiveStatement::get_childIndex(SgNode *child) {
10395 0 : cout << "error: get_childIndex called on node of type " << "SgIfDirectiveStatement" << " that has no successors!" << endl;
10396 0 : ROSE_ASSERT(false);
10397 : return 0;
10398 : }
10399 : vector<SgNode*>
10400 0 : SgDeadIfDirectiveStatement::get_traversalSuccessorContainer() {
10401 0 : vector<SgNode*> traversalSuccessorContainer;
10402 0 : return traversalSuccessorContainer;
10403 : }
10404 : vector<string>
10405 0 : SgDeadIfDirectiveStatement::get_traversalSuccessorNamesContainer() {
10406 0 : vector<string> traversalSuccessorContainer;
10407 0 : return traversalSuccessorContainer;
10408 : }
10409 : size_t
10410 0 : SgDeadIfDirectiveStatement::get_numberOfTraversalSuccessors() {
10411 0 : return 0;
10412 : }
10413 : SgNode *
10414 0 : SgDeadIfDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10415 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgDeadIfDirectiveStatement" << " that has no successors!" << endl;
10416 0 : ROSE_ASSERT(false);
10417 : return NULL;
10418 : }
10419 : size_t
10420 0 : SgDeadIfDirectiveStatement::get_childIndex(SgNode *child) {
10421 0 : cout << "error: get_childIndex called on node of type " << "SgDeadIfDirectiveStatement" << " that has no successors!" << endl;
10422 0 : ROSE_ASSERT(false);
10423 : return 0;
10424 : }
10425 : vector<SgNode*>
10426 0 : SgElseDirectiveStatement::get_traversalSuccessorContainer() {
10427 0 : vector<SgNode*> traversalSuccessorContainer;
10428 0 : return traversalSuccessorContainer;
10429 : }
10430 : vector<string>
10431 0 : SgElseDirectiveStatement::get_traversalSuccessorNamesContainer() {
10432 0 : vector<string> traversalSuccessorContainer;
10433 0 : return traversalSuccessorContainer;
10434 : }
10435 : size_t
10436 0 : SgElseDirectiveStatement::get_numberOfTraversalSuccessors() {
10437 0 : return 0;
10438 : }
10439 : SgNode *
10440 0 : SgElseDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10441 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgElseDirectiveStatement" << " that has no successors!" << endl;
10442 0 : ROSE_ASSERT(false);
10443 : return NULL;
10444 : }
10445 : size_t
10446 0 : SgElseDirectiveStatement::get_childIndex(SgNode *child) {
10447 0 : cout << "error: get_childIndex called on node of type " << "SgElseDirectiveStatement" << " that has no successors!" << endl;
10448 0 : ROSE_ASSERT(false);
10449 : return 0;
10450 : }
10451 : vector<SgNode*>
10452 0 : SgElseifDirectiveStatement::get_traversalSuccessorContainer() {
10453 0 : vector<SgNode*> traversalSuccessorContainer;
10454 0 : return traversalSuccessorContainer;
10455 : }
10456 : vector<string>
10457 0 : SgElseifDirectiveStatement::get_traversalSuccessorNamesContainer() {
10458 0 : vector<string> traversalSuccessorContainer;
10459 0 : return traversalSuccessorContainer;
10460 : }
10461 : size_t
10462 0 : SgElseifDirectiveStatement::get_numberOfTraversalSuccessors() {
10463 0 : return 0;
10464 : }
10465 : SgNode *
10466 0 : SgElseifDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10467 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgElseifDirectiveStatement" << " that has no successors!" << endl;
10468 0 : ROSE_ASSERT(false);
10469 : return NULL;
10470 : }
10471 : size_t
10472 0 : SgElseifDirectiveStatement::get_childIndex(SgNode *child) {
10473 0 : cout << "error: get_childIndex called on node of type " << "SgElseifDirectiveStatement" << " that has no successors!" << endl;
10474 0 : ROSE_ASSERT(false);
10475 : return 0;
10476 : }
10477 : vector<SgNode*>
10478 0 : SgEndifDirectiveStatement::get_traversalSuccessorContainer() {
10479 0 : vector<SgNode*> traversalSuccessorContainer;
10480 0 : return traversalSuccessorContainer;
10481 : }
10482 : vector<string>
10483 0 : SgEndifDirectiveStatement::get_traversalSuccessorNamesContainer() {
10484 0 : vector<string> traversalSuccessorContainer;
10485 0 : return traversalSuccessorContainer;
10486 : }
10487 : size_t
10488 0 : SgEndifDirectiveStatement::get_numberOfTraversalSuccessors() {
10489 0 : return 0;
10490 : }
10491 : SgNode *
10492 0 : SgEndifDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10493 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgEndifDirectiveStatement" << " that has no successors!" << endl;
10494 0 : ROSE_ASSERT(false);
10495 : return NULL;
10496 : }
10497 : size_t
10498 0 : SgEndifDirectiveStatement::get_childIndex(SgNode *child) {
10499 0 : cout << "error: get_childIndex called on node of type " << "SgEndifDirectiveStatement" << " that has no successors!" << endl;
10500 0 : ROSE_ASSERT(false);
10501 : return 0;
10502 : }
10503 : vector<SgNode*>
10504 0 : SgLineDirectiveStatement::get_traversalSuccessorContainer() {
10505 0 : vector<SgNode*> traversalSuccessorContainer;
10506 0 : return traversalSuccessorContainer;
10507 : }
10508 : vector<string>
10509 0 : SgLineDirectiveStatement::get_traversalSuccessorNamesContainer() {
10510 0 : vector<string> traversalSuccessorContainer;
10511 0 : return traversalSuccessorContainer;
10512 : }
10513 : size_t
10514 0 : SgLineDirectiveStatement::get_numberOfTraversalSuccessors() {
10515 0 : return 0;
10516 : }
10517 : SgNode *
10518 0 : SgLineDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10519 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgLineDirectiveStatement" << " that has no successors!" << endl;
10520 0 : ROSE_ASSERT(false);
10521 : return NULL;
10522 : }
10523 : size_t
10524 0 : SgLineDirectiveStatement::get_childIndex(SgNode *child) {
10525 0 : cout << "error: get_childIndex called on node of type " << "SgLineDirectiveStatement" << " that has no successors!" << endl;
10526 0 : ROSE_ASSERT(false);
10527 : return 0;
10528 : }
10529 : vector<SgNode*>
10530 0 : SgWarningDirectiveStatement::get_traversalSuccessorContainer() {
10531 0 : vector<SgNode*> traversalSuccessorContainer;
10532 0 : return traversalSuccessorContainer;
10533 : }
10534 : vector<string>
10535 0 : SgWarningDirectiveStatement::get_traversalSuccessorNamesContainer() {
10536 0 : vector<string> traversalSuccessorContainer;
10537 0 : return traversalSuccessorContainer;
10538 : }
10539 : size_t
10540 0 : SgWarningDirectiveStatement::get_numberOfTraversalSuccessors() {
10541 0 : return 0;
10542 : }
10543 : SgNode *
10544 0 : SgWarningDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10545 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgWarningDirectiveStatement" << " that has no successors!" << endl;
10546 0 : ROSE_ASSERT(false);
10547 : return NULL;
10548 : }
10549 : size_t
10550 0 : SgWarningDirectiveStatement::get_childIndex(SgNode *child) {
10551 0 : cout << "error: get_childIndex called on node of type " << "SgWarningDirectiveStatement" << " that has no successors!" << endl;
10552 0 : ROSE_ASSERT(false);
10553 : return 0;
10554 : }
10555 : vector<SgNode*>
10556 0 : SgErrorDirectiveStatement::get_traversalSuccessorContainer() {
10557 0 : vector<SgNode*> traversalSuccessorContainer;
10558 0 : return traversalSuccessorContainer;
10559 : }
10560 : vector<string>
10561 0 : SgErrorDirectiveStatement::get_traversalSuccessorNamesContainer() {
10562 0 : vector<string> traversalSuccessorContainer;
10563 0 : return traversalSuccessorContainer;
10564 : }
10565 : size_t
10566 0 : SgErrorDirectiveStatement::get_numberOfTraversalSuccessors() {
10567 0 : return 0;
10568 : }
10569 : SgNode *
10570 0 : SgErrorDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10571 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgErrorDirectiveStatement" << " that has no successors!" << endl;
10572 0 : ROSE_ASSERT(false);
10573 : return NULL;
10574 : }
10575 : size_t
10576 0 : SgErrorDirectiveStatement::get_childIndex(SgNode *child) {
10577 0 : cout << "error: get_childIndex called on node of type " << "SgErrorDirectiveStatement" << " that has no successors!" << endl;
10578 0 : ROSE_ASSERT(false);
10579 : return 0;
10580 : }
10581 : vector<SgNode*>
10582 0 : SgEmptyDirectiveStatement::get_traversalSuccessorContainer() {
10583 0 : vector<SgNode*> traversalSuccessorContainer;
10584 0 : return traversalSuccessorContainer;
10585 : }
10586 : vector<string>
10587 0 : SgEmptyDirectiveStatement::get_traversalSuccessorNamesContainer() {
10588 0 : vector<string> traversalSuccessorContainer;
10589 0 : return traversalSuccessorContainer;
10590 : }
10591 : size_t
10592 0 : SgEmptyDirectiveStatement::get_numberOfTraversalSuccessors() {
10593 0 : return 0;
10594 : }
10595 : SgNode *
10596 0 : SgEmptyDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10597 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgEmptyDirectiveStatement" << " that has no successors!" << endl;
10598 0 : ROSE_ASSERT(false);
10599 : return NULL;
10600 : }
10601 : size_t
10602 0 : SgEmptyDirectiveStatement::get_childIndex(SgNode *child) {
10603 0 : cout << "error: get_childIndex called on node of type " << "SgEmptyDirectiveStatement" << " that has no successors!" << endl;
10604 0 : ROSE_ASSERT(false);
10605 : return 0;
10606 : }
10607 : vector<SgNode*>
10608 0 : SgIncludeNextDirectiveStatement::get_traversalSuccessorContainer() {
10609 0 : vector<SgNode*> traversalSuccessorContainer;
10610 0 : return traversalSuccessorContainer;
10611 : }
10612 : vector<string>
10613 0 : SgIncludeNextDirectiveStatement::get_traversalSuccessorNamesContainer() {
10614 0 : vector<string> traversalSuccessorContainer;
10615 0 : return traversalSuccessorContainer;
10616 : }
10617 : size_t
10618 0 : SgIncludeNextDirectiveStatement::get_numberOfTraversalSuccessors() {
10619 0 : return 0;
10620 : }
10621 : SgNode *
10622 0 : SgIncludeNextDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10623 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgIncludeNextDirectiveStatement" << " that has no successors!" << endl;
10624 0 : ROSE_ASSERT(false);
10625 : return NULL;
10626 : }
10627 : size_t
10628 0 : SgIncludeNextDirectiveStatement::get_childIndex(SgNode *child) {
10629 0 : cout << "error: get_childIndex called on node of type " << "SgIncludeNextDirectiveStatement" << " that has no successors!" << endl;
10630 0 : ROSE_ASSERT(false);
10631 : return 0;
10632 : }
10633 : vector<SgNode*>
10634 0 : SgIdentDirectiveStatement::get_traversalSuccessorContainer() {
10635 0 : vector<SgNode*> traversalSuccessorContainer;
10636 0 : return traversalSuccessorContainer;
10637 : }
10638 : vector<string>
10639 0 : SgIdentDirectiveStatement::get_traversalSuccessorNamesContainer() {
10640 0 : vector<string> traversalSuccessorContainer;
10641 0 : return traversalSuccessorContainer;
10642 : }
10643 : size_t
10644 0 : SgIdentDirectiveStatement::get_numberOfTraversalSuccessors() {
10645 0 : return 0;
10646 : }
10647 : SgNode *
10648 0 : SgIdentDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10649 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgIdentDirectiveStatement" << " that has no successors!" << endl;
10650 0 : ROSE_ASSERT(false);
10651 : return NULL;
10652 : }
10653 : size_t
10654 0 : SgIdentDirectiveStatement::get_childIndex(SgNode *child) {
10655 0 : cout << "error: get_childIndex called on node of type " << "SgIdentDirectiveStatement" << " that has no successors!" << endl;
10656 0 : ROSE_ASSERT(false);
10657 : return 0;
10658 : }
10659 : vector<SgNode*>
10660 0 : SgLinemarkerDirectiveStatement::get_traversalSuccessorContainer() {
10661 0 : vector<SgNode*> traversalSuccessorContainer;
10662 0 : return traversalSuccessorContainer;
10663 : }
10664 : vector<string>
10665 0 : SgLinemarkerDirectiveStatement::get_traversalSuccessorNamesContainer() {
10666 0 : vector<string> traversalSuccessorContainer;
10667 0 : return traversalSuccessorContainer;
10668 : }
10669 : size_t
10670 0 : SgLinemarkerDirectiveStatement::get_numberOfTraversalSuccessors() {
10671 0 : return 0;
10672 : }
10673 : SgNode *
10674 0 : SgLinemarkerDirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
10675 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgLinemarkerDirectiveStatement" << " that has no successors!" << endl;
10676 0 : ROSE_ASSERT(false);
10677 : return NULL;
10678 : }
10679 : size_t
10680 0 : SgLinemarkerDirectiveStatement::get_childIndex(SgNode *child) {
10681 0 : cout << "error: get_childIndex called on node of type " << "SgLinemarkerDirectiveStatement" << " that has no successors!" << endl;
10682 0 : ROSE_ASSERT(false);
10683 : return 0;
10684 : }
10685 : vector<SgNode*>
10686 14 : SgOmpThreadprivateStatement::get_traversalSuccessorContainer() {
10687 14 : vector<SgNode*> traversalSuccessorContainer;
10688 14 : traversalSuccessorContainer.reserve(p_variables.size() + 0);
10689 14 : {
10690 14 : SgVarRefExpPtrList::iterator iter;
10691 34 : for (iter = p_variables.begin(); iter != p_variables.end(); iter++)
10692 20 : traversalSuccessorContainer.push_back(*iter);
10693 : }
10694 14 : return traversalSuccessorContainer;
10695 : }
10696 : vector<string>
10697 21 : SgOmpThreadprivateStatement::get_traversalSuccessorNamesContainer() {
10698 21 : vector<string> traversalSuccessorContainer;
10699 21 : int i = 0;
10700 21 : {
10701 21 : SgVarRefExpPtrList::iterator iter;
10702 51 : for (iter = p_variables.begin(); iter != p_variables.end(); (iter++,i++)) {
10703 30 : char buf[20];
10704 30 : sprintf(buf,"*[%d]",i);
10705 60 : traversalSuccessorContainer.push_back(buf);
10706 : }
10707 : }
10708 21 : return traversalSuccessorContainer;
10709 : }
10710 : size_t
10711 104 : SgOmpThreadprivateStatement::get_numberOfTraversalSuccessors() {
10712 104 : return p_variables.size() + 0;
10713 : }
10714 : SgNode *
10715 149 : SgOmpThreadprivateStatement::get_traversalSuccessorByIndex(size_t idx) {
10716 149 : ROSE_ASSERT(idx < p_variables.size());
10717 149 : return p_variables[idx];
10718 : }
10719 : size_t
10720 0 : SgOmpThreadprivateStatement::get_childIndex(SgNode *child) {
10721 0 : SgVarRefExpPtrList::iterator itr = find(p_variables.begin(), p_variables.end(), child);
10722 0 : if (itr != p_variables.end()) return itr - p_variables.begin();
10723 : else return (size_t) -1;
10724 : }
10725 : vector<SgNode*>
10726 14 : SgOmpRequiresStatement::get_traversalSuccessorContainer() {
10727 14 : vector<SgNode*> traversalSuccessorContainer;
10728 14 : traversalSuccessorContainer.reserve(p_clauses.size() + 0);
10729 14 : {
10730 14 : SgOmpClausePtrList::iterator iter;
10731 30 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
10732 16 : traversalSuccessorContainer.push_back(*iter);
10733 : }
10734 14 : return traversalSuccessorContainer;
10735 : }
10736 : vector<string>
10737 21 : SgOmpRequiresStatement::get_traversalSuccessorNamesContainer() {
10738 21 : vector<string> traversalSuccessorContainer;
10739 21 : int i = 0;
10740 21 : {
10741 21 : SgOmpClausePtrList::iterator iter;
10742 45 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
10743 24 : char buf[20];
10744 24 : sprintf(buf,"*[%d]",i);
10745 48 : traversalSuccessorContainer.push_back(buf);
10746 : }
10747 : }
10748 21 : return traversalSuccessorContainer;
10749 : }
10750 : size_t
10751 105 : SgOmpRequiresStatement::get_numberOfTraversalSuccessors() {
10752 105 : return p_clauses.size() + 0;
10753 : }
10754 : SgNode *
10755 120 : SgOmpRequiresStatement::get_traversalSuccessorByIndex(size_t idx) {
10756 120 : ROSE_ASSERT(idx < p_clauses.size());
10757 120 : return p_clauses[idx];
10758 : }
10759 : size_t
10760 0 : SgOmpRequiresStatement::get_childIndex(SgNode *child) {
10761 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
10762 0 : if (itr != p_clauses.end()) return itr - p_clauses.begin();
10763 : else return (size_t) -1;
10764 : }
10765 : vector<SgNode*>
10766 146 : SgFortranIncludeLine::get_traversalSuccessorContainer() {
10767 146 : vector<SgNode*> traversalSuccessorContainer;
10768 146 : return traversalSuccessorContainer;
10769 : }
10770 : vector<string>
10771 56 : SgFortranIncludeLine::get_traversalSuccessorNamesContainer() {
10772 56 : vector<string> traversalSuccessorContainer;
10773 56 : return traversalSuccessorContainer;
10774 : }
10775 : size_t
10776 1210 : SgFortranIncludeLine::get_numberOfTraversalSuccessors() {
10777 1210 : return 0;
10778 : }
10779 : SgNode *
10780 0 : SgFortranIncludeLine::get_traversalSuccessorByIndex(size_t idx) {
10781 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgFortranIncludeLine" << " that has no successors!" << endl;
10782 0 : ROSE_ASSERT(false);
10783 : return NULL;
10784 : }
10785 : size_t
10786 0 : SgFortranIncludeLine::get_childIndex(SgNode *child) {
10787 0 : cout << "error: get_childIndex called on node of type " << "SgFortranIncludeLine" << " that has no successors!" << endl;
10788 0 : ROSE_ASSERT(false);
10789 : return 0;
10790 : }
10791 : vector<SgNode*>
10792 56 : SgOmpTaskwaitStatement::get_traversalSuccessorContainer() {
10793 56 : vector<SgNode*> traversalSuccessorContainer;
10794 56 : traversalSuccessorContainer.reserve(p_clauses.size() + 0);
10795 56 : {
10796 56 : SgOmpClausePtrList::iterator iter;
10797 58 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
10798 2 : traversalSuccessorContainer.push_back(*iter);
10799 : }
10800 56 : return traversalSuccessorContainer;
10801 : }
10802 : vector<string>
10803 57 : SgOmpTaskwaitStatement::get_traversalSuccessorNamesContainer() {
10804 57 : vector<string> traversalSuccessorContainer;
10805 57 : int i = 0;
10806 57 : {
10807 57 : SgOmpClausePtrList::iterator iter;
10808 60 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
10809 3 : char buf[20];
10810 3 : sprintf(buf,"*[%d]",i);
10811 6 : traversalSuccessorContainer.push_back(buf);
10812 : }
10813 : }
10814 57 : return traversalSuccessorContainer;
10815 : }
10816 : size_t
10817 432 : SgOmpTaskwaitStatement::get_numberOfTraversalSuccessors() {
10818 432 : return p_clauses.size() + 0;
10819 : }
10820 : SgNode *
10821 16 : SgOmpTaskwaitStatement::get_traversalSuccessorByIndex(size_t idx) {
10822 16 : ROSE_ASSERT(idx < p_clauses.size());
10823 16 : return p_clauses[idx];
10824 : }
10825 : size_t
10826 0 : SgOmpTaskwaitStatement::get_childIndex(SgNode *child) {
10827 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
10828 0 : if (itr != p_clauses.end()) return itr - p_clauses.begin();
10829 : else return (size_t) -1;
10830 : }
10831 : vector<SgNode*>
10832 0 : SgStmtDeclarationStatement::get_traversalSuccessorContainer() {
10833 0 : vector<SgNode*> traversalSuccessorContainer;
10834 0 : traversalSuccessorContainer.reserve(1);
10835 0 : traversalSuccessorContainer.push_back(p_statement);
10836 0 : return traversalSuccessorContainer;
10837 : }
10838 : vector<string>
10839 0 : SgStmtDeclarationStatement::get_traversalSuccessorNamesContainer() {
10840 0 : vector<string> traversalSuccessorContainer;
10841 0 : traversalSuccessorContainer.push_back("p_statement");
10842 0 : return traversalSuccessorContainer;
10843 : }
10844 : size_t
10845 0 : SgStmtDeclarationStatement::get_numberOfTraversalSuccessors() {
10846 0 : return 1;
10847 : }
10848 : SgNode *
10849 0 : SgStmtDeclarationStatement::get_traversalSuccessorByIndex(size_t idx) {
10850 0 : switch (idx) {
10851 0 : case 0: ROSE_ASSERT(p_statement == NULL || p_statement != NULL); return p_statement;
10852 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
10853 0 : ROSE_ASSERT(false);
10854 : return NULL;
10855 : }
10856 : }
10857 : size_t
10858 0 : SgStmtDeclarationStatement::get_childIndex(SgNode *child) {
10859 0 : if (child == p_statement) return 0;
10860 0 : else return (size_t) -1;
10861 : }
10862 : vector<SgNode*>
10863 11877 : SgStaticAssertionDeclaration::get_traversalSuccessorContainer() {
10864 11877 : vector<SgNode*> traversalSuccessorContainer;
10865 11877 : traversalSuccessorContainer.reserve(1);
10866 11877 : traversalSuccessorContainer.push_back(p_condition);
10867 11877 : return traversalSuccessorContainer;
10868 : }
10869 : vector<string>
10870 204 : SgStaticAssertionDeclaration::get_traversalSuccessorNamesContainer() {
10871 204 : vector<string> traversalSuccessorContainer;
10872 408 : traversalSuccessorContainer.push_back("p_condition");
10873 204 : return traversalSuccessorContainer;
10874 : }
10875 : size_t
10876 17374 : SgStaticAssertionDeclaration::get_numberOfTraversalSuccessors() {
10877 17374 : return 1;
10878 : }
10879 : SgNode *
10880 17355 : SgStaticAssertionDeclaration::get_traversalSuccessorByIndex(size_t idx) {
10881 17355 : switch (idx) {
10882 17355 : case 0: ROSE_ASSERT(p_condition == NULL || p_condition != NULL); return p_condition;
10883 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
10884 0 : ROSE_ASSERT(false);
10885 : return NULL;
10886 : }
10887 : }
10888 : size_t
10889 0 : SgStaticAssertionDeclaration::get_childIndex(SgNode *child) {
10890 0 : if (child == p_condition) return 0;
10891 0 : else return (size_t) -1;
10892 : }
10893 : vector<SgNode*>
10894 6 : SgOmpDeclareSimdStatement::get_traversalSuccessorContainer() {
10895 6 : vector<SgNode*> traversalSuccessorContainer;
10896 6 : traversalSuccessorContainer.reserve(p_clauses.size() + 0);
10897 6 : {
10898 6 : SgOmpClausePtrList::iterator iter;
10899 16 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
10900 10 : traversalSuccessorContainer.push_back(*iter);
10901 : }
10902 6 : return traversalSuccessorContainer;
10903 : }
10904 : vector<string>
10905 9 : SgOmpDeclareSimdStatement::get_traversalSuccessorNamesContainer() {
10906 9 : vector<string> traversalSuccessorContainer;
10907 9 : int i = 0;
10908 9 : {
10909 9 : SgOmpClausePtrList::iterator iter;
10910 24 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
10911 15 : char buf[20];
10912 15 : sprintf(buf,"*[%d]",i);
10913 30 : traversalSuccessorContainer.push_back(buf);
10914 : }
10915 : }
10916 9 : return traversalSuccessorContainer;
10917 : }
10918 : size_t
10919 45 : SgOmpDeclareSimdStatement::get_numberOfTraversalSuccessors() {
10920 45 : return p_clauses.size() + 0;
10921 : }
10922 : SgNode *
10923 75 : SgOmpDeclareSimdStatement::get_traversalSuccessorByIndex(size_t idx) {
10924 75 : ROSE_ASSERT(idx < p_clauses.size());
10925 75 : return p_clauses[idx];
10926 : }
10927 : size_t
10928 0 : SgOmpDeclareSimdStatement::get_childIndex(SgNode *child) {
10929 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
10930 0 : if (itr != p_clauses.end()) return itr - p_clauses.begin();
10931 : else return (size_t) -1;
10932 : }
10933 : vector<SgNode*>
10934 0 : SgMicrosoftAttributeDeclaration::get_traversalSuccessorContainer() {
10935 0 : vector<SgNode*> traversalSuccessorContainer;
10936 0 : return traversalSuccessorContainer;
10937 : }
10938 : vector<string>
10939 0 : SgMicrosoftAttributeDeclaration::get_traversalSuccessorNamesContainer() {
10940 0 : vector<string> traversalSuccessorContainer;
10941 0 : return traversalSuccessorContainer;
10942 : }
10943 : size_t
10944 0 : SgMicrosoftAttributeDeclaration::get_numberOfTraversalSuccessors() {
10945 0 : return 0;
10946 : }
10947 : SgNode *
10948 0 : SgMicrosoftAttributeDeclaration::get_traversalSuccessorByIndex(size_t idx) {
10949 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgMicrosoftAttributeDeclaration" << " that has no successors!" << endl;
10950 0 : ROSE_ASSERT(false);
10951 : return NULL;
10952 : }
10953 : size_t
10954 0 : SgMicrosoftAttributeDeclaration::get_childIndex(SgNode *child) {
10955 0 : cout << "error: get_childIndex called on node of type " << "SgMicrosoftAttributeDeclaration" << " that has no successors!" << endl;
10956 0 : ROSE_ASSERT(false);
10957 : return 0;
10958 : }
10959 : vector<SgNode*>
10960 0 : SgNonrealDecl::get_traversalSuccessorContainer() {
10961 0 : vector<SgNode*> traversalSuccessorContainer;
10962 0 : return traversalSuccessorContainer;
10963 : }
10964 : vector<string>
10965 0 : SgNonrealDecl::get_traversalSuccessorNamesContainer() {
10966 0 : vector<string> traversalSuccessorContainer;
10967 0 : return traversalSuccessorContainer;
10968 : }
10969 : size_t
10970 742 : SgNonrealDecl::get_numberOfTraversalSuccessors() {
10971 742 : return 0;
10972 : }
10973 : SgNode *
10974 0 : SgNonrealDecl::get_traversalSuccessorByIndex(size_t idx) {
10975 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgNonrealDecl" << " that has no successors!" << endl;
10976 0 : ROSE_ASSERT(false);
10977 : return NULL;
10978 : }
10979 : size_t
10980 0 : SgNonrealDecl::get_childIndex(SgNode *child) {
10981 0 : cout << "error: get_childIndex called on node of type " << "SgNonrealDecl" << " that has no successors!" << endl;
10982 0 : ROSE_ASSERT(false);
10983 : return 0;
10984 : }
10985 : vector<SgNode*>
10986 0 : SgEmptyDeclaration::get_traversalSuccessorContainer() {
10987 0 : vector<SgNode*> traversalSuccessorContainer;
10988 0 : return traversalSuccessorContainer;
10989 : }
10990 : vector<string>
10991 0 : SgEmptyDeclaration::get_traversalSuccessorNamesContainer() {
10992 0 : vector<string> traversalSuccessorContainer;
10993 0 : return traversalSuccessorContainer;
10994 : }
10995 : size_t
10996 0 : SgEmptyDeclaration::get_numberOfTraversalSuccessors() {
10997 0 : return 0;
10998 : }
10999 : SgNode *
11000 0 : SgEmptyDeclaration::get_traversalSuccessorByIndex(size_t idx) {
11001 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgEmptyDeclaration" << " that has no successors!" << endl;
11002 0 : ROSE_ASSERT(false);
11003 : return NULL;
11004 : }
11005 : size_t
11006 0 : SgEmptyDeclaration::get_childIndex(SgNode *child) {
11007 0 : cout << "error: get_childIndex called on node of type " << "SgEmptyDeclaration" << " that has no successors!" << endl;
11008 0 : ROSE_ASSERT(false);
11009 : return 0;
11010 : }
11011 : vector<SgNode*>
11012 604145 : SgExprStatement::get_traversalSuccessorContainer() {
11013 604145 : vector<SgNode*> traversalSuccessorContainer;
11014 604145 : traversalSuccessorContainer.reserve(1);
11015 604145 : traversalSuccessorContainer.push_back(p_expression);
11016 604145 : return traversalSuccessorContainer;
11017 : }
11018 : vector<string>
11019 33341 : SgExprStatement::get_traversalSuccessorNamesContainer() {
11020 33341 : vector<string> traversalSuccessorContainer;
11021 66682 : traversalSuccessorContainer.push_back("p_expression");
11022 33341 : return traversalSuccessorContainer;
11023 : }
11024 : size_t
11025 1429490 : SgExprStatement::get_numberOfTraversalSuccessors() {
11026 1429490 : return 1;
11027 : }
11028 : SgNode *
11029 1428570 : SgExprStatement::get_traversalSuccessorByIndex(size_t idx) {
11030 1428570 : switch (idx) {
11031 1428570 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
11032 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
11033 0 : ROSE_ASSERT(false);
11034 : return NULL;
11035 : }
11036 : }
11037 : size_t
11038 0 : SgExprStatement::get_childIndex(SgNode *child) {
11039 0 : if (child == p_expression) return 0;
11040 0 : else return (size_t) -1;
11041 : }
11042 : vector<SgNode*>
11043 37 : SgLabelStatement::get_traversalSuccessorContainer() {
11044 37 : vector<SgNode*> traversalSuccessorContainer;
11045 37 : traversalSuccessorContainer.reserve(1);
11046 37 : traversalSuccessorContainer.push_back(p_statement);
11047 37 : return traversalSuccessorContainer;
11048 : }
11049 : vector<string>
11050 18 : SgLabelStatement::get_traversalSuccessorNamesContainer() {
11051 18 : vector<string> traversalSuccessorContainer;
11052 36 : traversalSuccessorContainer.push_back("p_statement");
11053 18 : return traversalSuccessorContainer;
11054 : }
11055 : size_t
11056 303 : SgLabelStatement::get_numberOfTraversalSuccessors() {
11057 303 : return 1;
11058 : }
11059 : SgNode *
11060 303 : SgLabelStatement::get_traversalSuccessorByIndex(size_t idx) {
11061 303 : switch (idx) {
11062 303 : case 0: ROSE_ASSERT(p_statement == NULL || p_statement != NULL); return p_statement;
11063 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
11064 0 : ROSE_ASSERT(false);
11065 : return NULL;
11066 : }
11067 : }
11068 : size_t
11069 0 : SgLabelStatement::get_childIndex(SgNode *child) {
11070 0 : if (child == p_statement) return 0;
11071 0 : else return (size_t) -1;
11072 : }
11073 : vector<SgNode*>
11074 7 : SgCaseOptionStmt::get_traversalSuccessorContainer() {
11075 7 : vector<SgNode*> traversalSuccessorContainer;
11076 7 : traversalSuccessorContainer.reserve(3);
11077 7 : traversalSuccessorContainer.push_back(p_key);
11078 7 : traversalSuccessorContainer.push_back(p_body);
11079 7 : traversalSuccessorContainer.push_back(p_key_range_end);
11080 7 : return traversalSuccessorContainer;
11081 : }
11082 : vector<string>
11083 0 : SgCaseOptionStmt::get_traversalSuccessorNamesContainer() {
11084 0 : vector<string> traversalSuccessorContainer;
11085 0 : traversalSuccessorContainer.push_back("p_key");
11086 0 : traversalSuccessorContainer.push_back("p_body");
11087 0 : traversalSuccessorContainer.push_back("p_key_range_end");
11088 0 : return traversalSuccessorContainer;
11089 : }
11090 : size_t
11091 38 : SgCaseOptionStmt::get_numberOfTraversalSuccessors() {
11092 38 : return 3;
11093 : }
11094 : SgNode *
11095 114 : SgCaseOptionStmt::get_traversalSuccessorByIndex(size_t idx) {
11096 114 : switch (idx) {
11097 38 : case 0: ROSE_ASSERT(p_key == NULL || p_key != NULL); return p_key;
11098 38 : case 1: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
11099 38 : case 2: ROSE_ASSERT(p_key_range_end == NULL || p_key_range_end != NULL); return p_key_range_end;
11100 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
11101 0 : ROSE_ASSERT(false);
11102 : return NULL;
11103 : }
11104 : }
11105 : size_t
11106 0 : SgCaseOptionStmt::get_childIndex(SgNode *child) {
11107 0 : if (child == p_key) return 0;
11108 0 : else if (child == p_body) return 1;
11109 0 : else if (child == p_key_range_end) return 2;
11110 0 : else return (size_t) -1;
11111 : }
11112 : vector<SgNode*>
11113 18301 : SgTryStmt::get_traversalSuccessorContainer() {
11114 18301 : vector<SgNode*> traversalSuccessorContainer;
11115 18301 : traversalSuccessorContainer.reserve(4);
11116 18301 : traversalSuccessorContainer.push_back(p_body);
11117 18301 : traversalSuccessorContainer.push_back(p_catch_statement_seq_root);
11118 18301 : traversalSuccessorContainer.push_back(p_else_body);
11119 18301 : traversalSuccessorContainer.push_back(p_finally_body);
11120 18301 : return traversalSuccessorContainer;
11121 : }
11122 : vector<string>
11123 704 : SgTryStmt::get_traversalSuccessorNamesContainer() {
11124 704 : vector<string> traversalSuccessorContainer;
11125 1408 : traversalSuccessorContainer.push_back("p_body");
11126 1408 : traversalSuccessorContainer.push_back("p_catch_statement_seq_root");
11127 1408 : traversalSuccessorContainer.push_back("p_else_body");
11128 1408 : traversalSuccessorContainer.push_back("p_finally_body");
11129 704 : return traversalSuccessorContainer;
11130 : }
11131 : size_t
11132 36782 : SgTryStmt::get_numberOfTraversalSuccessors() {
11133 36782 : return 4;
11134 : }
11135 : SgNode *
11136 146344 : SgTryStmt::get_traversalSuccessorByIndex(size_t idx) {
11137 146344 : switch (idx) {
11138 36614 : case 0: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
11139 36614 : case 1: ROSE_ASSERT(p_catch_statement_seq_root == NULL || p_catch_statement_seq_root != NULL); return p_catch_statement_seq_root;
11140 36558 : case 2: ROSE_ASSERT(p_else_body == NULL || p_else_body != NULL); return p_else_body;
11141 36558 : case 3: ROSE_ASSERT(p_finally_body == NULL || p_finally_body != NULL); return p_finally_body;
11142 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
11143 0 : ROSE_ASSERT(false);
11144 : return NULL;
11145 : }
11146 : }
11147 : size_t
11148 0 : SgTryStmt::get_childIndex(SgNode *child) {
11149 0 : if (child == p_body) return 0;
11150 0 : else if (child == p_catch_statement_seq_root) return 1;
11151 0 : else if (child == p_else_body) return 2;
11152 0 : else if (child == p_finally_body) return 3;
11153 0 : else return (size_t) -1;
11154 : }
11155 : vector<SgNode*>
11156 7 : SgDefaultOptionStmt::get_traversalSuccessorContainer() {
11157 7 : vector<SgNode*> traversalSuccessorContainer;
11158 7 : traversalSuccessorContainer.reserve(1);
11159 7 : traversalSuccessorContainer.push_back(p_body);
11160 7 : return traversalSuccessorContainer;
11161 : }
11162 : vector<string>
11163 0 : SgDefaultOptionStmt::get_traversalSuccessorNamesContainer() {
11164 0 : vector<string> traversalSuccessorContainer;
11165 0 : traversalSuccessorContainer.push_back("p_body");
11166 0 : return traversalSuccessorContainer;
11167 : }
11168 : size_t
11169 38 : SgDefaultOptionStmt::get_numberOfTraversalSuccessors() {
11170 38 : return 1;
11171 : }
11172 : SgNode *
11173 38 : SgDefaultOptionStmt::get_traversalSuccessorByIndex(size_t idx) {
11174 38 : switch (idx) {
11175 38 : case 0: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
11176 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
11177 0 : ROSE_ASSERT(false);
11178 : return NULL;
11179 : }
11180 : }
11181 : size_t
11182 0 : SgDefaultOptionStmt::get_childIndex(SgNode *child) {
11183 0 : if (child == p_body) return 0;
11184 0 : else return (size_t) -1;
11185 : }
11186 : vector<SgNode*>
11187 871 : SgBreakStmt::get_traversalSuccessorContainer() {
11188 871 : vector<SgNode*> traversalSuccessorContainer;
11189 871 : return traversalSuccessorContainer;
11190 : }
11191 : vector<string>
11192 360 : SgBreakStmt::get_traversalSuccessorNamesContainer() {
11193 360 : vector<string> traversalSuccessorContainer;
11194 360 : return traversalSuccessorContainer;
11195 : }
11196 : size_t
11197 9508 : SgBreakStmt::get_numberOfTraversalSuccessors() {
11198 9508 : return 0;
11199 : }
11200 : SgNode *
11201 0 : SgBreakStmt::get_traversalSuccessorByIndex(size_t idx) {
11202 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgBreakStmt" << " that has no successors!" << endl;
11203 0 : ROSE_ASSERT(false);
11204 : return NULL;
11205 : }
11206 : size_t
11207 0 : SgBreakStmt::get_childIndex(SgNode *child) {
11208 0 : cout << "error: get_childIndex called on node of type " << "SgBreakStmt" << " that has no successors!" << endl;
11209 0 : ROSE_ASSERT(false);
11210 : return 0;
11211 : }
11212 : vector<SgNode*>
11213 65 : SgContinueStmt::get_traversalSuccessorContainer() {
11214 65 : vector<SgNode*> traversalSuccessorContainer;
11215 65 : return traversalSuccessorContainer;
11216 : }
11217 : vector<string>
11218 24 : SgContinueStmt::get_traversalSuccessorNamesContainer() {
11219 24 : vector<string> traversalSuccessorContainer;
11220 24 : return traversalSuccessorContainer;
11221 : }
11222 : size_t
11223 633 : SgContinueStmt::get_numberOfTraversalSuccessors() {
11224 633 : return 0;
11225 : }
11226 : SgNode *
11227 0 : SgContinueStmt::get_traversalSuccessorByIndex(size_t idx) {
11228 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgContinueStmt" << " that has no successors!" << endl;
11229 0 : ROSE_ASSERT(false);
11230 : return NULL;
11231 : }
11232 : size_t
11233 0 : SgContinueStmt::get_childIndex(SgNode *child) {
11234 0 : cout << "error: get_childIndex called on node of type " << "SgContinueStmt" << " that has no successors!" << endl;
11235 0 : ROSE_ASSERT(false);
11236 : return 0;
11237 : }
11238 : vector<SgNode*>
11239 550923 : SgReturnStmt::get_traversalSuccessorContainer() {
11240 550923 : vector<SgNode*> traversalSuccessorContainer;
11241 550923 : traversalSuccessorContainer.reserve(1);
11242 550923 : traversalSuccessorContainer.push_back(p_expression);
11243 550923 : return traversalSuccessorContainer;
11244 : }
11245 : vector<string>
11246 20950 : SgReturnStmt::get_traversalSuccessorNamesContainer() {
11247 20950 : vector<string> traversalSuccessorContainer;
11248 41900 : traversalSuccessorContainer.push_back("p_expression");
11249 20950 : return traversalSuccessorContainer;
11250 : }
11251 : size_t
11252 1056530 : SgReturnStmt::get_numberOfTraversalSuccessors() {
11253 1056530 : return 1;
11254 : }
11255 : SgNode *
11256 1055720 : SgReturnStmt::get_traversalSuccessorByIndex(size_t idx) {
11257 1055720 : switch (idx) {
11258 1055720 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
11259 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
11260 0 : ROSE_ASSERT(false);
11261 : return NULL;
11262 : }
11263 : }
11264 : size_t
11265 0 : SgReturnStmt::get_childIndex(SgNode *child) {
11266 0 : if (child == p_expression) return 0;
11267 0 : else return (size_t) -1;
11268 : }
11269 : vector<SgNode*>
11270 13 : SgGotoStatement::get_traversalSuccessorContainer() {
11271 13 : vector<SgNode*> traversalSuccessorContainer;
11272 13 : return traversalSuccessorContainer;
11273 : }
11274 : vector<string>
11275 6 : SgGotoStatement::get_traversalSuccessorNamesContainer() {
11276 6 : vector<string> traversalSuccessorContainer;
11277 6 : return traversalSuccessorContainer;
11278 : }
11279 : size_t
11280 90 : SgGotoStatement::get_numberOfTraversalSuccessors() {
11281 90 : return 0;
11282 : }
11283 : SgNode *
11284 0 : SgGotoStatement::get_traversalSuccessorByIndex(size_t idx) {
11285 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgGotoStatement" << " that has no successors!" << endl;
11286 0 : ROSE_ASSERT(false);
11287 : return NULL;
11288 : }
11289 : size_t
11290 0 : SgGotoStatement::get_childIndex(SgNode *child) {
11291 0 : cout << "error: get_childIndex called on node of type " << "SgGotoStatement" << " that has no successors!" << endl;
11292 0 : ROSE_ASSERT(false);
11293 : return 0;
11294 : }
11295 : vector<SgNode*>
11296 0 : SgSpawnStmt::get_traversalSuccessorContainer() {
11297 0 : vector<SgNode*> traversalSuccessorContainer;
11298 0 : traversalSuccessorContainer.reserve(1);
11299 0 : traversalSuccessorContainer.push_back(p_the_func);
11300 0 : return traversalSuccessorContainer;
11301 : }
11302 : vector<string>
11303 0 : SgSpawnStmt::get_traversalSuccessorNamesContainer() {
11304 0 : vector<string> traversalSuccessorContainer;
11305 0 : traversalSuccessorContainer.push_back("p_the_func");
11306 0 : return traversalSuccessorContainer;
11307 : }
11308 : size_t
11309 0 : SgSpawnStmt::get_numberOfTraversalSuccessors() {
11310 0 : return 1;
11311 : }
11312 : SgNode *
11313 0 : SgSpawnStmt::get_traversalSuccessorByIndex(size_t idx) {
11314 0 : switch (idx) {
11315 0 : case 0: ROSE_ASSERT(p_the_func == NULL || p_the_func != NULL); return p_the_func;
11316 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
11317 0 : ROSE_ASSERT(false);
11318 : return NULL;
11319 : }
11320 : }
11321 : size_t
11322 0 : SgSpawnStmt::get_childIndex(SgNode *child) {
11323 0 : if (child == p_the_func) return 0;
11324 0 : else return (size_t) -1;
11325 : }
11326 : vector<SgNode*>
11327 21232 : SgNullStatement::get_traversalSuccessorContainer() {
11328 21232 : vector<SgNode*> traversalSuccessorContainer;
11329 21232 : return traversalSuccessorContainer;
11330 : }
11331 : vector<string>
11332 312 : SgNullStatement::get_traversalSuccessorNamesContainer() {
11333 312 : vector<string> traversalSuccessorContainer;
11334 312 : return traversalSuccessorContainer;
11335 : }
11336 : size_t
11337 29807 : SgNullStatement::get_numberOfTraversalSuccessors() {
11338 29807 : return 0;
11339 : }
11340 : SgNode *
11341 0 : SgNullStatement::get_traversalSuccessorByIndex(size_t idx) {
11342 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgNullStatement" << " that has no successors!" << endl;
11343 0 : ROSE_ASSERT(false);
11344 : return NULL;
11345 : }
11346 : size_t
11347 0 : SgNullStatement::get_childIndex(SgNode *child) {
11348 0 : cout << "error: get_childIndex called on node of type " << "SgNullStatement" << " that has no successors!" << endl;
11349 0 : ROSE_ASSERT(false);
11350 : return 0;
11351 : }
11352 : vector<SgNode*>
11353 0 : SgVariantStatement::get_traversalSuccessorContainer() {
11354 0 : vector<SgNode*> traversalSuccessorContainer;
11355 0 : return traversalSuccessorContainer;
11356 : }
11357 : vector<string>
11358 0 : SgVariantStatement::get_traversalSuccessorNamesContainer() {
11359 0 : vector<string> traversalSuccessorContainer;
11360 0 : return traversalSuccessorContainer;
11361 : }
11362 : size_t
11363 0 : SgVariantStatement::get_numberOfTraversalSuccessors() {
11364 0 : return 0;
11365 : }
11366 : SgNode *
11367 0 : SgVariantStatement::get_traversalSuccessorByIndex(size_t idx) {
11368 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgVariantStatement" << " that has no successors!" << endl;
11369 0 : ROSE_ASSERT(false);
11370 : return NULL;
11371 : }
11372 : size_t
11373 0 : SgVariantStatement::get_childIndex(SgNode *child) {
11374 0 : cout << "error: get_childIndex called on node of type " << "SgVariantStatement" << " that has no successors!" << endl;
11375 0 : ROSE_ASSERT(false);
11376 : return 0;
11377 : }
11378 : vector<SgNode*>
11379 33267 : SgForInitStatement::get_traversalSuccessorContainer() {
11380 33267 : vector<SgNode*> traversalSuccessorContainer;
11381 33267 : traversalSuccessorContainer.reserve(p_init_stmt.size() + 0);
11382 33267 : {
11383 33267 : SgStatementPtrList::iterator iter;
11384 66534 : for (iter = p_init_stmt.begin(); iter != p_init_stmt.end(); iter++)
11385 33267 : traversalSuccessorContainer.push_back(*iter);
11386 : }
11387 33267 : return traversalSuccessorContainer;
11388 : }
11389 : vector<string>
11390 1681 : SgForInitStatement::get_traversalSuccessorNamesContainer() {
11391 1681 : vector<string> traversalSuccessorContainer;
11392 1681 : int i = 0;
11393 1681 : {
11394 1681 : SgStatementPtrList::iterator iter;
11395 3362 : for (iter = p_init_stmt.begin(); iter != p_init_stmt.end(); (iter++,i++)) {
11396 1681 : char buf[20];
11397 1681 : sprintf(buf,"*[%d]",i);
11398 3362 : traversalSuccessorContainer.push_back(buf);
11399 : }
11400 : }
11401 1681 : return traversalSuccessorContainer;
11402 : }
11403 : size_t
11404 63275 : SgForInitStatement::get_numberOfTraversalSuccessors() {
11405 63275 : return p_init_stmt.size() + 0;
11406 : }
11407 : SgNode *
11408 63225 : SgForInitStatement::get_traversalSuccessorByIndex(size_t idx) {
11409 63225 : ROSE_ASSERT(idx < p_init_stmt.size());
11410 63225 : return p_init_stmt[idx];
11411 : }
11412 : size_t
11413 0 : SgForInitStatement::get_childIndex(SgNode *child) {
11414 0 : SgStatementPtrList::iterator itr = find(p_init_stmt.begin(), p_init_stmt.end(), child);
11415 0 : if (itr != p_init_stmt.end()) return itr - p_init_stmt.begin();
11416 : else return (size_t) -1;
11417 : }
11418 : vector<SgNode*>
11419 18301 : SgCatchStatementSeq::get_traversalSuccessorContainer() {
11420 18301 : vector<SgNode*> traversalSuccessorContainer;
11421 18301 : traversalSuccessorContainer.reserve(p_catch_statement_seq.size() + 0);
11422 18301 : {
11423 18301 : SgStatementPtrList::iterator iter;
11424 37570 : for (iter = p_catch_statement_seq.begin(); iter != p_catch_statement_seq.end(); iter++)
11425 19269 : traversalSuccessorContainer.push_back(*iter);
11426 : }
11427 18301 : return traversalSuccessorContainer;
11428 : }
11429 : vector<string>
11430 1056 : SgCatchStatementSeq::get_traversalSuccessorNamesContainer() {
11431 1056 : vector<string> traversalSuccessorContainer;
11432 1056 : int i = 0;
11433 1056 : {
11434 1056 : SgStatementPtrList::iterator iter;
11435 2760 : for (iter = p_catch_statement_seq.begin(); iter != p_catch_statement_seq.end(); (iter++,i++)) {
11436 1704 : char buf[20];
11437 1704 : sprintf(buf,"*[%d]",i);
11438 3408 : traversalSuccessorContainer.push_back(buf);
11439 : }
11440 : }
11441 1056 : return traversalSuccessorContainer;
11442 : }
11443 : size_t
11444 36642 : SgCatchStatementSeq::get_numberOfTraversalSuccessors() {
11445 36642 : return p_catch_statement_seq.size() + 0;
11446 : }
11447 : SgNode *
11448 47987 : SgCatchStatementSeq::get_traversalSuccessorByIndex(size_t idx) {
11449 47987 : ROSE_ASSERT(idx < p_catch_statement_seq.size());
11450 47987 : return p_catch_statement_seq[idx];
11451 : }
11452 : size_t
11453 0 : SgCatchStatementSeq::get_childIndex(SgNode *child) {
11454 0 : SgStatementPtrList::iterator itr = find(p_catch_statement_seq.begin(), p_catch_statement_seq.end(), child);
11455 0 : if (itr != p_catch_statement_seq.end()) return itr - p_catch_statement_seq.begin();
11456 : else return (size_t) -1;
11457 : }
11458 : vector<SgNode*>
11459 4 : SgProcessControlStatement::get_traversalSuccessorContainer() {
11460 4 : vector<SgNode*> traversalSuccessorContainer;
11461 4 : traversalSuccessorContainer.reserve(2);
11462 4 : traversalSuccessorContainer.push_back(p_code);
11463 4 : traversalSuccessorContainer.push_back(p_quiet);
11464 4 : return traversalSuccessorContainer;
11465 : }
11466 : vector<string>
11467 2 : SgProcessControlStatement::get_traversalSuccessorNamesContainer() {
11468 2 : vector<string> traversalSuccessorContainer;
11469 4 : traversalSuccessorContainer.push_back("p_code");
11470 4 : traversalSuccessorContainer.push_back("p_quiet");
11471 2 : return traversalSuccessorContainer;
11472 : }
11473 : size_t
11474 41 : SgProcessControlStatement::get_numberOfTraversalSuccessors() {
11475 41 : return 2;
11476 : }
11477 : SgNode *
11478 82 : SgProcessControlStatement::get_traversalSuccessorByIndex(size_t idx) {
11479 82 : switch (idx) {
11480 41 : case 0: ROSE_ASSERT(p_code == NULL || p_code != NULL); return p_code;
11481 41 : case 1: ROSE_ASSERT(p_quiet == NULL || p_quiet != NULL); return p_quiet;
11482 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
11483 0 : ROSE_ASSERT(false);
11484 : return NULL;
11485 : }
11486 : }
11487 : size_t
11488 0 : SgProcessControlStatement::get_childIndex(SgNode *child) {
11489 0 : if (child == p_code) return 0;
11490 0 : else if (child == p_quiet) return 1;
11491 0 : else return (size_t) -1;
11492 : }
11493 : vector<SgNode*>
11494 0 : SgIOStatement::get_traversalSuccessorContainer() {
11495 0 : vector<SgNode*> traversalSuccessorContainer;
11496 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
11497 0 : << "static: SgIOStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
11498 0 : cerr << "Aborting ..." << endl;
11499 0 : ROSE_ASSERT(false);
11500 : return traversalSuccessorContainer;
11501 : }
11502 :
11503 : vector<string>
11504 0 : SgIOStatement::get_traversalSuccessorNamesContainer() {
11505 0 : vector<string> traversalSuccessorContainer;
11506 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
11507 0 : << "static: SgIOStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
11508 0 : cerr << "Aborting ..." << endl;
11509 0 : ROSE_ASSERT(false);
11510 : return traversalSuccessorContainer;
11511 : }
11512 :
11513 : size_t
11514 0 : SgIOStatement::get_numberOfTraversalSuccessors() {
11515 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
11516 0 : << "static: SgIOStatement" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
11517 0 : cerr << "Aborting ..." << endl;
11518 0 : ROSE_ASSERT(false);
11519 : return 42;
11520 : }
11521 :
11522 : SgNode*
11523 0 : SgIOStatement::get_traversalSuccessorByIndex(size_t) {
11524 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
11525 0 : << "static: SgIOStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
11526 0 : cerr << "Aborting ..." << endl;
11527 0 : ROSE_ASSERT(false);
11528 : return NULL;
11529 : }
11530 :
11531 : size_t
11532 0 : SgIOStatement::get_childIndex(SgNode *) {
11533 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
11534 0 : << "static: SgIOStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
11535 0 : cerr << "Aborting ..." << endl;
11536 0 : ROSE_ASSERT(false);
11537 : return 42;
11538 : }
11539 :
11540 : vector<SgNode*>
11541 221 : SgPrintStatement::get_traversalSuccessorContainer() {
11542 221 : vector<SgNode*> traversalSuccessorContainer;
11543 221 : traversalSuccessorContainer.reserve(6);
11544 221 : traversalSuccessorContainer.push_back(p_io_stmt_list);
11545 221 : traversalSuccessorContainer.push_back(p_unit);
11546 221 : traversalSuccessorContainer.push_back(p_iostat);
11547 221 : traversalSuccessorContainer.push_back(p_err);
11548 221 : traversalSuccessorContainer.push_back(p_iomsg);
11549 221 : traversalSuccessorContainer.push_back(p_format);
11550 221 : return traversalSuccessorContainer;
11551 : }
11552 : vector<string>
11553 108 : SgPrintStatement::get_traversalSuccessorNamesContainer() {
11554 108 : vector<string> traversalSuccessorContainer;
11555 216 : traversalSuccessorContainer.push_back("p_io_stmt_list");
11556 216 : traversalSuccessorContainer.push_back("p_unit");
11557 216 : traversalSuccessorContainer.push_back("p_iostat");
11558 216 : traversalSuccessorContainer.push_back("p_err");
11559 216 : traversalSuccessorContainer.push_back("p_iomsg");
11560 216 : traversalSuccessorContainer.push_back("p_format");
11561 108 : return traversalSuccessorContainer;
11562 : }
11563 : size_t
11564 2284 : SgPrintStatement::get_numberOfTraversalSuccessors() {
11565 2284 : return 6;
11566 : }
11567 : SgNode *
11568 13704 : SgPrintStatement::get_traversalSuccessorByIndex(size_t idx) {
11569 13704 : switch (idx) {
11570 2284 : case 0: ROSE_ASSERT(p_io_stmt_list == NULL || p_io_stmt_list != NULL); return p_io_stmt_list;
11571 2284 : case 1: ROSE_ASSERT(p_unit == NULL || p_unit != NULL); return p_unit;
11572 2284 : case 2: ROSE_ASSERT(p_iostat == NULL || p_iostat != NULL); return p_iostat;
11573 2284 : case 3: ROSE_ASSERT(p_err == NULL || p_err != NULL); return p_err;
11574 2284 : case 4: ROSE_ASSERT(p_iomsg == NULL || p_iomsg != NULL); return p_iomsg;
11575 2284 : case 5: ROSE_ASSERT(p_format == NULL || p_format != NULL); return p_format;
11576 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
11577 0 : ROSE_ASSERT(false);
11578 : return NULL;
11579 : }
11580 : }
11581 : size_t
11582 0 : SgPrintStatement::get_childIndex(SgNode *child) {
11583 0 : if (child == p_io_stmt_list) return 0;
11584 0 : else if (child == p_unit) return 1;
11585 0 : else if (child == p_iostat) return 2;
11586 0 : else if (child == p_err) return 3;
11587 0 : else if (child == p_iomsg) return 4;
11588 0 : else if (child == p_format) return 5;
11589 0 : else return (size_t) -1;
11590 : }
11591 : vector<SgNode*>
11592 0 : SgReadStatement::get_traversalSuccessorContainer() {
11593 0 : vector<SgNode*> traversalSuccessorContainer;
11594 0 : traversalSuccessorContainer.reserve(21);
11595 0 : traversalSuccessorContainer.push_back(p_io_stmt_list);
11596 0 : traversalSuccessorContainer.push_back(p_unit);
11597 0 : traversalSuccessorContainer.push_back(p_iostat);
11598 0 : traversalSuccessorContainer.push_back(p_err);
11599 0 : traversalSuccessorContainer.push_back(p_iomsg);
11600 0 : traversalSuccessorContainer.push_back(p_format);
11601 0 : traversalSuccessorContainer.push_back(p_namelist);
11602 0 : traversalSuccessorContainer.push_back(p_advance);
11603 0 : traversalSuccessorContainer.push_back(p_asynchronous);
11604 0 : traversalSuccessorContainer.push_back(p_blank);
11605 0 : traversalSuccessorContainer.push_back(p_decimal);
11606 0 : traversalSuccessorContainer.push_back(p_delim);
11607 0 : traversalSuccessorContainer.push_back(p_end);
11608 0 : traversalSuccessorContainer.push_back(p_eor);
11609 0 : traversalSuccessorContainer.push_back(p_id);
11610 0 : traversalSuccessorContainer.push_back(p_pad);
11611 0 : traversalSuccessorContainer.push_back(p_pos);
11612 0 : traversalSuccessorContainer.push_back(p_rec);
11613 0 : traversalSuccessorContainer.push_back(p_round);
11614 0 : traversalSuccessorContainer.push_back(p_sign);
11615 0 : traversalSuccessorContainer.push_back(p_size);
11616 0 : return traversalSuccessorContainer;
11617 : }
11618 : vector<string>
11619 0 : SgReadStatement::get_traversalSuccessorNamesContainer() {
11620 0 : vector<string> traversalSuccessorContainer;
11621 0 : traversalSuccessorContainer.push_back("p_io_stmt_list");
11622 0 : traversalSuccessorContainer.push_back("p_unit");
11623 0 : traversalSuccessorContainer.push_back("p_iostat");
11624 0 : traversalSuccessorContainer.push_back("p_err");
11625 0 : traversalSuccessorContainer.push_back("p_iomsg");
11626 0 : traversalSuccessorContainer.push_back("p_format");
11627 0 : traversalSuccessorContainer.push_back("p_namelist");
11628 0 : traversalSuccessorContainer.push_back("p_advance");
11629 0 : traversalSuccessorContainer.push_back("p_asynchronous");
11630 0 : traversalSuccessorContainer.push_back("p_blank");
11631 0 : traversalSuccessorContainer.push_back("p_decimal");
11632 0 : traversalSuccessorContainer.push_back("p_delim");
11633 0 : traversalSuccessorContainer.push_back("p_end");
11634 0 : traversalSuccessorContainer.push_back("p_eor");
11635 0 : traversalSuccessorContainer.push_back("p_id");
11636 0 : traversalSuccessorContainer.push_back("p_pad");
11637 0 : traversalSuccessorContainer.push_back("p_pos");
11638 0 : traversalSuccessorContainer.push_back("p_rec");
11639 0 : traversalSuccessorContainer.push_back("p_round");
11640 0 : traversalSuccessorContainer.push_back("p_sign");
11641 0 : traversalSuccessorContainer.push_back("p_size");
11642 0 : return traversalSuccessorContainer;
11643 : }
11644 : size_t
11645 0 : SgReadStatement::get_numberOfTraversalSuccessors() {
11646 0 : return 21;
11647 : }
11648 : SgNode *
11649 0 : SgReadStatement::get_traversalSuccessorByIndex(size_t idx) {
11650 0 : switch (idx) {
11651 0 : case 0: ROSE_ASSERT(p_io_stmt_list == NULL || p_io_stmt_list != NULL); return p_io_stmt_list;
11652 0 : case 1: ROSE_ASSERT(p_unit == NULL || p_unit != NULL); return p_unit;
11653 0 : case 2: ROSE_ASSERT(p_iostat == NULL || p_iostat != NULL); return p_iostat;
11654 0 : case 3: ROSE_ASSERT(p_err == NULL || p_err != NULL); return p_err;
11655 0 : case 4: ROSE_ASSERT(p_iomsg == NULL || p_iomsg != NULL); return p_iomsg;
11656 0 : case 5: ROSE_ASSERT(p_format == NULL || p_format != NULL); return p_format;
11657 0 : case 6: ROSE_ASSERT(p_namelist == NULL || p_namelist != NULL); return p_namelist;
11658 0 : case 7: ROSE_ASSERT(p_advance == NULL || p_advance != NULL); return p_advance;
11659 0 : case 8: ROSE_ASSERT(p_asynchronous == NULL || p_asynchronous != NULL); return p_asynchronous;
11660 0 : case 9: ROSE_ASSERT(p_blank == NULL || p_blank != NULL); return p_blank;
11661 0 : case 10: ROSE_ASSERT(p_decimal == NULL || p_decimal != NULL); return p_decimal;
11662 0 : case 11: ROSE_ASSERT(p_delim == NULL || p_delim != NULL); return p_delim;
11663 0 : case 12: ROSE_ASSERT(p_end == NULL || p_end != NULL); return p_end;
11664 0 : case 13: ROSE_ASSERT(p_eor == NULL || p_eor != NULL); return p_eor;
11665 0 : case 14: ROSE_ASSERT(p_id == NULL || p_id != NULL); return p_id;
11666 0 : case 15: ROSE_ASSERT(p_pad == NULL || p_pad != NULL); return p_pad;
11667 0 : case 16: ROSE_ASSERT(p_pos == NULL || p_pos != NULL); return p_pos;
11668 0 : case 17: ROSE_ASSERT(p_rec == NULL || p_rec != NULL); return p_rec;
11669 0 : case 18: ROSE_ASSERT(p_round == NULL || p_round != NULL); return p_round;
11670 0 : case 19: ROSE_ASSERT(p_sign == NULL || p_sign != NULL); return p_sign;
11671 0 : case 20: ROSE_ASSERT(p_size == NULL || p_size != NULL); return p_size;
11672 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
11673 0 : ROSE_ASSERT(false);
11674 : return NULL;
11675 : }
11676 : }
11677 : size_t
11678 0 : SgReadStatement::get_childIndex(SgNode *child) {
11679 0 : if (child == p_io_stmt_list) return 0;
11680 0 : else if (child == p_unit) return 1;
11681 0 : else if (child == p_iostat) return 2;
11682 0 : else if (child == p_err) return 3;
11683 0 : else if (child == p_iomsg) return 4;
11684 0 : else if (child == p_format) return 5;
11685 0 : else if (child == p_namelist) return 6;
11686 0 : else if (child == p_advance) return 7;
11687 0 : else if (child == p_asynchronous) return 8;
11688 0 : else if (child == p_blank) return 9;
11689 0 : else if (child == p_decimal) return 10;
11690 0 : else if (child == p_delim) return 11;
11691 0 : else if (child == p_end) return 12;
11692 0 : else if (child == p_eor) return 13;
11693 0 : else if (child == p_id) return 14;
11694 0 : else if (child == p_pad) return 15;
11695 0 : else if (child == p_pos) return 16;
11696 0 : else if (child == p_rec) return 17;
11697 0 : else if (child == p_round) return 18;
11698 0 : else if (child == p_sign) return 19;
11699 0 : else if (child == p_size) return 20;
11700 0 : else return (size_t) -1;
11701 : }
11702 : vector<SgNode*>
11703 28 : SgWriteStatement::get_traversalSuccessorContainer() {
11704 28 : vector<SgNode*> traversalSuccessorContainer;
11705 28 : traversalSuccessorContainer.reserve(21);
11706 28 : traversalSuccessorContainer.push_back(p_io_stmt_list);
11707 28 : traversalSuccessorContainer.push_back(p_unit);
11708 28 : traversalSuccessorContainer.push_back(p_iostat);
11709 28 : traversalSuccessorContainer.push_back(p_err);
11710 28 : traversalSuccessorContainer.push_back(p_iomsg);
11711 28 : traversalSuccessorContainer.push_back(p_format);
11712 28 : traversalSuccessorContainer.push_back(p_namelist);
11713 28 : traversalSuccessorContainer.push_back(p_advance);
11714 28 : traversalSuccessorContainer.push_back(p_asynchronous);
11715 28 : traversalSuccessorContainer.push_back(p_blank);
11716 28 : traversalSuccessorContainer.push_back(p_decimal);
11717 28 : traversalSuccessorContainer.push_back(p_delim);
11718 28 : traversalSuccessorContainer.push_back(p_end);
11719 28 : traversalSuccessorContainer.push_back(p_eor);
11720 28 : traversalSuccessorContainer.push_back(p_id);
11721 28 : traversalSuccessorContainer.push_back(p_pad);
11722 28 : traversalSuccessorContainer.push_back(p_pos);
11723 28 : traversalSuccessorContainer.push_back(p_rec);
11724 28 : traversalSuccessorContainer.push_back(p_round);
11725 28 : traversalSuccessorContainer.push_back(p_sign);
11726 28 : traversalSuccessorContainer.push_back(p_size);
11727 28 : return traversalSuccessorContainer;
11728 : }
11729 : vector<string>
11730 14 : SgWriteStatement::get_traversalSuccessorNamesContainer() {
11731 14 : vector<string> traversalSuccessorContainer;
11732 28 : traversalSuccessorContainer.push_back("p_io_stmt_list");
11733 28 : traversalSuccessorContainer.push_back("p_unit");
11734 28 : traversalSuccessorContainer.push_back("p_iostat");
11735 28 : traversalSuccessorContainer.push_back("p_err");
11736 28 : traversalSuccessorContainer.push_back("p_iomsg");
11737 28 : traversalSuccessorContainer.push_back("p_format");
11738 28 : traversalSuccessorContainer.push_back("p_namelist");
11739 28 : traversalSuccessorContainer.push_back("p_advance");
11740 28 : traversalSuccessorContainer.push_back("p_asynchronous");
11741 28 : traversalSuccessorContainer.push_back("p_blank");
11742 28 : traversalSuccessorContainer.push_back("p_decimal");
11743 28 : traversalSuccessorContainer.push_back("p_delim");
11744 28 : traversalSuccessorContainer.push_back("p_end");
11745 28 : traversalSuccessorContainer.push_back("p_eor");
11746 28 : traversalSuccessorContainer.push_back("p_id");
11747 28 : traversalSuccessorContainer.push_back("p_pad");
11748 28 : traversalSuccessorContainer.push_back("p_pos");
11749 28 : traversalSuccessorContainer.push_back("p_rec");
11750 28 : traversalSuccessorContainer.push_back("p_round");
11751 28 : traversalSuccessorContainer.push_back("p_sign");
11752 28 : traversalSuccessorContainer.push_back("p_size");
11753 14 : return traversalSuccessorContainer;
11754 : }
11755 : size_t
11756 294 : SgWriteStatement::get_numberOfTraversalSuccessors() {
11757 294 : return 21;
11758 : }
11759 : SgNode *
11760 6174 : SgWriteStatement::get_traversalSuccessorByIndex(size_t idx) {
11761 6174 : switch (idx) {
11762 294 : case 0: ROSE_ASSERT(p_io_stmt_list == NULL || p_io_stmt_list != NULL); return p_io_stmt_list;
11763 294 : case 1: ROSE_ASSERT(p_unit == NULL || p_unit != NULL); return p_unit;
11764 294 : case 2: ROSE_ASSERT(p_iostat == NULL || p_iostat != NULL); return p_iostat;
11765 294 : case 3: ROSE_ASSERT(p_err == NULL || p_err != NULL); return p_err;
11766 294 : case 4: ROSE_ASSERT(p_iomsg == NULL || p_iomsg != NULL); return p_iomsg;
11767 294 : case 5: ROSE_ASSERT(p_format == NULL || p_format != NULL); return p_format;
11768 294 : case 6: ROSE_ASSERT(p_namelist == NULL || p_namelist != NULL); return p_namelist;
11769 294 : case 7: ROSE_ASSERT(p_advance == NULL || p_advance != NULL); return p_advance;
11770 294 : case 8: ROSE_ASSERT(p_asynchronous == NULL || p_asynchronous != NULL); return p_asynchronous;
11771 294 : case 9: ROSE_ASSERT(p_blank == NULL || p_blank != NULL); return p_blank;
11772 294 : case 10: ROSE_ASSERT(p_decimal == NULL || p_decimal != NULL); return p_decimal;
11773 294 : case 11: ROSE_ASSERT(p_delim == NULL || p_delim != NULL); return p_delim;
11774 294 : case 12: ROSE_ASSERT(p_end == NULL || p_end != NULL); return p_end;
11775 294 : case 13: ROSE_ASSERT(p_eor == NULL || p_eor != NULL); return p_eor;
11776 294 : case 14: ROSE_ASSERT(p_id == NULL || p_id != NULL); return p_id;
11777 294 : case 15: ROSE_ASSERT(p_pad == NULL || p_pad != NULL); return p_pad;
11778 294 : case 16: ROSE_ASSERT(p_pos == NULL || p_pos != NULL); return p_pos;
11779 294 : case 17: ROSE_ASSERT(p_rec == NULL || p_rec != NULL); return p_rec;
11780 294 : case 18: ROSE_ASSERT(p_round == NULL || p_round != NULL); return p_round;
11781 294 : case 19: ROSE_ASSERT(p_sign == NULL || p_sign != NULL); return p_sign;
11782 294 : case 20: ROSE_ASSERT(p_size == NULL || p_size != NULL); return p_size;
11783 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
11784 0 : ROSE_ASSERT(false);
11785 : return NULL;
11786 : }
11787 : }
11788 : size_t
11789 0 : SgWriteStatement::get_childIndex(SgNode *child) {
11790 0 : if (child == p_io_stmt_list) return 0;
11791 0 : else if (child == p_unit) return 1;
11792 0 : else if (child == p_iostat) return 2;
11793 0 : else if (child == p_err) return 3;
11794 0 : else if (child == p_iomsg) return 4;
11795 0 : else if (child == p_format) return 5;
11796 0 : else if (child == p_namelist) return 6;
11797 0 : else if (child == p_advance) return 7;
11798 0 : else if (child == p_asynchronous) return 8;
11799 0 : else if (child == p_blank) return 9;
11800 0 : else if (child == p_decimal) return 10;
11801 0 : else if (child == p_delim) return 11;
11802 0 : else if (child == p_end) return 12;
11803 0 : else if (child == p_eor) return 13;
11804 0 : else if (child == p_id) return 14;
11805 0 : else if (child == p_pad) return 15;
11806 0 : else if (child == p_pos) return 16;
11807 0 : else if (child == p_rec) return 17;
11808 0 : else if (child == p_round) return 18;
11809 0 : else if (child == p_sign) return 19;
11810 0 : else if (child == p_size) return 20;
11811 0 : else return (size_t) -1;
11812 : }
11813 : vector<SgNode*>
11814 0 : SgOpenStatement::get_traversalSuccessorContainer() {
11815 0 : vector<SgNode*> traversalSuccessorContainer;
11816 0 : traversalSuccessorContainer.reserve(18);
11817 0 : traversalSuccessorContainer.push_back(p_io_stmt_list);
11818 0 : traversalSuccessorContainer.push_back(p_unit);
11819 0 : traversalSuccessorContainer.push_back(p_iostat);
11820 0 : traversalSuccessorContainer.push_back(p_err);
11821 0 : traversalSuccessorContainer.push_back(p_iomsg);
11822 0 : traversalSuccessorContainer.push_back(p_file);
11823 0 : traversalSuccessorContainer.push_back(p_status);
11824 0 : traversalSuccessorContainer.push_back(p_access);
11825 0 : traversalSuccessorContainer.push_back(p_form);
11826 0 : traversalSuccessorContainer.push_back(p_recl);
11827 0 : traversalSuccessorContainer.push_back(p_blank);
11828 0 : traversalSuccessorContainer.push_back(p_position);
11829 0 : traversalSuccessorContainer.push_back(p_action);
11830 0 : traversalSuccessorContainer.push_back(p_delim);
11831 0 : traversalSuccessorContainer.push_back(p_pad);
11832 0 : traversalSuccessorContainer.push_back(p_round);
11833 0 : traversalSuccessorContainer.push_back(p_sign);
11834 0 : traversalSuccessorContainer.push_back(p_asynchronous);
11835 0 : return traversalSuccessorContainer;
11836 : }
11837 : vector<string>
11838 0 : SgOpenStatement::get_traversalSuccessorNamesContainer() {
11839 0 : vector<string> traversalSuccessorContainer;
11840 0 : traversalSuccessorContainer.push_back("p_io_stmt_list");
11841 0 : traversalSuccessorContainer.push_back("p_unit");
11842 0 : traversalSuccessorContainer.push_back("p_iostat");
11843 0 : traversalSuccessorContainer.push_back("p_err");
11844 0 : traversalSuccessorContainer.push_back("p_iomsg");
11845 0 : traversalSuccessorContainer.push_back("p_file");
11846 0 : traversalSuccessorContainer.push_back("p_status");
11847 0 : traversalSuccessorContainer.push_back("p_access");
11848 0 : traversalSuccessorContainer.push_back("p_form");
11849 0 : traversalSuccessorContainer.push_back("p_recl");
11850 0 : traversalSuccessorContainer.push_back("p_blank");
11851 0 : traversalSuccessorContainer.push_back("p_position");
11852 0 : traversalSuccessorContainer.push_back("p_action");
11853 0 : traversalSuccessorContainer.push_back("p_delim");
11854 0 : traversalSuccessorContainer.push_back("p_pad");
11855 0 : traversalSuccessorContainer.push_back("p_round");
11856 0 : traversalSuccessorContainer.push_back("p_sign");
11857 0 : traversalSuccessorContainer.push_back("p_asynchronous");
11858 0 : return traversalSuccessorContainer;
11859 : }
11860 : size_t
11861 0 : SgOpenStatement::get_numberOfTraversalSuccessors() {
11862 0 : return 18;
11863 : }
11864 : SgNode *
11865 0 : SgOpenStatement::get_traversalSuccessorByIndex(size_t idx) {
11866 0 : switch (idx) {
11867 0 : case 0: ROSE_ASSERT(p_io_stmt_list == NULL || p_io_stmt_list != NULL); return p_io_stmt_list;
11868 0 : case 1: ROSE_ASSERT(p_unit == NULL || p_unit != NULL); return p_unit;
11869 0 : case 2: ROSE_ASSERT(p_iostat == NULL || p_iostat != NULL); return p_iostat;
11870 0 : case 3: ROSE_ASSERT(p_err == NULL || p_err != NULL); return p_err;
11871 0 : case 4: ROSE_ASSERT(p_iomsg == NULL || p_iomsg != NULL); return p_iomsg;
11872 0 : case 5: ROSE_ASSERT(p_file == NULL || p_file != NULL); return p_file;
11873 0 : case 6: ROSE_ASSERT(p_status == NULL || p_status != NULL); return p_status;
11874 0 : case 7: ROSE_ASSERT(p_access == NULL || p_access != NULL); return p_access;
11875 0 : case 8: ROSE_ASSERT(p_form == NULL || p_form != NULL); return p_form;
11876 0 : case 9: ROSE_ASSERT(p_recl == NULL || p_recl != NULL); return p_recl;
11877 0 : case 10: ROSE_ASSERT(p_blank == NULL || p_blank != NULL); return p_blank;
11878 0 : case 11: ROSE_ASSERT(p_position == NULL || p_position != NULL); return p_position;
11879 0 : case 12: ROSE_ASSERT(p_action == NULL || p_action != NULL); return p_action;
11880 0 : case 13: ROSE_ASSERT(p_delim == NULL || p_delim != NULL); return p_delim;
11881 0 : case 14: ROSE_ASSERT(p_pad == NULL || p_pad != NULL); return p_pad;
11882 0 : case 15: ROSE_ASSERT(p_round == NULL || p_round != NULL); return p_round;
11883 0 : case 16: ROSE_ASSERT(p_sign == NULL || p_sign != NULL); return p_sign;
11884 0 : case 17: ROSE_ASSERT(p_asynchronous == NULL || p_asynchronous != NULL); return p_asynchronous;
11885 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
11886 0 : ROSE_ASSERT(false);
11887 : return NULL;
11888 : }
11889 : }
11890 : size_t
11891 0 : SgOpenStatement::get_childIndex(SgNode *child) {
11892 0 : if (child == p_io_stmt_list) return 0;
11893 0 : else if (child == p_unit) return 1;
11894 0 : else if (child == p_iostat) return 2;
11895 0 : else if (child == p_err) return 3;
11896 0 : else if (child == p_iomsg) return 4;
11897 0 : else if (child == p_file) return 5;
11898 0 : else if (child == p_status) return 6;
11899 0 : else if (child == p_access) return 7;
11900 0 : else if (child == p_form) return 8;
11901 0 : else if (child == p_recl) return 9;
11902 0 : else if (child == p_blank) return 10;
11903 0 : else if (child == p_position) return 11;
11904 0 : else if (child == p_action) return 12;
11905 0 : else if (child == p_delim) return 13;
11906 0 : else if (child == p_pad) return 14;
11907 0 : else if (child == p_round) return 15;
11908 0 : else if (child == p_sign) return 16;
11909 0 : else if (child == p_asynchronous) return 17;
11910 0 : else return (size_t) -1;
11911 : }
11912 : vector<SgNode*>
11913 0 : SgCloseStatement::get_traversalSuccessorContainer() {
11914 0 : vector<SgNode*> traversalSuccessorContainer;
11915 0 : traversalSuccessorContainer.reserve(6);
11916 0 : traversalSuccessorContainer.push_back(p_io_stmt_list);
11917 0 : traversalSuccessorContainer.push_back(p_unit);
11918 0 : traversalSuccessorContainer.push_back(p_iostat);
11919 0 : traversalSuccessorContainer.push_back(p_err);
11920 0 : traversalSuccessorContainer.push_back(p_iomsg);
11921 0 : traversalSuccessorContainer.push_back(p_status);
11922 0 : return traversalSuccessorContainer;
11923 : }
11924 : vector<string>
11925 0 : SgCloseStatement::get_traversalSuccessorNamesContainer() {
11926 0 : vector<string> traversalSuccessorContainer;
11927 0 : traversalSuccessorContainer.push_back("p_io_stmt_list");
11928 0 : traversalSuccessorContainer.push_back("p_unit");
11929 0 : traversalSuccessorContainer.push_back("p_iostat");
11930 0 : traversalSuccessorContainer.push_back("p_err");
11931 0 : traversalSuccessorContainer.push_back("p_iomsg");
11932 0 : traversalSuccessorContainer.push_back("p_status");
11933 0 : return traversalSuccessorContainer;
11934 : }
11935 : size_t
11936 0 : SgCloseStatement::get_numberOfTraversalSuccessors() {
11937 0 : return 6;
11938 : }
11939 : SgNode *
11940 0 : SgCloseStatement::get_traversalSuccessorByIndex(size_t idx) {
11941 0 : switch (idx) {
11942 0 : case 0: ROSE_ASSERT(p_io_stmt_list == NULL || p_io_stmt_list != NULL); return p_io_stmt_list;
11943 0 : case 1: ROSE_ASSERT(p_unit == NULL || p_unit != NULL); return p_unit;
11944 0 : case 2: ROSE_ASSERT(p_iostat == NULL || p_iostat != NULL); return p_iostat;
11945 0 : case 3: ROSE_ASSERT(p_err == NULL || p_err != NULL); return p_err;
11946 0 : case 4: ROSE_ASSERT(p_iomsg == NULL || p_iomsg != NULL); return p_iomsg;
11947 0 : case 5: ROSE_ASSERT(p_status == NULL || p_status != NULL); return p_status;
11948 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
11949 0 : ROSE_ASSERT(false);
11950 : return NULL;
11951 : }
11952 : }
11953 : size_t
11954 0 : SgCloseStatement::get_childIndex(SgNode *child) {
11955 0 : if (child == p_io_stmt_list) return 0;
11956 0 : else if (child == p_unit) return 1;
11957 0 : else if (child == p_iostat) return 2;
11958 0 : else if (child == p_err) return 3;
11959 0 : else if (child == p_iomsg) return 4;
11960 0 : else if (child == p_status) return 5;
11961 0 : else return (size_t) -1;
11962 : }
11963 : vector<SgNode*>
11964 0 : SgInquireStatement::get_traversalSuccessorContainer() {
11965 0 : vector<SgNode*> traversalSuccessorContainer;
11966 0 : traversalSuccessorContainer.reserve(5);
11967 0 : traversalSuccessorContainer.push_back(p_io_stmt_list);
11968 0 : traversalSuccessorContainer.push_back(p_unit);
11969 0 : traversalSuccessorContainer.push_back(p_iostat);
11970 0 : traversalSuccessorContainer.push_back(p_err);
11971 0 : traversalSuccessorContainer.push_back(p_iomsg);
11972 0 : return traversalSuccessorContainer;
11973 : }
11974 : vector<string>
11975 0 : SgInquireStatement::get_traversalSuccessorNamesContainer() {
11976 0 : vector<string> traversalSuccessorContainer;
11977 0 : traversalSuccessorContainer.push_back("p_io_stmt_list");
11978 0 : traversalSuccessorContainer.push_back("p_unit");
11979 0 : traversalSuccessorContainer.push_back("p_iostat");
11980 0 : traversalSuccessorContainer.push_back("p_err");
11981 0 : traversalSuccessorContainer.push_back("p_iomsg");
11982 0 : return traversalSuccessorContainer;
11983 : }
11984 : size_t
11985 0 : SgInquireStatement::get_numberOfTraversalSuccessors() {
11986 0 : return 5;
11987 : }
11988 : SgNode *
11989 0 : SgInquireStatement::get_traversalSuccessorByIndex(size_t idx) {
11990 0 : switch (idx) {
11991 0 : case 0: ROSE_ASSERT(p_io_stmt_list == NULL || p_io_stmt_list != NULL); return p_io_stmt_list;
11992 0 : case 1: ROSE_ASSERT(p_unit == NULL || p_unit != NULL); return p_unit;
11993 0 : case 2: ROSE_ASSERT(p_iostat == NULL || p_iostat != NULL); return p_iostat;
11994 0 : case 3: ROSE_ASSERT(p_err == NULL || p_err != NULL); return p_err;
11995 0 : case 4: ROSE_ASSERT(p_iomsg == NULL || p_iomsg != NULL); return p_iomsg;
11996 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
11997 0 : ROSE_ASSERT(false);
11998 : return NULL;
11999 : }
12000 : }
12001 : size_t
12002 0 : SgInquireStatement::get_childIndex(SgNode *child) {
12003 0 : if (child == p_io_stmt_list) return 0;
12004 0 : else if (child == p_unit) return 1;
12005 0 : else if (child == p_iostat) return 2;
12006 0 : else if (child == p_err) return 3;
12007 0 : else if (child == p_iomsg) return 4;
12008 0 : else return (size_t) -1;
12009 : }
12010 : vector<SgNode*>
12011 0 : SgFlushStatement::get_traversalSuccessorContainer() {
12012 0 : vector<SgNode*> traversalSuccessorContainer;
12013 0 : traversalSuccessorContainer.reserve(5);
12014 0 : traversalSuccessorContainer.push_back(p_io_stmt_list);
12015 0 : traversalSuccessorContainer.push_back(p_unit);
12016 0 : traversalSuccessorContainer.push_back(p_iostat);
12017 0 : traversalSuccessorContainer.push_back(p_err);
12018 0 : traversalSuccessorContainer.push_back(p_iomsg);
12019 0 : return traversalSuccessorContainer;
12020 : }
12021 : vector<string>
12022 0 : SgFlushStatement::get_traversalSuccessorNamesContainer() {
12023 0 : vector<string> traversalSuccessorContainer;
12024 0 : traversalSuccessorContainer.push_back("p_io_stmt_list");
12025 0 : traversalSuccessorContainer.push_back("p_unit");
12026 0 : traversalSuccessorContainer.push_back("p_iostat");
12027 0 : traversalSuccessorContainer.push_back("p_err");
12028 0 : traversalSuccessorContainer.push_back("p_iomsg");
12029 0 : return traversalSuccessorContainer;
12030 : }
12031 : size_t
12032 0 : SgFlushStatement::get_numberOfTraversalSuccessors() {
12033 0 : return 5;
12034 : }
12035 : SgNode *
12036 0 : SgFlushStatement::get_traversalSuccessorByIndex(size_t idx) {
12037 0 : switch (idx) {
12038 0 : case 0: ROSE_ASSERT(p_io_stmt_list == NULL || p_io_stmt_list != NULL); return p_io_stmt_list;
12039 0 : case 1: ROSE_ASSERT(p_unit == NULL || p_unit != NULL); return p_unit;
12040 0 : case 2: ROSE_ASSERT(p_iostat == NULL || p_iostat != NULL); return p_iostat;
12041 0 : case 3: ROSE_ASSERT(p_err == NULL || p_err != NULL); return p_err;
12042 0 : case 4: ROSE_ASSERT(p_iomsg == NULL || p_iomsg != NULL); return p_iomsg;
12043 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12044 0 : ROSE_ASSERT(false);
12045 : return NULL;
12046 : }
12047 : }
12048 : size_t
12049 0 : SgFlushStatement::get_childIndex(SgNode *child) {
12050 0 : if (child == p_io_stmt_list) return 0;
12051 0 : else if (child == p_unit) return 1;
12052 0 : else if (child == p_iostat) return 2;
12053 0 : else if (child == p_err) return 3;
12054 0 : else if (child == p_iomsg) return 4;
12055 0 : else return (size_t) -1;
12056 : }
12057 : vector<SgNode*>
12058 0 : SgBackspaceStatement::get_traversalSuccessorContainer() {
12059 0 : vector<SgNode*> traversalSuccessorContainer;
12060 0 : traversalSuccessorContainer.reserve(5);
12061 0 : traversalSuccessorContainer.push_back(p_io_stmt_list);
12062 0 : traversalSuccessorContainer.push_back(p_unit);
12063 0 : traversalSuccessorContainer.push_back(p_iostat);
12064 0 : traversalSuccessorContainer.push_back(p_err);
12065 0 : traversalSuccessorContainer.push_back(p_iomsg);
12066 0 : return traversalSuccessorContainer;
12067 : }
12068 : vector<string>
12069 0 : SgBackspaceStatement::get_traversalSuccessorNamesContainer() {
12070 0 : vector<string> traversalSuccessorContainer;
12071 0 : traversalSuccessorContainer.push_back("p_io_stmt_list");
12072 0 : traversalSuccessorContainer.push_back("p_unit");
12073 0 : traversalSuccessorContainer.push_back("p_iostat");
12074 0 : traversalSuccessorContainer.push_back("p_err");
12075 0 : traversalSuccessorContainer.push_back("p_iomsg");
12076 0 : return traversalSuccessorContainer;
12077 : }
12078 : size_t
12079 0 : SgBackspaceStatement::get_numberOfTraversalSuccessors() {
12080 0 : return 5;
12081 : }
12082 : SgNode *
12083 0 : SgBackspaceStatement::get_traversalSuccessorByIndex(size_t idx) {
12084 0 : switch (idx) {
12085 0 : case 0: ROSE_ASSERT(p_io_stmt_list == NULL || p_io_stmt_list != NULL); return p_io_stmt_list;
12086 0 : case 1: ROSE_ASSERT(p_unit == NULL || p_unit != NULL); return p_unit;
12087 0 : case 2: ROSE_ASSERT(p_iostat == NULL || p_iostat != NULL); return p_iostat;
12088 0 : case 3: ROSE_ASSERT(p_err == NULL || p_err != NULL); return p_err;
12089 0 : case 4: ROSE_ASSERT(p_iomsg == NULL || p_iomsg != NULL); return p_iomsg;
12090 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12091 0 : ROSE_ASSERT(false);
12092 : return NULL;
12093 : }
12094 : }
12095 : size_t
12096 0 : SgBackspaceStatement::get_childIndex(SgNode *child) {
12097 0 : if (child == p_io_stmt_list) return 0;
12098 0 : else if (child == p_unit) return 1;
12099 0 : else if (child == p_iostat) return 2;
12100 0 : else if (child == p_err) return 3;
12101 0 : else if (child == p_iomsg) return 4;
12102 0 : else return (size_t) -1;
12103 : }
12104 : vector<SgNode*>
12105 0 : SgRewindStatement::get_traversalSuccessorContainer() {
12106 0 : vector<SgNode*> traversalSuccessorContainer;
12107 0 : traversalSuccessorContainer.reserve(5);
12108 0 : traversalSuccessorContainer.push_back(p_io_stmt_list);
12109 0 : traversalSuccessorContainer.push_back(p_unit);
12110 0 : traversalSuccessorContainer.push_back(p_iostat);
12111 0 : traversalSuccessorContainer.push_back(p_err);
12112 0 : traversalSuccessorContainer.push_back(p_iomsg);
12113 0 : return traversalSuccessorContainer;
12114 : }
12115 : vector<string>
12116 0 : SgRewindStatement::get_traversalSuccessorNamesContainer() {
12117 0 : vector<string> traversalSuccessorContainer;
12118 0 : traversalSuccessorContainer.push_back("p_io_stmt_list");
12119 0 : traversalSuccessorContainer.push_back("p_unit");
12120 0 : traversalSuccessorContainer.push_back("p_iostat");
12121 0 : traversalSuccessorContainer.push_back("p_err");
12122 0 : traversalSuccessorContainer.push_back("p_iomsg");
12123 0 : return traversalSuccessorContainer;
12124 : }
12125 : size_t
12126 0 : SgRewindStatement::get_numberOfTraversalSuccessors() {
12127 0 : return 5;
12128 : }
12129 : SgNode *
12130 0 : SgRewindStatement::get_traversalSuccessorByIndex(size_t idx) {
12131 0 : switch (idx) {
12132 0 : case 0: ROSE_ASSERT(p_io_stmt_list == NULL || p_io_stmt_list != NULL); return p_io_stmt_list;
12133 0 : case 1: ROSE_ASSERT(p_unit == NULL || p_unit != NULL); return p_unit;
12134 0 : case 2: ROSE_ASSERT(p_iostat == NULL || p_iostat != NULL); return p_iostat;
12135 0 : case 3: ROSE_ASSERT(p_err == NULL || p_err != NULL); return p_err;
12136 0 : case 4: ROSE_ASSERT(p_iomsg == NULL || p_iomsg != NULL); return p_iomsg;
12137 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12138 0 : ROSE_ASSERT(false);
12139 : return NULL;
12140 : }
12141 : }
12142 : size_t
12143 0 : SgRewindStatement::get_childIndex(SgNode *child) {
12144 0 : if (child == p_io_stmt_list) return 0;
12145 0 : else if (child == p_unit) return 1;
12146 0 : else if (child == p_iostat) return 2;
12147 0 : else if (child == p_err) return 3;
12148 0 : else if (child == p_iomsg) return 4;
12149 0 : else return (size_t) -1;
12150 : }
12151 : vector<SgNode*>
12152 0 : SgEndfileStatement::get_traversalSuccessorContainer() {
12153 0 : vector<SgNode*> traversalSuccessorContainer;
12154 0 : traversalSuccessorContainer.reserve(5);
12155 0 : traversalSuccessorContainer.push_back(p_io_stmt_list);
12156 0 : traversalSuccessorContainer.push_back(p_unit);
12157 0 : traversalSuccessorContainer.push_back(p_iostat);
12158 0 : traversalSuccessorContainer.push_back(p_err);
12159 0 : traversalSuccessorContainer.push_back(p_iomsg);
12160 0 : return traversalSuccessorContainer;
12161 : }
12162 : vector<string>
12163 0 : SgEndfileStatement::get_traversalSuccessorNamesContainer() {
12164 0 : vector<string> traversalSuccessorContainer;
12165 0 : traversalSuccessorContainer.push_back("p_io_stmt_list");
12166 0 : traversalSuccessorContainer.push_back("p_unit");
12167 0 : traversalSuccessorContainer.push_back("p_iostat");
12168 0 : traversalSuccessorContainer.push_back("p_err");
12169 0 : traversalSuccessorContainer.push_back("p_iomsg");
12170 0 : return traversalSuccessorContainer;
12171 : }
12172 : size_t
12173 0 : SgEndfileStatement::get_numberOfTraversalSuccessors() {
12174 0 : return 5;
12175 : }
12176 : SgNode *
12177 0 : SgEndfileStatement::get_traversalSuccessorByIndex(size_t idx) {
12178 0 : switch (idx) {
12179 0 : case 0: ROSE_ASSERT(p_io_stmt_list == NULL || p_io_stmt_list != NULL); return p_io_stmt_list;
12180 0 : case 1: ROSE_ASSERT(p_unit == NULL || p_unit != NULL); return p_unit;
12181 0 : case 2: ROSE_ASSERT(p_iostat == NULL || p_iostat != NULL); return p_iostat;
12182 0 : case 3: ROSE_ASSERT(p_err == NULL || p_err != NULL); return p_err;
12183 0 : case 4: ROSE_ASSERT(p_iomsg == NULL || p_iomsg != NULL); return p_iomsg;
12184 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12185 0 : ROSE_ASSERT(false);
12186 : return NULL;
12187 : }
12188 : }
12189 : size_t
12190 0 : SgEndfileStatement::get_childIndex(SgNode *child) {
12191 0 : if (child == p_io_stmt_list) return 0;
12192 0 : else if (child == p_unit) return 1;
12193 0 : else if (child == p_iostat) return 2;
12194 0 : else if (child == p_err) return 3;
12195 0 : else if (child == p_iomsg) return 4;
12196 0 : else return (size_t) -1;
12197 : }
12198 : vector<SgNode*>
12199 0 : SgWaitStatement::get_traversalSuccessorContainer() {
12200 0 : vector<SgNode*> traversalSuccessorContainer;
12201 0 : traversalSuccessorContainer.reserve(5);
12202 0 : traversalSuccessorContainer.push_back(p_io_stmt_list);
12203 0 : traversalSuccessorContainer.push_back(p_unit);
12204 0 : traversalSuccessorContainer.push_back(p_iostat);
12205 0 : traversalSuccessorContainer.push_back(p_err);
12206 0 : traversalSuccessorContainer.push_back(p_iomsg);
12207 0 : return traversalSuccessorContainer;
12208 : }
12209 : vector<string>
12210 0 : SgWaitStatement::get_traversalSuccessorNamesContainer() {
12211 0 : vector<string> traversalSuccessorContainer;
12212 0 : traversalSuccessorContainer.push_back("p_io_stmt_list");
12213 0 : traversalSuccessorContainer.push_back("p_unit");
12214 0 : traversalSuccessorContainer.push_back("p_iostat");
12215 0 : traversalSuccessorContainer.push_back("p_err");
12216 0 : traversalSuccessorContainer.push_back("p_iomsg");
12217 0 : return traversalSuccessorContainer;
12218 : }
12219 : size_t
12220 0 : SgWaitStatement::get_numberOfTraversalSuccessors() {
12221 0 : return 5;
12222 : }
12223 : SgNode *
12224 0 : SgWaitStatement::get_traversalSuccessorByIndex(size_t idx) {
12225 0 : switch (idx) {
12226 0 : case 0: ROSE_ASSERT(p_io_stmt_list == NULL || p_io_stmt_list != NULL); return p_io_stmt_list;
12227 0 : case 1: ROSE_ASSERT(p_unit == NULL || p_unit != NULL); return p_unit;
12228 0 : case 2: ROSE_ASSERT(p_iostat == NULL || p_iostat != NULL); return p_iostat;
12229 0 : case 3: ROSE_ASSERT(p_err == NULL || p_err != NULL); return p_err;
12230 0 : case 4: ROSE_ASSERT(p_iomsg == NULL || p_iomsg != NULL); return p_iomsg;
12231 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12232 0 : ROSE_ASSERT(false);
12233 : return NULL;
12234 : }
12235 : }
12236 : size_t
12237 0 : SgWaitStatement::get_childIndex(SgNode *child) {
12238 0 : if (child == p_io_stmt_list) return 0;
12239 0 : else if (child == p_unit) return 1;
12240 0 : else if (child == p_iostat) return 2;
12241 0 : else if (child == p_err) return 3;
12242 0 : else if (child == p_iomsg) return 4;
12243 0 : else return (size_t) -1;
12244 : }
12245 : vector<SgNode*>
12246 0 : SgWhereStatement::get_traversalSuccessorContainer() {
12247 0 : vector<SgNode*> traversalSuccessorContainer;
12248 0 : traversalSuccessorContainer.reserve(3);
12249 0 : traversalSuccessorContainer.push_back(p_condition);
12250 0 : traversalSuccessorContainer.push_back(p_body);
12251 0 : traversalSuccessorContainer.push_back(p_elsewhere);
12252 0 : return traversalSuccessorContainer;
12253 : }
12254 : vector<string>
12255 0 : SgWhereStatement::get_traversalSuccessorNamesContainer() {
12256 0 : vector<string> traversalSuccessorContainer;
12257 0 : traversalSuccessorContainer.push_back("p_condition");
12258 0 : traversalSuccessorContainer.push_back("p_body");
12259 0 : traversalSuccessorContainer.push_back("p_elsewhere");
12260 0 : return traversalSuccessorContainer;
12261 : }
12262 : size_t
12263 0 : SgWhereStatement::get_numberOfTraversalSuccessors() {
12264 0 : return 3;
12265 : }
12266 : SgNode *
12267 0 : SgWhereStatement::get_traversalSuccessorByIndex(size_t idx) {
12268 0 : switch (idx) {
12269 0 : case 0: ROSE_ASSERT(p_condition == NULL || p_condition != NULL); return p_condition;
12270 0 : case 1: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
12271 0 : case 2: ROSE_ASSERT(p_elsewhere == NULL || p_elsewhere != NULL); return p_elsewhere;
12272 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12273 0 : ROSE_ASSERT(false);
12274 : return NULL;
12275 : }
12276 : }
12277 : size_t
12278 0 : SgWhereStatement::get_childIndex(SgNode *child) {
12279 0 : if (child == p_condition) return 0;
12280 0 : else if (child == p_body) return 1;
12281 0 : else if (child == p_elsewhere) return 2;
12282 0 : else return (size_t) -1;
12283 : }
12284 : vector<SgNode*>
12285 0 : SgElseWhereStatement::get_traversalSuccessorContainer() {
12286 0 : vector<SgNode*> traversalSuccessorContainer;
12287 0 : traversalSuccessorContainer.reserve(3);
12288 0 : traversalSuccessorContainer.push_back(p_condition);
12289 0 : traversalSuccessorContainer.push_back(p_body);
12290 0 : traversalSuccessorContainer.push_back(p_elsewhere);
12291 0 : return traversalSuccessorContainer;
12292 : }
12293 : vector<string>
12294 0 : SgElseWhereStatement::get_traversalSuccessorNamesContainer() {
12295 0 : vector<string> traversalSuccessorContainer;
12296 0 : traversalSuccessorContainer.push_back("p_condition");
12297 0 : traversalSuccessorContainer.push_back("p_body");
12298 0 : traversalSuccessorContainer.push_back("p_elsewhere");
12299 0 : return traversalSuccessorContainer;
12300 : }
12301 : size_t
12302 0 : SgElseWhereStatement::get_numberOfTraversalSuccessors() {
12303 0 : return 3;
12304 : }
12305 : SgNode *
12306 0 : SgElseWhereStatement::get_traversalSuccessorByIndex(size_t idx) {
12307 0 : switch (idx) {
12308 0 : case 0: ROSE_ASSERT(p_condition == NULL || p_condition != NULL); return p_condition;
12309 0 : case 1: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
12310 0 : case 2: ROSE_ASSERT(p_elsewhere == NULL || p_elsewhere != NULL); return p_elsewhere;
12311 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12312 0 : ROSE_ASSERT(false);
12313 : return NULL;
12314 : }
12315 : }
12316 : size_t
12317 0 : SgElseWhereStatement::get_childIndex(SgNode *child) {
12318 0 : if (child == p_condition) return 0;
12319 0 : else if (child == p_body) return 1;
12320 0 : else if (child == p_elsewhere) return 2;
12321 0 : else return (size_t) -1;
12322 : }
12323 : vector<SgNode*>
12324 0 : SgNullifyStatement::get_traversalSuccessorContainer() {
12325 0 : vector<SgNode*> traversalSuccessorContainer;
12326 0 : traversalSuccessorContainer.reserve(1);
12327 0 : traversalSuccessorContainer.push_back(p_pointer_list);
12328 0 : return traversalSuccessorContainer;
12329 : }
12330 : vector<string>
12331 0 : SgNullifyStatement::get_traversalSuccessorNamesContainer() {
12332 0 : vector<string> traversalSuccessorContainer;
12333 0 : traversalSuccessorContainer.push_back("p_pointer_list");
12334 0 : return traversalSuccessorContainer;
12335 : }
12336 : size_t
12337 0 : SgNullifyStatement::get_numberOfTraversalSuccessors() {
12338 0 : return 1;
12339 : }
12340 : SgNode *
12341 0 : SgNullifyStatement::get_traversalSuccessorByIndex(size_t idx) {
12342 0 : switch (idx) {
12343 0 : case 0: ROSE_ASSERT(p_pointer_list == NULL || p_pointer_list != NULL); return p_pointer_list;
12344 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12345 0 : ROSE_ASSERT(false);
12346 : return NULL;
12347 : }
12348 : }
12349 : size_t
12350 0 : SgNullifyStatement::get_childIndex(SgNode *child) {
12351 0 : if (child == p_pointer_list) return 0;
12352 0 : else return (size_t) -1;
12353 : }
12354 : vector<SgNode*>
12355 0 : SgArithmeticIfStatement::get_traversalSuccessorContainer() {
12356 0 : vector<SgNode*> traversalSuccessorContainer;
12357 0 : traversalSuccessorContainer.reserve(1);
12358 0 : traversalSuccessorContainer.push_back(p_conditional);
12359 0 : return traversalSuccessorContainer;
12360 : }
12361 : vector<string>
12362 0 : SgArithmeticIfStatement::get_traversalSuccessorNamesContainer() {
12363 0 : vector<string> traversalSuccessorContainer;
12364 0 : traversalSuccessorContainer.push_back("p_conditional");
12365 0 : return traversalSuccessorContainer;
12366 : }
12367 : size_t
12368 0 : SgArithmeticIfStatement::get_numberOfTraversalSuccessors() {
12369 0 : return 1;
12370 : }
12371 : SgNode *
12372 0 : SgArithmeticIfStatement::get_traversalSuccessorByIndex(size_t idx) {
12373 0 : switch (idx) {
12374 0 : case 0: ROSE_ASSERT(p_conditional == NULL || p_conditional != NULL); return p_conditional;
12375 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12376 0 : ROSE_ASSERT(false);
12377 : return NULL;
12378 : }
12379 : }
12380 : size_t
12381 0 : SgArithmeticIfStatement::get_childIndex(SgNode *child) {
12382 0 : if (child == p_conditional) return 0;
12383 0 : else return (size_t) -1;
12384 : }
12385 : vector<SgNode*>
12386 0 : SgAssignStatement::get_traversalSuccessorContainer() {
12387 0 : vector<SgNode*> traversalSuccessorContainer;
12388 0 : traversalSuccessorContainer.reserve(1);
12389 0 : traversalSuccessorContainer.push_back(p_value);
12390 0 : return traversalSuccessorContainer;
12391 : }
12392 : vector<string>
12393 0 : SgAssignStatement::get_traversalSuccessorNamesContainer() {
12394 0 : vector<string> traversalSuccessorContainer;
12395 0 : traversalSuccessorContainer.push_back("p_value");
12396 0 : return traversalSuccessorContainer;
12397 : }
12398 : size_t
12399 0 : SgAssignStatement::get_numberOfTraversalSuccessors() {
12400 0 : return 1;
12401 : }
12402 : SgNode *
12403 0 : SgAssignStatement::get_traversalSuccessorByIndex(size_t idx) {
12404 0 : switch (idx) {
12405 0 : case 0: ROSE_ASSERT(p_value == NULL || p_value != NULL); return p_value;
12406 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12407 0 : ROSE_ASSERT(false);
12408 : return NULL;
12409 : }
12410 : }
12411 : size_t
12412 0 : SgAssignStatement::get_childIndex(SgNode *child) {
12413 0 : if (child == p_value) return 0;
12414 0 : else return (size_t) -1;
12415 : }
12416 : vector<SgNode*>
12417 0 : SgComputedGotoStatement::get_traversalSuccessorContainer() {
12418 0 : vector<SgNode*> traversalSuccessorContainer;
12419 0 : traversalSuccessorContainer.reserve(2);
12420 0 : traversalSuccessorContainer.push_back(p_labelList);
12421 0 : traversalSuccessorContainer.push_back(p_label_index);
12422 0 : return traversalSuccessorContainer;
12423 : }
12424 : vector<string>
12425 0 : SgComputedGotoStatement::get_traversalSuccessorNamesContainer() {
12426 0 : vector<string> traversalSuccessorContainer;
12427 0 : traversalSuccessorContainer.push_back("p_labelList");
12428 0 : traversalSuccessorContainer.push_back("p_label_index");
12429 0 : return traversalSuccessorContainer;
12430 : }
12431 : size_t
12432 0 : SgComputedGotoStatement::get_numberOfTraversalSuccessors() {
12433 0 : return 2;
12434 : }
12435 : SgNode *
12436 0 : SgComputedGotoStatement::get_traversalSuccessorByIndex(size_t idx) {
12437 0 : switch (idx) {
12438 0 : case 0: ROSE_ASSERT(p_labelList == NULL || p_labelList != NULL); return p_labelList;
12439 0 : case 1: ROSE_ASSERT(p_label_index == NULL || p_label_index != NULL); return p_label_index;
12440 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12441 0 : ROSE_ASSERT(false);
12442 : return NULL;
12443 : }
12444 : }
12445 : size_t
12446 0 : SgComputedGotoStatement::get_childIndex(SgNode *child) {
12447 0 : if (child == p_labelList) return 0;
12448 0 : else if (child == p_label_index) return 1;
12449 0 : else return (size_t) -1;
12450 : }
12451 : vector<SgNode*>
12452 0 : SgAssignedGotoStatement::get_traversalSuccessorContainer() {
12453 0 : vector<SgNode*> traversalSuccessorContainer;
12454 0 : traversalSuccessorContainer.reserve(1);
12455 0 : traversalSuccessorContainer.push_back(p_targets);
12456 0 : return traversalSuccessorContainer;
12457 : }
12458 : vector<string>
12459 0 : SgAssignedGotoStatement::get_traversalSuccessorNamesContainer() {
12460 0 : vector<string> traversalSuccessorContainer;
12461 0 : traversalSuccessorContainer.push_back("p_targets");
12462 0 : return traversalSuccessorContainer;
12463 : }
12464 : size_t
12465 0 : SgAssignedGotoStatement::get_numberOfTraversalSuccessors() {
12466 0 : return 1;
12467 : }
12468 : SgNode *
12469 0 : SgAssignedGotoStatement::get_traversalSuccessorByIndex(size_t idx) {
12470 0 : switch (idx) {
12471 0 : case 0: ROSE_ASSERT(p_targets == NULL || p_targets != NULL); return p_targets;
12472 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12473 0 : ROSE_ASSERT(false);
12474 : return NULL;
12475 : }
12476 : }
12477 : size_t
12478 0 : SgAssignedGotoStatement::get_childIndex(SgNode *child) {
12479 0 : if (child == p_targets) return 0;
12480 0 : else return (size_t) -1;
12481 : }
12482 : vector<SgNode*>
12483 0 : SgAllocateStatement::get_traversalSuccessorContainer() {
12484 0 : vector<SgNode*> traversalSuccessorContainer;
12485 0 : traversalSuccessorContainer.reserve(4);
12486 0 : traversalSuccessorContainer.push_back(p_expr_list);
12487 0 : traversalSuccessorContainer.push_back(p_stat_expression);
12488 0 : traversalSuccessorContainer.push_back(p_errmsg_expression);
12489 0 : traversalSuccessorContainer.push_back(p_source_expression);
12490 0 : return traversalSuccessorContainer;
12491 : }
12492 : vector<string>
12493 0 : SgAllocateStatement::get_traversalSuccessorNamesContainer() {
12494 0 : vector<string> traversalSuccessorContainer;
12495 0 : traversalSuccessorContainer.push_back("p_expr_list");
12496 0 : traversalSuccessorContainer.push_back("p_stat_expression");
12497 0 : traversalSuccessorContainer.push_back("p_errmsg_expression");
12498 0 : traversalSuccessorContainer.push_back("p_source_expression");
12499 0 : return traversalSuccessorContainer;
12500 : }
12501 : size_t
12502 0 : SgAllocateStatement::get_numberOfTraversalSuccessors() {
12503 0 : return 4;
12504 : }
12505 : SgNode *
12506 0 : SgAllocateStatement::get_traversalSuccessorByIndex(size_t idx) {
12507 0 : switch (idx) {
12508 0 : case 0: ROSE_ASSERT(p_expr_list == NULL || p_expr_list != NULL); return p_expr_list;
12509 0 : case 1: ROSE_ASSERT(p_stat_expression == NULL || p_stat_expression != NULL); return p_stat_expression;
12510 0 : case 2: ROSE_ASSERT(p_errmsg_expression == NULL || p_errmsg_expression != NULL); return p_errmsg_expression;
12511 0 : case 3: ROSE_ASSERT(p_source_expression == NULL || p_source_expression != NULL); return p_source_expression;
12512 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12513 0 : ROSE_ASSERT(false);
12514 : return NULL;
12515 : }
12516 : }
12517 : size_t
12518 0 : SgAllocateStatement::get_childIndex(SgNode *child) {
12519 0 : if (child == p_expr_list) return 0;
12520 0 : else if (child == p_stat_expression) return 1;
12521 0 : else if (child == p_errmsg_expression) return 2;
12522 0 : else if (child == p_source_expression) return 3;
12523 0 : else return (size_t) -1;
12524 : }
12525 : vector<SgNode*>
12526 0 : SgDeallocateStatement::get_traversalSuccessorContainer() {
12527 0 : vector<SgNode*> traversalSuccessorContainer;
12528 0 : traversalSuccessorContainer.reserve(3);
12529 0 : traversalSuccessorContainer.push_back(p_expr_list);
12530 0 : traversalSuccessorContainer.push_back(p_stat_expression);
12531 0 : traversalSuccessorContainer.push_back(p_errmsg_expression);
12532 0 : return traversalSuccessorContainer;
12533 : }
12534 : vector<string>
12535 0 : SgDeallocateStatement::get_traversalSuccessorNamesContainer() {
12536 0 : vector<string> traversalSuccessorContainer;
12537 0 : traversalSuccessorContainer.push_back("p_expr_list");
12538 0 : traversalSuccessorContainer.push_back("p_stat_expression");
12539 0 : traversalSuccessorContainer.push_back("p_errmsg_expression");
12540 0 : return traversalSuccessorContainer;
12541 : }
12542 : size_t
12543 0 : SgDeallocateStatement::get_numberOfTraversalSuccessors() {
12544 0 : return 3;
12545 : }
12546 : SgNode *
12547 0 : SgDeallocateStatement::get_traversalSuccessorByIndex(size_t idx) {
12548 0 : switch (idx) {
12549 0 : case 0: ROSE_ASSERT(p_expr_list == NULL || p_expr_list != NULL); return p_expr_list;
12550 0 : case 1: ROSE_ASSERT(p_stat_expression == NULL || p_stat_expression != NULL); return p_stat_expression;
12551 0 : case 2: ROSE_ASSERT(p_errmsg_expression == NULL || p_errmsg_expression != NULL); return p_errmsg_expression;
12552 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12553 0 : ROSE_ASSERT(false);
12554 : return NULL;
12555 : }
12556 : }
12557 : size_t
12558 0 : SgDeallocateStatement::get_childIndex(SgNode *child) {
12559 0 : if (child == p_expr_list) return 0;
12560 0 : else if (child == p_stat_expression) return 1;
12561 0 : else if (child == p_errmsg_expression) return 2;
12562 0 : else return (size_t) -1;
12563 : }
12564 : vector<SgNode*>
12565 0 : SgUpcNotifyStatement::get_traversalSuccessorContainer() {
12566 0 : vector<SgNode*> traversalSuccessorContainer;
12567 0 : traversalSuccessorContainer.reserve(1);
12568 0 : traversalSuccessorContainer.push_back(p_notify_expression);
12569 0 : return traversalSuccessorContainer;
12570 : }
12571 : vector<string>
12572 0 : SgUpcNotifyStatement::get_traversalSuccessorNamesContainer() {
12573 0 : vector<string> traversalSuccessorContainer;
12574 0 : traversalSuccessorContainer.push_back("p_notify_expression");
12575 0 : return traversalSuccessorContainer;
12576 : }
12577 : size_t
12578 0 : SgUpcNotifyStatement::get_numberOfTraversalSuccessors() {
12579 0 : return 1;
12580 : }
12581 : SgNode *
12582 0 : SgUpcNotifyStatement::get_traversalSuccessorByIndex(size_t idx) {
12583 0 : switch (idx) {
12584 0 : case 0: ROSE_ASSERT(p_notify_expression == NULL || p_notify_expression != NULL); return p_notify_expression;
12585 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12586 0 : ROSE_ASSERT(false);
12587 : return NULL;
12588 : }
12589 : }
12590 : size_t
12591 0 : SgUpcNotifyStatement::get_childIndex(SgNode *child) {
12592 0 : if (child == p_notify_expression) return 0;
12593 0 : else return (size_t) -1;
12594 : }
12595 : vector<SgNode*>
12596 0 : SgUpcWaitStatement::get_traversalSuccessorContainer() {
12597 0 : vector<SgNode*> traversalSuccessorContainer;
12598 0 : traversalSuccessorContainer.reserve(1);
12599 0 : traversalSuccessorContainer.push_back(p_wait_expression);
12600 0 : return traversalSuccessorContainer;
12601 : }
12602 : vector<string>
12603 0 : SgUpcWaitStatement::get_traversalSuccessorNamesContainer() {
12604 0 : vector<string> traversalSuccessorContainer;
12605 0 : traversalSuccessorContainer.push_back("p_wait_expression");
12606 0 : return traversalSuccessorContainer;
12607 : }
12608 : size_t
12609 0 : SgUpcWaitStatement::get_numberOfTraversalSuccessors() {
12610 0 : return 1;
12611 : }
12612 : SgNode *
12613 0 : SgUpcWaitStatement::get_traversalSuccessorByIndex(size_t idx) {
12614 0 : switch (idx) {
12615 0 : case 0: ROSE_ASSERT(p_wait_expression == NULL || p_wait_expression != NULL); return p_wait_expression;
12616 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12617 0 : ROSE_ASSERT(false);
12618 : return NULL;
12619 : }
12620 : }
12621 : size_t
12622 0 : SgUpcWaitStatement::get_childIndex(SgNode *child) {
12623 0 : if (child == p_wait_expression) return 0;
12624 0 : else return (size_t) -1;
12625 : }
12626 : vector<SgNode*>
12627 0 : SgUpcBarrierStatement::get_traversalSuccessorContainer() {
12628 0 : vector<SgNode*> traversalSuccessorContainer;
12629 0 : traversalSuccessorContainer.reserve(1);
12630 0 : traversalSuccessorContainer.push_back(p_barrier_expression);
12631 0 : return traversalSuccessorContainer;
12632 : }
12633 : vector<string>
12634 0 : SgUpcBarrierStatement::get_traversalSuccessorNamesContainer() {
12635 0 : vector<string> traversalSuccessorContainer;
12636 0 : traversalSuccessorContainer.push_back("p_barrier_expression");
12637 0 : return traversalSuccessorContainer;
12638 : }
12639 : size_t
12640 0 : SgUpcBarrierStatement::get_numberOfTraversalSuccessors() {
12641 0 : return 1;
12642 : }
12643 : SgNode *
12644 0 : SgUpcBarrierStatement::get_traversalSuccessorByIndex(size_t idx) {
12645 0 : switch (idx) {
12646 0 : case 0: ROSE_ASSERT(p_barrier_expression == NULL || p_barrier_expression != NULL); return p_barrier_expression;
12647 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12648 0 : ROSE_ASSERT(false);
12649 : return NULL;
12650 : }
12651 : }
12652 : size_t
12653 0 : SgUpcBarrierStatement::get_childIndex(SgNode *child) {
12654 0 : if (child == p_barrier_expression) return 0;
12655 0 : else return (size_t) -1;
12656 : }
12657 : vector<SgNode*>
12658 0 : SgUpcFenceStatement::get_traversalSuccessorContainer() {
12659 0 : vector<SgNode*> traversalSuccessorContainer;
12660 0 : return traversalSuccessorContainer;
12661 : }
12662 : vector<string>
12663 0 : SgUpcFenceStatement::get_traversalSuccessorNamesContainer() {
12664 0 : vector<string> traversalSuccessorContainer;
12665 0 : return traversalSuccessorContainer;
12666 : }
12667 : size_t
12668 0 : SgUpcFenceStatement::get_numberOfTraversalSuccessors() {
12669 0 : return 0;
12670 : }
12671 : SgNode *
12672 0 : SgUpcFenceStatement::get_traversalSuccessorByIndex(size_t idx) {
12673 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUpcFenceStatement" << " that has no successors!" << endl;
12674 0 : ROSE_ASSERT(false);
12675 : return NULL;
12676 : }
12677 : size_t
12678 0 : SgUpcFenceStatement::get_childIndex(SgNode *child) {
12679 0 : cout << "error: get_childIndex called on node of type " << "SgUpcFenceStatement" << " that has no successors!" << endl;
12680 0 : ROSE_ASSERT(false);
12681 : return 0;
12682 : }
12683 : vector<SgNode*>
12684 0 : SgUpirBaseStatement::get_traversalSuccessorContainer() {
12685 0 : vector<SgNode*> traversalSuccessorContainer;
12686 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
12687 0 : << "static: SgUpirBaseStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
12688 0 : cerr << "Aborting ..." << endl;
12689 0 : ROSE_ASSERT(false);
12690 : return traversalSuccessorContainer;
12691 : }
12692 :
12693 : vector<string>
12694 0 : SgUpirBaseStatement::get_traversalSuccessorNamesContainer() {
12695 0 : vector<string> traversalSuccessorContainer;
12696 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
12697 0 : << "static: SgUpirBaseStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
12698 0 : cerr << "Aborting ..." << endl;
12699 0 : ROSE_ASSERT(false);
12700 : return traversalSuccessorContainer;
12701 : }
12702 :
12703 : size_t
12704 0 : SgUpirBaseStatement::get_numberOfTraversalSuccessors() {
12705 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
12706 0 : << "static: SgUpirBaseStatement" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
12707 0 : cerr << "Aborting ..." << endl;
12708 0 : ROSE_ASSERT(false);
12709 : return 42;
12710 : }
12711 :
12712 : SgNode*
12713 0 : SgUpirBaseStatement::get_traversalSuccessorByIndex(size_t) {
12714 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
12715 0 : << "static: SgUpirBaseStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
12716 0 : cerr << "Aborting ..." << endl;
12717 0 : ROSE_ASSERT(false);
12718 : return NULL;
12719 : }
12720 :
12721 : size_t
12722 0 : SgUpirBaseStatement::get_childIndex(SgNode *) {
12723 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
12724 0 : << "static: SgUpirBaseStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
12725 0 : cerr << "Aborting ..." << endl;
12726 0 : ROSE_ASSERT(false);
12727 : return 42;
12728 : }
12729 :
12730 : vector<SgNode*>
12731 2 : SgOmpTaskyieldStatement::get_traversalSuccessorContainer() {
12732 2 : vector<SgNode*> traversalSuccessorContainer;
12733 2 : return traversalSuccessorContainer;
12734 : }
12735 : vector<string>
12736 2 : SgOmpTaskyieldStatement::get_traversalSuccessorNamesContainer() {
12737 2 : vector<string> traversalSuccessorContainer;
12738 2 : return traversalSuccessorContainer;
12739 : }
12740 : size_t
12741 16 : SgOmpTaskyieldStatement::get_numberOfTraversalSuccessors() {
12742 16 : return 0;
12743 : }
12744 : SgNode *
12745 0 : SgOmpTaskyieldStatement::get_traversalSuccessorByIndex(size_t idx) {
12746 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpTaskyieldStatement" << " that has no successors!" << endl;
12747 0 : ROSE_ASSERT(false);
12748 : return NULL;
12749 : }
12750 : size_t
12751 0 : SgOmpTaskyieldStatement::get_childIndex(SgNode *child) {
12752 0 : cout << "error: get_childIndex called on node of type " << "SgOmpTaskyieldStatement" << " that has no successors!" << endl;
12753 0 : ROSE_ASSERT(false);
12754 : return 0;
12755 : }
12756 : vector<SgNode*>
12757 34 : SgOmpBarrierStatement::get_traversalSuccessorContainer() {
12758 34 : vector<SgNode*> traversalSuccessorContainer;
12759 34 : return traversalSuccessorContainer;
12760 : }
12761 : vector<string>
12762 34 : SgOmpBarrierStatement::get_traversalSuccessorNamesContainer() {
12763 34 : vector<string> traversalSuccessorContainer;
12764 34 : return traversalSuccessorContainer;
12765 : }
12766 : size_t
12767 266 : SgOmpBarrierStatement::get_numberOfTraversalSuccessors() {
12768 266 : return 0;
12769 : }
12770 : SgNode *
12771 0 : SgOmpBarrierStatement::get_traversalSuccessorByIndex(size_t idx) {
12772 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpBarrierStatement" << " that has no successors!" << endl;
12773 0 : ROSE_ASSERT(false);
12774 : return NULL;
12775 : }
12776 : size_t
12777 0 : SgOmpBarrierStatement::get_childIndex(SgNode *child) {
12778 0 : cout << "error: get_childIndex called on node of type " << "SgOmpBarrierStatement" << " that has no successors!" << endl;
12779 0 : ROSE_ASSERT(false);
12780 : return 0;
12781 : }
12782 : vector<SgNode*>
12783 0 : SgUpirBodyStatement::get_traversalSuccessorContainer() {
12784 0 : vector<SgNode*> traversalSuccessorContainer;
12785 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
12786 0 : << "static: SgUpirBodyStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
12787 0 : cerr << "Aborting ..." << endl;
12788 0 : ROSE_ASSERT(false);
12789 : return traversalSuccessorContainer;
12790 : }
12791 :
12792 : vector<string>
12793 0 : SgUpirBodyStatement::get_traversalSuccessorNamesContainer() {
12794 0 : vector<string> traversalSuccessorContainer;
12795 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
12796 0 : << "static: SgUpirBodyStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
12797 0 : cerr << "Aborting ..." << endl;
12798 0 : ROSE_ASSERT(false);
12799 : return traversalSuccessorContainer;
12800 : }
12801 :
12802 : size_t
12803 0 : SgUpirBodyStatement::get_numberOfTraversalSuccessors() {
12804 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
12805 0 : << "static: SgUpirBodyStatement" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
12806 0 : cerr << "Aborting ..." << endl;
12807 0 : ROSE_ASSERT(false);
12808 : return 42;
12809 : }
12810 :
12811 : SgNode*
12812 0 : SgUpirBodyStatement::get_traversalSuccessorByIndex(size_t) {
12813 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
12814 0 : << "static: SgUpirBodyStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
12815 0 : cerr << "Aborting ..." << endl;
12816 0 : ROSE_ASSERT(false);
12817 : return NULL;
12818 : }
12819 :
12820 : size_t
12821 0 : SgUpirBodyStatement::get_childIndex(SgNode *) {
12822 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
12823 0 : << "static: SgUpirBodyStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
12824 0 : cerr << "Aborting ..." << endl;
12825 0 : ROSE_ASSERT(false);
12826 : return 42;
12827 : }
12828 :
12829 : vector<SgNode*>
12830 28 : SgOmpMasterStatement::get_traversalSuccessorContainer() {
12831 28 : vector<SgNode*> traversalSuccessorContainer;
12832 28 : traversalSuccessorContainer.reserve(1);
12833 28 : traversalSuccessorContainer.push_back(p_body);
12834 28 : return traversalSuccessorContainer;
12835 : }
12836 : vector<string>
12837 28 : SgOmpMasterStatement::get_traversalSuccessorNamesContainer() {
12838 28 : vector<string> traversalSuccessorContainer;
12839 56 : traversalSuccessorContainer.push_back("p_body");
12840 28 : return traversalSuccessorContainer;
12841 : }
12842 : size_t
12843 217 : SgOmpMasterStatement::get_numberOfTraversalSuccessors() {
12844 217 : return 1;
12845 : }
12846 : SgNode *
12847 217 : SgOmpMasterStatement::get_traversalSuccessorByIndex(size_t idx) {
12848 217 : switch (idx) {
12849 217 : case 0: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
12850 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12851 0 : ROSE_ASSERT(false);
12852 : return NULL;
12853 : }
12854 : }
12855 : size_t
12856 0 : SgOmpMasterStatement::get_childIndex(SgNode *child) {
12857 0 : if (child == p_body) return 0;
12858 0 : else return (size_t) -1;
12859 : }
12860 : vector<SgNode*>
12861 58 : SgOmpSectionStatement::get_traversalSuccessorContainer() {
12862 58 : vector<SgNode*> traversalSuccessorContainer;
12863 58 : traversalSuccessorContainer.reserve(1);
12864 58 : traversalSuccessorContainer.push_back(p_body);
12865 58 : return traversalSuccessorContainer;
12866 : }
12867 : vector<string>
12868 58 : SgOmpSectionStatement::get_traversalSuccessorNamesContainer() {
12869 58 : vector<string> traversalSuccessorContainer;
12870 116 : traversalSuccessorContainer.push_back("p_body");
12871 58 : return traversalSuccessorContainer;
12872 : }
12873 : size_t
12874 453 : SgOmpSectionStatement::get_numberOfTraversalSuccessors() {
12875 453 : return 1;
12876 : }
12877 : SgNode *
12878 453 : SgOmpSectionStatement::get_traversalSuccessorByIndex(size_t idx) {
12879 453 : switch (idx) {
12880 453 : case 0: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
12881 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12882 0 : ROSE_ASSERT(false);
12883 : return NULL;
12884 : }
12885 : }
12886 : size_t
12887 0 : SgOmpSectionStatement::get_childIndex(SgNode *child) {
12888 0 : if (child == p_body) return 0;
12889 0 : else return (size_t) -1;
12890 : }
12891 : vector<SgNode*>
12892 0 : SgOmpWorkshareStatement::get_traversalSuccessorContainer() {
12893 0 : vector<SgNode*> traversalSuccessorContainer;
12894 0 : traversalSuccessorContainer.reserve(1);
12895 0 : traversalSuccessorContainer.push_back(p_body);
12896 0 : return traversalSuccessorContainer;
12897 : }
12898 : vector<string>
12899 0 : SgOmpWorkshareStatement::get_traversalSuccessorNamesContainer() {
12900 0 : vector<string> traversalSuccessorContainer;
12901 0 : traversalSuccessorContainer.push_back("p_body");
12902 0 : return traversalSuccessorContainer;
12903 : }
12904 : size_t
12905 0 : SgOmpWorkshareStatement::get_numberOfTraversalSuccessors() {
12906 0 : return 1;
12907 : }
12908 : SgNode *
12909 0 : SgOmpWorkshareStatement::get_traversalSuccessorByIndex(size_t idx) {
12910 0 : switch (idx) {
12911 0 : case 0: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
12912 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
12913 0 : ROSE_ASSERT(false);
12914 : return NULL;
12915 : }
12916 : }
12917 : size_t
12918 0 : SgOmpWorkshareStatement::get_childIndex(SgNode *child) {
12919 0 : if (child == p_body) return 0;
12920 0 : else return (size_t) -1;
12921 : }
12922 : vector<SgNode*>
12923 0 : SgUpirFieldBodyStatement::get_traversalSuccessorContainer() {
12924 0 : vector<SgNode*> traversalSuccessorContainer;
12925 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
12926 0 : << "static: SgUpirFieldBodyStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
12927 0 : cerr << "Aborting ..." << endl;
12928 0 : ROSE_ASSERT(false);
12929 : return traversalSuccessorContainer;
12930 : }
12931 :
12932 : vector<string>
12933 0 : SgUpirFieldBodyStatement::get_traversalSuccessorNamesContainer() {
12934 0 : vector<string> traversalSuccessorContainer;
12935 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
12936 0 : << "static: SgUpirFieldBodyStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
12937 0 : cerr << "Aborting ..." << endl;
12938 0 : ROSE_ASSERT(false);
12939 : return traversalSuccessorContainer;
12940 : }
12941 :
12942 : size_t
12943 0 : SgUpirFieldBodyStatement::get_numberOfTraversalSuccessors() {
12944 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
12945 0 : << "static: SgUpirFieldBodyStatement" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
12946 0 : cerr << "Aborting ..." << endl;
12947 0 : ROSE_ASSERT(false);
12948 : return 42;
12949 : }
12950 :
12951 : SgNode*
12952 0 : SgUpirFieldBodyStatement::get_traversalSuccessorByIndex(size_t) {
12953 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
12954 0 : << "static: SgUpirFieldBodyStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
12955 0 : cerr << "Aborting ..." << endl;
12956 0 : ROSE_ASSERT(false);
12957 : return NULL;
12958 : }
12959 :
12960 : size_t
12961 0 : SgUpirFieldBodyStatement::get_childIndex(SgNode *) {
12962 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
12963 0 : << "static: SgUpirFieldBodyStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
12964 0 : cerr << "Aborting ..." << endl;
12965 0 : ROSE_ASSERT(false);
12966 : return 42;
12967 : }
12968 :
12969 : vector<SgNode*>
12970 711 : SgUpirSpmdStatement::get_traversalSuccessorContainer() {
12971 711 : vector<SgNode*> traversalSuccessorContainer;
12972 711 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
12973 711 : traversalSuccessorContainer.push_back(p_body);
12974 711 : {
12975 711 : SgOmpClausePtrList::iterator iter;
12976 1054 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
12977 343 : traversalSuccessorContainer.push_back(*iter);
12978 : }
12979 711 : return traversalSuccessorContainer;
12980 : }
12981 : vector<string>
12982 708 : SgUpirSpmdStatement::get_traversalSuccessorNamesContainer() {
12983 708 : vector<string> traversalSuccessorContainer;
12984 708 : int i = 1;
12985 1416 : traversalSuccessorContainer.push_back("p_body");
12986 708 : {
12987 708 : SgOmpClausePtrList::iterator iter;
12988 1050 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
12989 342 : char buf[20];
12990 342 : sprintf(buf,"*[%d]",i);
12991 684 : traversalSuccessorContainer.push_back(buf);
12992 : }
12993 : }
12994 708 : return traversalSuccessorContainer;
12995 : }
12996 : size_t
12997 5584 : SgUpirSpmdStatement::get_numberOfTraversalSuccessors() {
12998 5584 : return p_clauses.size() + 1;
12999 : }
13000 : SgNode *
13001 8274 : SgUpirSpmdStatement::get_traversalSuccessorByIndex(size_t idx) {
13002 8274 : if (idx == 0) return p_body;
13003 2690 : else return p_clauses[idx-1];
13004 : }
13005 : size_t
13006 0 : SgUpirSpmdStatement::get_childIndex(SgNode *child) {
13007 0 : if (child == p_body) return 0;
13008 : else {
13009 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13010 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13011 : else return (size_t) -1;
13012 : }
13013 : }
13014 : vector<SgNode*>
13015 6 : SgOmpTeamsStatement::get_traversalSuccessorContainer() {
13016 6 : vector<SgNode*> traversalSuccessorContainer;
13017 6 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13018 6 : traversalSuccessorContainer.push_back(p_body);
13019 6 : {
13020 6 : SgOmpClausePtrList::iterator iter;
13021 18 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13022 12 : traversalSuccessorContainer.push_back(*iter);
13023 : }
13024 6 : return traversalSuccessorContainer;
13025 : }
13026 : vector<string>
13027 6 : SgOmpTeamsStatement::get_traversalSuccessorNamesContainer() {
13028 6 : vector<string> traversalSuccessorContainer;
13029 6 : int i = 1;
13030 12 : traversalSuccessorContainer.push_back("p_body");
13031 6 : {
13032 6 : SgOmpClausePtrList::iterator iter;
13033 18 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13034 12 : char buf[20];
13035 12 : sprintf(buf,"*[%d]",i);
13036 24 : traversalSuccessorContainer.push_back(buf);
13037 : }
13038 : }
13039 6 : return traversalSuccessorContainer;
13040 : }
13041 : size_t
13042 48 : SgOmpTeamsStatement::get_numberOfTraversalSuccessors() {
13043 48 : return p_clauses.size() + 1;
13044 : }
13045 : SgNode *
13046 144 : SgOmpTeamsStatement::get_traversalSuccessorByIndex(size_t idx) {
13047 144 : if (idx == 0) return p_body;
13048 96 : else return p_clauses[idx-1];
13049 : }
13050 : size_t
13051 0 : SgOmpTeamsStatement::get_childIndex(SgNode *child) {
13052 0 : if (child == p_body) return 0;
13053 : else {
13054 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13055 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13056 : else return (size_t) -1;
13057 : }
13058 : }
13059 : vector<SgNode*>
13060 170 : SgOmpSingleStatement::get_traversalSuccessorContainer() {
13061 170 : vector<SgNode*> traversalSuccessorContainer;
13062 170 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13063 170 : traversalSuccessorContainer.push_back(p_body);
13064 170 : {
13065 170 : SgOmpClausePtrList::iterator iter;
13066 194 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13067 24 : traversalSuccessorContainer.push_back(*iter);
13068 : }
13069 170 : return traversalSuccessorContainer;
13070 : }
13071 : vector<string>
13072 168 : SgOmpSingleStatement::get_traversalSuccessorNamesContainer() {
13073 168 : vector<string> traversalSuccessorContainer;
13074 168 : int i = 1;
13075 336 : traversalSuccessorContainer.push_back("p_body");
13076 168 : {
13077 168 : SgOmpClausePtrList::iterator iter;
13078 192 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13079 24 : char buf[20];
13080 24 : sprintf(buf,"*[%d]",i);
13081 48 : traversalSuccessorContainer.push_back(buf);
13082 : }
13083 : }
13084 168 : return traversalSuccessorContainer;
13085 : }
13086 : size_t
13087 1317 : SgOmpSingleStatement::get_numberOfTraversalSuccessors() {
13088 1317 : return p_clauses.size() + 1;
13089 : }
13090 : SgNode *
13091 1507 : SgOmpSingleStatement::get_traversalSuccessorByIndex(size_t idx) {
13092 1507 : if (idx == 0) return p_body;
13093 190 : else return p_clauses[idx-1];
13094 : }
13095 : size_t
13096 0 : SgOmpSingleStatement::get_childIndex(SgNode *child) {
13097 0 : if (child == p_body) return 0;
13098 : else {
13099 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13100 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13101 : else return (size_t) -1;
13102 : }
13103 : }
13104 : vector<SgNode*>
13105 16 : SgOmpAtomicStatement::get_traversalSuccessorContainer() {
13106 16 : vector<SgNode*> traversalSuccessorContainer;
13107 16 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13108 16 : traversalSuccessorContainer.push_back(p_body);
13109 16 : {
13110 16 : SgOmpClausePtrList::iterator iter;
13111 30 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13112 14 : traversalSuccessorContainer.push_back(*iter);
13113 : }
13114 16 : return traversalSuccessorContainer;
13115 : }
13116 : vector<string>
13117 16 : SgOmpAtomicStatement::get_traversalSuccessorNamesContainer() {
13118 16 : vector<string> traversalSuccessorContainer;
13119 16 : int i = 1;
13120 32 : traversalSuccessorContainer.push_back("p_body");
13121 16 : {
13122 16 : SgOmpClausePtrList::iterator iter;
13123 30 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13124 14 : char buf[20];
13125 14 : sprintf(buf,"*[%d]",i);
13126 28 : traversalSuccessorContainer.push_back(buf);
13127 : }
13128 : }
13129 16 : return traversalSuccessorContainer;
13130 : }
13131 : size_t
13132 128 : SgOmpAtomicStatement::get_numberOfTraversalSuccessors() {
13133 128 : return p_clauses.size() + 1;
13134 : }
13135 : SgNode *
13136 240 : SgOmpAtomicStatement::get_traversalSuccessorByIndex(size_t idx) {
13137 240 : if (idx == 0) return p_body;
13138 112 : else return p_clauses[idx-1];
13139 : }
13140 : size_t
13141 0 : SgOmpAtomicStatement::get_childIndex(SgNode *child) {
13142 0 : if (child == p_body) return 0;
13143 : else {
13144 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13145 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13146 : else return (size_t) -1;
13147 : }
13148 : }
13149 : vector<SgNode*>
13150 0 : SgOmpScanStatement::get_traversalSuccessorContainer() {
13151 0 : vector<SgNode*> traversalSuccessorContainer;
13152 0 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13153 0 : traversalSuccessorContainer.push_back(p_body);
13154 0 : {
13155 0 : SgOmpClausePtrList::iterator iter;
13156 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13157 0 : traversalSuccessorContainer.push_back(*iter);
13158 : }
13159 0 : return traversalSuccessorContainer;
13160 : }
13161 : vector<string>
13162 0 : SgOmpScanStatement::get_traversalSuccessorNamesContainer() {
13163 0 : vector<string> traversalSuccessorContainer;
13164 0 : int i = 1;
13165 0 : traversalSuccessorContainer.push_back("p_body");
13166 0 : {
13167 0 : SgOmpClausePtrList::iterator iter;
13168 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13169 0 : char buf[20];
13170 0 : sprintf(buf,"*[%d]",i);
13171 0 : traversalSuccessorContainer.push_back(buf);
13172 : }
13173 : }
13174 0 : return traversalSuccessorContainer;
13175 : }
13176 : size_t
13177 0 : SgOmpScanStatement::get_numberOfTraversalSuccessors() {
13178 0 : return p_clauses.size() + 1;
13179 : }
13180 : SgNode *
13181 0 : SgOmpScanStatement::get_traversalSuccessorByIndex(size_t idx) {
13182 0 : if (idx == 0) return p_body;
13183 0 : else return p_clauses[idx-1];
13184 : }
13185 : size_t
13186 0 : SgOmpScanStatement::get_childIndex(SgNode *child) {
13187 0 : if (child == p_body) return 0;
13188 : else {
13189 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13190 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13191 : else return (size_t) -1;
13192 : }
13193 : }
13194 : vector<SgNode*>
13195 0 : SgOmpMetadirectiveStatement::get_traversalSuccessorContainer() {
13196 0 : vector<SgNode*> traversalSuccessorContainer;
13197 0 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13198 0 : traversalSuccessorContainer.push_back(p_body);
13199 0 : {
13200 0 : SgOmpClausePtrList::iterator iter;
13201 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13202 0 : traversalSuccessorContainer.push_back(*iter);
13203 : }
13204 0 : return traversalSuccessorContainer;
13205 : }
13206 : vector<string>
13207 0 : SgOmpMetadirectiveStatement::get_traversalSuccessorNamesContainer() {
13208 0 : vector<string> traversalSuccessorContainer;
13209 0 : int i = 1;
13210 0 : traversalSuccessorContainer.push_back("p_body");
13211 0 : {
13212 0 : SgOmpClausePtrList::iterator iter;
13213 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13214 0 : char buf[20];
13215 0 : sprintf(buf,"*[%d]",i);
13216 0 : traversalSuccessorContainer.push_back(buf);
13217 : }
13218 : }
13219 0 : return traversalSuccessorContainer;
13220 : }
13221 : size_t
13222 0 : SgOmpMetadirectiveStatement::get_numberOfTraversalSuccessors() {
13223 0 : return p_clauses.size() + 1;
13224 : }
13225 : SgNode *
13226 0 : SgOmpMetadirectiveStatement::get_traversalSuccessorByIndex(size_t idx) {
13227 0 : if (idx == 0) return p_body;
13228 0 : else return p_clauses[idx-1];
13229 : }
13230 : size_t
13231 0 : SgOmpMetadirectiveStatement::get_childIndex(SgNode *child) {
13232 0 : if (child == p_body) return 0;
13233 : else {
13234 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13235 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13236 : else return (size_t) -1;
13237 : }
13238 : }
13239 : vector<SgNode*>
13240 2 : SgOmpLoopStatement::get_traversalSuccessorContainer() {
13241 2 : vector<SgNode*> traversalSuccessorContainer;
13242 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13243 2 : traversalSuccessorContainer.push_back(p_body);
13244 2 : {
13245 2 : SgOmpClausePtrList::iterator iter;
13246 4 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13247 2 : traversalSuccessorContainer.push_back(*iter);
13248 : }
13249 2 : return traversalSuccessorContainer;
13250 : }
13251 : vector<string>
13252 2 : SgOmpLoopStatement::get_traversalSuccessorNamesContainer() {
13253 2 : vector<string> traversalSuccessorContainer;
13254 2 : int i = 1;
13255 4 : traversalSuccessorContainer.push_back("p_body");
13256 2 : {
13257 2 : SgOmpClausePtrList::iterator iter;
13258 4 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13259 2 : char buf[20];
13260 2 : sprintf(buf,"*[%d]",i);
13261 4 : traversalSuccessorContainer.push_back(buf);
13262 : }
13263 : }
13264 2 : return traversalSuccessorContainer;
13265 : }
13266 : size_t
13267 16 : SgOmpLoopStatement::get_numberOfTraversalSuccessors() {
13268 16 : return p_clauses.size() + 1;
13269 : }
13270 : SgNode *
13271 32 : SgOmpLoopStatement::get_traversalSuccessorByIndex(size_t idx) {
13272 32 : if (idx == 0) return p_body;
13273 16 : else return p_clauses[idx-1];
13274 : }
13275 : size_t
13276 0 : SgOmpLoopStatement::get_childIndex(SgNode *child) {
13277 0 : if (child == p_body) return 0;
13278 : else {
13279 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13280 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13281 : else return (size_t) -1;
13282 : }
13283 : }
13284 : vector<SgNode*>
13285 0 : SgOmpOrderedStatement::get_traversalSuccessorContainer() {
13286 0 : vector<SgNode*> traversalSuccessorContainer;
13287 0 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13288 0 : traversalSuccessorContainer.push_back(p_body);
13289 0 : {
13290 0 : SgOmpClausePtrList::iterator iter;
13291 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13292 0 : traversalSuccessorContainer.push_back(*iter);
13293 : }
13294 0 : return traversalSuccessorContainer;
13295 : }
13296 : vector<string>
13297 0 : SgOmpOrderedStatement::get_traversalSuccessorNamesContainer() {
13298 0 : vector<string> traversalSuccessorContainer;
13299 0 : int i = 1;
13300 0 : traversalSuccessorContainer.push_back("p_body");
13301 0 : {
13302 0 : SgOmpClausePtrList::iterator iter;
13303 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13304 0 : char buf[20];
13305 0 : sprintf(buf,"*[%d]",i);
13306 0 : traversalSuccessorContainer.push_back(buf);
13307 : }
13308 : }
13309 0 : return traversalSuccessorContainer;
13310 : }
13311 : size_t
13312 0 : SgOmpOrderedStatement::get_numberOfTraversalSuccessors() {
13313 0 : return p_clauses.size() + 1;
13314 : }
13315 : SgNode *
13316 0 : SgOmpOrderedStatement::get_traversalSuccessorByIndex(size_t idx) {
13317 0 : if (idx == 0) return p_body;
13318 0 : else return p_clauses[idx-1];
13319 : }
13320 : size_t
13321 0 : SgOmpOrderedStatement::get_childIndex(SgNode *child) {
13322 0 : if (child == p_body) return 0;
13323 : else {
13324 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13325 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13326 : else return (size_t) -1;
13327 : }
13328 : }
13329 : vector<SgNode*>
13330 4 : SgOmpTaskgroupStatement::get_traversalSuccessorContainer() {
13331 4 : vector<SgNode*> traversalSuccessorContainer;
13332 4 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13333 4 : traversalSuccessorContainer.push_back(p_body);
13334 4 : {
13335 4 : SgOmpClausePtrList::iterator iter;
13336 4 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13337 0 : traversalSuccessorContainer.push_back(*iter);
13338 : }
13339 4 : return traversalSuccessorContainer;
13340 : }
13341 : vector<string>
13342 4 : SgOmpTaskgroupStatement::get_traversalSuccessorNamesContainer() {
13343 4 : vector<string> traversalSuccessorContainer;
13344 4 : int i = 1;
13345 8 : traversalSuccessorContainer.push_back("p_body");
13346 4 : {
13347 4 : SgOmpClausePtrList::iterator iter;
13348 4 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13349 0 : char buf[20];
13350 0 : sprintf(buf,"*[%d]",i);
13351 0 : traversalSuccessorContainer.push_back(buf);
13352 : }
13353 : }
13354 4 : return traversalSuccessorContainer;
13355 : }
13356 : size_t
13357 31 : SgOmpTaskgroupStatement::get_numberOfTraversalSuccessors() {
13358 31 : return p_clauses.size() + 1;
13359 : }
13360 : SgNode *
13361 31 : SgOmpTaskgroupStatement::get_traversalSuccessorByIndex(size_t idx) {
13362 31 : if (idx == 0) return p_body;
13363 0 : else return p_clauses[idx-1];
13364 : }
13365 : size_t
13366 0 : SgOmpTaskgroupStatement::get_childIndex(SgNode *child) {
13367 0 : if (child == p_body) return 0;
13368 : else {
13369 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13370 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13371 : else return (size_t) -1;
13372 : }
13373 : }
13374 : vector<SgNode*>
13375 4 : SgOmpTaskloopStatement::get_traversalSuccessorContainer() {
13376 4 : vector<SgNode*> traversalSuccessorContainer;
13377 4 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13378 4 : traversalSuccessorContainer.push_back(p_body);
13379 4 : {
13380 4 : SgOmpClausePtrList::iterator iter;
13381 10 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13382 6 : traversalSuccessorContainer.push_back(*iter);
13383 : }
13384 4 : return traversalSuccessorContainer;
13385 : }
13386 : vector<string>
13387 4 : SgOmpTaskloopStatement::get_traversalSuccessorNamesContainer() {
13388 4 : vector<string> traversalSuccessorContainer;
13389 4 : int i = 1;
13390 8 : traversalSuccessorContainer.push_back("p_body");
13391 4 : {
13392 4 : SgOmpClausePtrList::iterator iter;
13393 10 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13394 6 : char buf[20];
13395 6 : sprintf(buf,"*[%d]",i);
13396 12 : traversalSuccessorContainer.push_back(buf);
13397 : }
13398 : }
13399 4 : return traversalSuccessorContainer;
13400 : }
13401 : size_t
13402 32 : SgOmpTaskloopStatement::get_numberOfTraversalSuccessors() {
13403 32 : return p_clauses.size() + 1;
13404 : }
13405 : SgNode *
13406 80 : SgOmpTaskloopStatement::get_traversalSuccessorByIndex(size_t idx) {
13407 80 : if (idx == 0) return p_body;
13408 48 : else return p_clauses[idx-1];
13409 : }
13410 : size_t
13411 0 : SgOmpTaskloopStatement::get_childIndex(SgNode *child) {
13412 0 : if (child == p_body) return 0;
13413 : else {
13414 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13415 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13416 : else return (size_t) -1;
13417 : }
13418 : }
13419 : vector<SgNode*>
13420 6 : SgOmpDepobjStatement::get_traversalSuccessorContainer() {
13421 6 : vector<SgNode*> traversalSuccessorContainer;
13422 6 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13423 6 : traversalSuccessorContainer.push_back(p_body);
13424 6 : {
13425 6 : SgOmpClausePtrList::iterator iter;
13426 12 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13427 6 : traversalSuccessorContainer.push_back(*iter);
13428 : }
13429 6 : return traversalSuccessorContainer;
13430 : }
13431 : vector<string>
13432 6 : SgOmpDepobjStatement::get_traversalSuccessorNamesContainer() {
13433 6 : vector<string> traversalSuccessorContainer;
13434 6 : int i = 1;
13435 12 : traversalSuccessorContainer.push_back("p_body");
13436 6 : {
13437 6 : SgOmpClausePtrList::iterator iter;
13438 12 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13439 6 : char buf[20];
13440 6 : sprintf(buf,"*[%d]",i);
13441 12 : traversalSuccessorContainer.push_back(buf);
13442 : }
13443 : }
13444 6 : return traversalSuccessorContainer;
13445 : }
13446 : size_t
13447 48 : SgOmpDepobjStatement::get_numberOfTraversalSuccessors() {
13448 48 : return p_clauses.size() + 1;
13449 : }
13450 : SgNode *
13451 96 : SgOmpDepobjStatement::get_traversalSuccessorByIndex(size_t idx) {
13452 96 : if (idx == 0) return p_body;
13453 48 : else return p_clauses[idx-1];
13454 : }
13455 : size_t
13456 0 : SgOmpDepobjStatement::get_childIndex(SgNode *child) {
13457 0 : if (child == p_body) return 0;
13458 : else {
13459 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13460 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13461 : else return (size_t) -1;
13462 : }
13463 : }
13464 : vector<SgNode*>
13465 0 : SgOmpTargetEnterDataStatement::get_traversalSuccessorContainer() {
13466 0 : vector<SgNode*> traversalSuccessorContainer;
13467 0 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13468 0 : traversalSuccessorContainer.push_back(p_body);
13469 0 : {
13470 0 : SgOmpClausePtrList::iterator iter;
13471 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13472 0 : traversalSuccessorContainer.push_back(*iter);
13473 : }
13474 0 : return traversalSuccessorContainer;
13475 : }
13476 : vector<string>
13477 0 : SgOmpTargetEnterDataStatement::get_traversalSuccessorNamesContainer() {
13478 0 : vector<string> traversalSuccessorContainer;
13479 0 : int i = 1;
13480 0 : traversalSuccessorContainer.push_back("p_body");
13481 0 : {
13482 0 : SgOmpClausePtrList::iterator iter;
13483 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13484 0 : char buf[20];
13485 0 : sprintf(buf,"*[%d]",i);
13486 0 : traversalSuccessorContainer.push_back(buf);
13487 : }
13488 : }
13489 0 : return traversalSuccessorContainer;
13490 : }
13491 : size_t
13492 0 : SgOmpTargetEnterDataStatement::get_numberOfTraversalSuccessors() {
13493 0 : return p_clauses.size() + 1;
13494 : }
13495 : SgNode *
13496 0 : SgOmpTargetEnterDataStatement::get_traversalSuccessorByIndex(size_t idx) {
13497 0 : if (idx == 0) return p_body;
13498 0 : else return p_clauses[idx-1];
13499 : }
13500 : size_t
13501 0 : SgOmpTargetEnterDataStatement::get_childIndex(SgNode *child) {
13502 0 : if (child == p_body) return 0;
13503 : else {
13504 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13505 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13506 : else return (size_t) -1;
13507 : }
13508 : }
13509 : vector<SgNode*>
13510 0 : SgOmpTargetExitDataStatement::get_traversalSuccessorContainer() {
13511 0 : vector<SgNode*> traversalSuccessorContainer;
13512 0 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13513 0 : traversalSuccessorContainer.push_back(p_body);
13514 0 : {
13515 0 : SgOmpClausePtrList::iterator iter;
13516 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13517 0 : traversalSuccessorContainer.push_back(*iter);
13518 : }
13519 0 : return traversalSuccessorContainer;
13520 : }
13521 : vector<string>
13522 0 : SgOmpTargetExitDataStatement::get_traversalSuccessorNamesContainer() {
13523 0 : vector<string> traversalSuccessorContainer;
13524 0 : int i = 1;
13525 0 : traversalSuccessorContainer.push_back("p_body");
13526 0 : {
13527 0 : SgOmpClausePtrList::iterator iter;
13528 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13529 0 : char buf[20];
13530 0 : sprintf(buf,"*[%d]",i);
13531 0 : traversalSuccessorContainer.push_back(buf);
13532 : }
13533 : }
13534 0 : return traversalSuccessorContainer;
13535 : }
13536 : size_t
13537 0 : SgOmpTargetExitDataStatement::get_numberOfTraversalSuccessors() {
13538 0 : return p_clauses.size() + 1;
13539 : }
13540 : SgNode *
13541 0 : SgOmpTargetExitDataStatement::get_traversalSuccessorByIndex(size_t idx) {
13542 0 : if (idx == 0) return p_body;
13543 0 : else return p_clauses[idx-1];
13544 : }
13545 : size_t
13546 0 : SgOmpTargetExitDataStatement::get_childIndex(SgNode *child) {
13547 0 : if (child == p_body) return 0;
13548 : else {
13549 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13550 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13551 : else return (size_t) -1;
13552 : }
13553 : }
13554 : vector<SgNode*>
13555 6 : SgOmpParallelMasterStatement::get_traversalSuccessorContainer() {
13556 6 : vector<SgNode*> traversalSuccessorContainer;
13557 6 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13558 6 : traversalSuccessorContainer.push_back(p_body);
13559 6 : {
13560 6 : SgOmpClausePtrList::iterator iter;
13561 8 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13562 2 : traversalSuccessorContainer.push_back(*iter);
13563 : }
13564 6 : return traversalSuccessorContainer;
13565 : }
13566 : vector<string>
13567 6 : SgOmpParallelMasterStatement::get_traversalSuccessorNamesContainer() {
13568 6 : vector<string> traversalSuccessorContainer;
13569 6 : int i = 1;
13570 12 : traversalSuccessorContainer.push_back("p_body");
13571 6 : {
13572 6 : SgOmpClausePtrList::iterator iter;
13573 8 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13574 2 : char buf[20];
13575 2 : sprintf(buf,"*[%d]",i);
13576 4 : traversalSuccessorContainer.push_back(buf);
13577 : }
13578 : }
13579 6 : return traversalSuccessorContainer;
13580 : }
13581 : size_t
13582 48 : SgOmpParallelMasterStatement::get_numberOfTraversalSuccessors() {
13583 48 : return p_clauses.size() + 1;
13584 : }
13585 : SgNode *
13586 64 : SgOmpParallelMasterStatement::get_traversalSuccessorByIndex(size_t idx) {
13587 64 : if (idx == 0) return p_body;
13588 16 : else return p_clauses[idx-1];
13589 : }
13590 : size_t
13591 0 : SgOmpParallelMasterStatement::get_childIndex(SgNode *child) {
13592 0 : if (child == p_body) return 0;
13593 : else {
13594 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13595 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13596 : else return (size_t) -1;
13597 : }
13598 : }
13599 : vector<SgNode*>
13600 4 : SgOmpMasterTaskloopStatement::get_traversalSuccessorContainer() {
13601 4 : vector<SgNode*> traversalSuccessorContainer;
13602 4 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13603 4 : traversalSuccessorContainer.push_back(p_body);
13604 4 : {
13605 4 : SgOmpClausePtrList::iterator iter;
13606 8 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13607 4 : traversalSuccessorContainer.push_back(*iter);
13608 : }
13609 4 : return traversalSuccessorContainer;
13610 : }
13611 : vector<string>
13612 4 : SgOmpMasterTaskloopStatement::get_traversalSuccessorNamesContainer() {
13613 4 : vector<string> traversalSuccessorContainer;
13614 4 : int i = 1;
13615 8 : traversalSuccessorContainer.push_back("p_body");
13616 4 : {
13617 4 : SgOmpClausePtrList::iterator iter;
13618 8 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13619 4 : char buf[20];
13620 4 : sprintf(buf,"*[%d]",i);
13621 8 : traversalSuccessorContainer.push_back(buf);
13622 : }
13623 : }
13624 4 : return traversalSuccessorContainer;
13625 : }
13626 : size_t
13627 32 : SgOmpMasterTaskloopStatement::get_numberOfTraversalSuccessors() {
13628 32 : return p_clauses.size() + 1;
13629 : }
13630 : SgNode *
13631 64 : SgOmpMasterTaskloopStatement::get_traversalSuccessorByIndex(size_t idx) {
13632 64 : if (idx == 0) return p_body;
13633 32 : else return p_clauses[idx-1];
13634 : }
13635 : size_t
13636 0 : SgOmpMasterTaskloopStatement::get_childIndex(SgNode *child) {
13637 0 : if (child == p_body) return 0;
13638 : else {
13639 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13640 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13641 : else return (size_t) -1;
13642 : }
13643 : }
13644 : vector<SgNode*>
13645 148 : SgOmpTaskStatement::get_traversalSuccessorContainer() {
13646 148 : vector<SgNode*> traversalSuccessorContainer;
13647 148 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13648 148 : traversalSuccessorContainer.push_back(p_body);
13649 148 : {
13650 148 : SgOmpClausePtrList::iterator iter;
13651 312 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13652 164 : traversalSuccessorContainer.push_back(*iter);
13653 : }
13654 148 : return traversalSuccessorContainer;
13655 : }
13656 : vector<string>
13657 146 : SgOmpTaskStatement::get_traversalSuccessorNamesContainer() {
13658 146 : vector<string> traversalSuccessorContainer;
13659 146 : int i = 1;
13660 292 : traversalSuccessorContainer.push_back("p_body");
13661 146 : {
13662 146 : SgOmpClausePtrList::iterator iter;
13663 310 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13664 164 : char buf[20];
13665 164 : sprintf(buf,"*[%d]",i);
13666 328 : traversalSuccessorContainer.push_back(buf);
13667 : }
13668 : }
13669 146 : return traversalSuccessorContainer;
13670 : }
13671 : size_t
13672 1138 : SgOmpTaskStatement::get_numberOfTraversalSuccessors() {
13673 1138 : return p_clauses.size() + 1;
13674 : }
13675 : SgNode *
13676 2429 : SgOmpTaskStatement::get_traversalSuccessorByIndex(size_t idx) {
13677 2429 : if (idx == 0) return p_body;
13678 1291 : else return p_clauses[idx-1];
13679 : }
13680 : size_t
13681 0 : SgOmpTaskStatement::get_childIndex(SgNode *child) {
13682 0 : if (child == p_body) return 0;
13683 : else {
13684 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13685 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13686 : else return (size_t) -1;
13687 : }
13688 : }
13689 : vector<SgNode*>
13690 24 : SgOmpDoStatement::get_traversalSuccessorContainer() {
13691 24 : vector<SgNode*> traversalSuccessorContainer;
13692 24 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13693 24 : traversalSuccessorContainer.push_back(p_body);
13694 24 : {
13695 24 : SgOmpClausePtrList::iterator iter;
13696 50 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13697 26 : traversalSuccessorContainer.push_back(*iter);
13698 : }
13699 24 : return traversalSuccessorContainer;
13700 : }
13701 : vector<string>
13702 24 : SgOmpDoStatement::get_traversalSuccessorNamesContainer() {
13703 24 : vector<string> traversalSuccessorContainer;
13704 24 : int i = 1;
13705 48 : traversalSuccessorContainer.push_back("p_body");
13706 24 : {
13707 24 : SgOmpClausePtrList::iterator iter;
13708 50 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13709 26 : char buf[20];
13710 26 : sprintf(buf,"*[%d]",i);
13711 52 : traversalSuccessorContainer.push_back(buf);
13712 : }
13713 : }
13714 24 : return traversalSuccessorContainer;
13715 : }
13716 : size_t
13717 168 : SgOmpDoStatement::get_numberOfTraversalSuccessors() {
13718 168 : return p_clauses.size() + 1;
13719 : }
13720 : SgNode *
13721 350 : SgOmpDoStatement::get_traversalSuccessorByIndex(size_t idx) {
13722 350 : if (idx == 0) return p_body;
13723 182 : else return p_clauses[idx-1];
13724 : }
13725 : size_t
13726 0 : SgOmpDoStatement::get_childIndex(SgNode *child) {
13727 0 : if (child == p_body) return 0;
13728 : else {
13729 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13730 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13731 : else return (size_t) -1;
13732 : }
13733 : }
13734 : vector<SgNode*>
13735 22 : SgOmpSectionsStatement::get_traversalSuccessorContainer() {
13736 22 : vector<SgNode*> traversalSuccessorContainer;
13737 22 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13738 22 : traversalSuccessorContainer.push_back(p_body);
13739 22 : {
13740 22 : SgOmpClausePtrList::iterator iter;
13741 58 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13742 36 : traversalSuccessorContainer.push_back(*iter);
13743 : }
13744 22 : return traversalSuccessorContainer;
13745 : }
13746 : vector<string>
13747 22 : SgOmpSectionsStatement::get_traversalSuccessorNamesContainer() {
13748 22 : vector<string> traversalSuccessorContainer;
13749 22 : int i = 1;
13750 44 : traversalSuccessorContainer.push_back("p_body");
13751 22 : {
13752 22 : SgOmpClausePtrList::iterator iter;
13753 58 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13754 36 : char buf[20];
13755 36 : sprintf(buf,"*[%d]",i);
13756 72 : traversalSuccessorContainer.push_back(buf);
13757 : }
13758 : }
13759 22 : return traversalSuccessorContainer;
13760 : }
13761 : size_t
13762 171 : SgOmpSectionsStatement::get_numberOfTraversalSuccessors() {
13763 171 : return p_clauses.size() + 1;
13764 : }
13765 : SgNode *
13766 455 : SgOmpSectionsStatement::get_traversalSuccessorByIndex(size_t idx) {
13767 455 : if (idx == 0) return p_body;
13768 284 : else return p_clauses[idx-1];
13769 : }
13770 : size_t
13771 0 : SgOmpSectionsStatement::get_childIndex(SgNode *child) {
13772 0 : if (child == p_body) return 0;
13773 : else {
13774 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13775 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13776 : else return (size_t) -1;
13777 : }
13778 : }
13779 : vector<SgNode*>
13780 48 : SgUpirTaskStatement::get_traversalSuccessorContainer() {
13781 48 : vector<SgNode*> traversalSuccessorContainer;
13782 48 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13783 48 : traversalSuccessorContainer.push_back(p_body);
13784 48 : {
13785 48 : SgOmpClausePtrList::iterator iter;
13786 122 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13787 74 : traversalSuccessorContainer.push_back(*iter);
13788 : }
13789 48 : return traversalSuccessorContainer;
13790 : }
13791 : vector<string>
13792 48 : SgUpirTaskStatement::get_traversalSuccessorNamesContainer() {
13793 48 : vector<string> traversalSuccessorContainer;
13794 48 : int i = 1;
13795 96 : traversalSuccessorContainer.push_back("p_body");
13796 48 : {
13797 48 : SgOmpClausePtrList::iterator iter;
13798 122 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13799 74 : char buf[20];
13800 74 : sprintf(buf,"*[%d]",i);
13801 148 : traversalSuccessorContainer.push_back(buf);
13802 : }
13803 : }
13804 48 : return traversalSuccessorContainer;
13805 : }
13806 : size_t
13807 382 : SgUpirTaskStatement::get_numberOfTraversalSuccessors() {
13808 382 : return p_clauses.size() + 1;
13809 : }
13810 : SgNode *
13811 965 : SgUpirTaskStatement::get_traversalSuccessorByIndex(size_t idx) {
13812 965 : if (idx == 0) return p_body;
13813 583 : else return p_clauses[idx-1];
13814 : }
13815 : size_t
13816 0 : SgUpirTaskStatement::get_childIndex(SgNode *child) {
13817 0 : if (child == p_body) return 0;
13818 : else {
13819 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13820 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13821 : else return (size_t) -1;
13822 : }
13823 : }
13824 : vector<SgNode*>
13825 14 : SgOmpTargetDataStatement::get_traversalSuccessorContainer() {
13826 14 : vector<SgNode*> traversalSuccessorContainer;
13827 14 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13828 14 : traversalSuccessorContainer.push_back(p_body);
13829 14 : {
13830 14 : SgOmpClausePtrList::iterator iter;
13831 40 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13832 26 : traversalSuccessorContainer.push_back(*iter);
13833 : }
13834 14 : return traversalSuccessorContainer;
13835 : }
13836 : vector<string>
13837 14 : SgOmpTargetDataStatement::get_traversalSuccessorNamesContainer() {
13838 14 : vector<string> traversalSuccessorContainer;
13839 14 : int i = 1;
13840 28 : traversalSuccessorContainer.push_back("p_body");
13841 14 : {
13842 14 : SgOmpClausePtrList::iterator iter;
13843 40 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13844 26 : char buf[20];
13845 26 : sprintf(buf,"*[%d]",i);
13846 52 : traversalSuccessorContainer.push_back(buf);
13847 : }
13848 : }
13849 14 : return traversalSuccessorContainer;
13850 : }
13851 : size_t
13852 112 : SgOmpTargetDataStatement::get_numberOfTraversalSuccessors() {
13853 112 : return p_clauses.size() + 1;
13854 : }
13855 : SgNode *
13856 314 : SgOmpTargetDataStatement::get_traversalSuccessorByIndex(size_t idx) {
13857 314 : if (idx == 0) return p_body;
13858 202 : else return p_clauses[idx-1];
13859 : }
13860 : size_t
13861 0 : SgOmpTargetDataStatement::get_childIndex(SgNode *child) {
13862 0 : if (child == p_body) return 0;
13863 : else {
13864 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13865 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13866 : else return (size_t) -1;
13867 : }
13868 : }
13869 : vector<SgNode*>
13870 0 : SgOmpTargetParallelForStatement::get_traversalSuccessorContainer() {
13871 0 : vector<SgNode*> traversalSuccessorContainer;
13872 0 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13873 0 : traversalSuccessorContainer.push_back(p_body);
13874 0 : {
13875 0 : SgOmpClausePtrList::iterator iter;
13876 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13877 0 : traversalSuccessorContainer.push_back(*iter);
13878 : }
13879 0 : return traversalSuccessorContainer;
13880 : }
13881 : vector<string>
13882 0 : SgOmpTargetParallelForStatement::get_traversalSuccessorNamesContainer() {
13883 0 : vector<string> traversalSuccessorContainer;
13884 0 : int i = 1;
13885 0 : traversalSuccessorContainer.push_back("p_body");
13886 0 : {
13887 0 : SgOmpClausePtrList::iterator iter;
13888 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13889 0 : char buf[20];
13890 0 : sprintf(buf,"*[%d]",i);
13891 0 : traversalSuccessorContainer.push_back(buf);
13892 : }
13893 : }
13894 0 : return traversalSuccessorContainer;
13895 : }
13896 : size_t
13897 0 : SgOmpTargetParallelForStatement::get_numberOfTraversalSuccessors() {
13898 0 : return p_clauses.size() + 1;
13899 : }
13900 : SgNode *
13901 0 : SgOmpTargetParallelForStatement::get_traversalSuccessorByIndex(size_t idx) {
13902 0 : if (idx == 0) return p_body;
13903 0 : else return p_clauses[idx-1];
13904 : }
13905 : size_t
13906 0 : SgOmpTargetParallelForStatement::get_childIndex(SgNode *child) {
13907 0 : if (child == p_body) return 0;
13908 : else {
13909 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13910 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13911 : else return (size_t) -1;
13912 : }
13913 : }
13914 : vector<SgNode*>
13915 2 : SgOmpParallelLoopStatement::get_traversalSuccessorContainer() {
13916 2 : vector<SgNode*> traversalSuccessorContainer;
13917 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13918 2 : traversalSuccessorContainer.push_back(p_body);
13919 2 : {
13920 2 : SgOmpClausePtrList::iterator iter;
13921 4 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13922 2 : traversalSuccessorContainer.push_back(*iter);
13923 : }
13924 2 : return traversalSuccessorContainer;
13925 : }
13926 : vector<string>
13927 2 : SgOmpParallelLoopStatement::get_traversalSuccessorNamesContainer() {
13928 2 : vector<string> traversalSuccessorContainer;
13929 2 : int i = 1;
13930 4 : traversalSuccessorContainer.push_back("p_body");
13931 2 : {
13932 2 : SgOmpClausePtrList::iterator iter;
13933 4 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13934 2 : char buf[20];
13935 2 : sprintf(buf,"*[%d]",i);
13936 4 : traversalSuccessorContainer.push_back(buf);
13937 : }
13938 : }
13939 2 : return traversalSuccessorContainer;
13940 : }
13941 : size_t
13942 16 : SgOmpParallelLoopStatement::get_numberOfTraversalSuccessors() {
13943 16 : return p_clauses.size() + 1;
13944 : }
13945 : SgNode *
13946 32 : SgOmpParallelLoopStatement::get_traversalSuccessorByIndex(size_t idx) {
13947 32 : if (idx == 0) return p_body;
13948 16 : else return p_clauses[idx-1];
13949 : }
13950 : size_t
13951 0 : SgOmpParallelLoopStatement::get_childIndex(SgNode *child) {
13952 0 : if (child == p_body) return 0;
13953 : else {
13954 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
13955 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
13956 : else return (size_t) -1;
13957 : }
13958 : }
13959 : vector<SgNode*>
13960 2 : SgOmpTargetParallelStatement::get_traversalSuccessorContainer() {
13961 2 : vector<SgNode*> traversalSuccessorContainer;
13962 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
13963 2 : traversalSuccessorContainer.push_back(p_body);
13964 2 : {
13965 2 : SgOmpClausePtrList::iterator iter;
13966 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
13967 0 : traversalSuccessorContainer.push_back(*iter);
13968 : }
13969 2 : return traversalSuccessorContainer;
13970 : }
13971 : vector<string>
13972 2 : SgOmpTargetParallelStatement::get_traversalSuccessorNamesContainer() {
13973 2 : vector<string> traversalSuccessorContainer;
13974 2 : int i = 1;
13975 4 : traversalSuccessorContainer.push_back("p_body");
13976 2 : {
13977 2 : SgOmpClausePtrList::iterator iter;
13978 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
13979 0 : char buf[20];
13980 0 : sprintf(buf,"*[%d]",i);
13981 0 : traversalSuccessorContainer.push_back(buf);
13982 : }
13983 : }
13984 2 : return traversalSuccessorContainer;
13985 : }
13986 : size_t
13987 16 : SgOmpTargetParallelStatement::get_numberOfTraversalSuccessors() {
13988 16 : return p_clauses.size() + 1;
13989 : }
13990 : SgNode *
13991 16 : SgOmpTargetParallelStatement::get_traversalSuccessorByIndex(size_t idx) {
13992 16 : if (idx == 0) return p_body;
13993 0 : else return p_clauses[idx-1];
13994 : }
13995 : size_t
13996 0 : SgOmpTargetParallelStatement::get_childIndex(SgNode *child) {
13997 0 : if (child == p_body) return 0;
13998 : else {
13999 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14000 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14001 : else return (size_t) -1;
14002 : }
14003 : }
14004 : vector<SgNode*>
14005 2 : SgOmpTargetParallelForSimdStatement::get_traversalSuccessorContainer() {
14006 2 : vector<SgNode*> traversalSuccessorContainer;
14007 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14008 2 : traversalSuccessorContainer.push_back(p_body);
14009 2 : {
14010 2 : SgOmpClausePtrList::iterator iter;
14011 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14012 0 : traversalSuccessorContainer.push_back(*iter);
14013 : }
14014 2 : return traversalSuccessorContainer;
14015 : }
14016 : vector<string>
14017 2 : SgOmpTargetParallelForSimdStatement::get_traversalSuccessorNamesContainer() {
14018 2 : vector<string> traversalSuccessorContainer;
14019 2 : int i = 1;
14020 4 : traversalSuccessorContainer.push_back("p_body");
14021 2 : {
14022 2 : SgOmpClausePtrList::iterator iter;
14023 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14024 0 : char buf[20];
14025 0 : sprintf(buf,"*[%d]",i);
14026 0 : traversalSuccessorContainer.push_back(buf);
14027 : }
14028 : }
14029 2 : return traversalSuccessorContainer;
14030 : }
14031 : size_t
14032 16 : SgOmpTargetParallelForSimdStatement::get_numberOfTraversalSuccessors() {
14033 16 : return p_clauses.size() + 1;
14034 : }
14035 : SgNode *
14036 16 : SgOmpTargetParallelForSimdStatement::get_traversalSuccessorByIndex(size_t idx) {
14037 16 : if (idx == 0) return p_body;
14038 0 : else return p_clauses[idx-1];
14039 : }
14040 : size_t
14041 0 : SgOmpTargetParallelForSimdStatement::get_childIndex(SgNode *child) {
14042 0 : if (child == p_body) return 0;
14043 : else {
14044 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14045 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14046 : else return (size_t) -1;
14047 : }
14048 : }
14049 : vector<SgNode*>
14050 2 : SgOmpTargetParallelLoopStatement::get_traversalSuccessorContainer() {
14051 2 : vector<SgNode*> traversalSuccessorContainer;
14052 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14053 2 : traversalSuccessorContainer.push_back(p_body);
14054 2 : {
14055 2 : SgOmpClausePtrList::iterator iter;
14056 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14057 0 : traversalSuccessorContainer.push_back(*iter);
14058 : }
14059 2 : return traversalSuccessorContainer;
14060 : }
14061 : vector<string>
14062 2 : SgOmpTargetParallelLoopStatement::get_traversalSuccessorNamesContainer() {
14063 2 : vector<string> traversalSuccessorContainer;
14064 2 : int i = 1;
14065 4 : traversalSuccessorContainer.push_back("p_body");
14066 2 : {
14067 2 : SgOmpClausePtrList::iterator iter;
14068 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14069 0 : char buf[20];
14070 0 : sprintf(buf,"*[%d]",i);
14071 0 : traversalSuccessorContainer.push_back(buf);
14072 : }
14073 : }
14074 2 : return traversalSuccessorContainer;
14075 : }
14076 : size_t
14077 16 : SgOmpTargetParallelLoopStatement::get_numberOfTraversalSuccessors() {
14078 16 : return p_clauses.size() + 1;
14079 : }
14080 : SgNode *
14081 16 : SgOmpTargetParallelLoopStatement::get_traversalSuccessorByIndex(size_t idx) {
14082 16 : if (idx == 0) return p_body;
14083 0 : else return p_clauses[idx-1];
14084 : }
14085 : size_t
14086 0 : SgOmpTargetParallelLoopStatement::get_childIndex(SgNode *child) {
14087 0 : if (child == p_body) return 0;
14088 : else {
14089 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14090 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14091 : else return (size_t) -1;
14092 : }
14093 : }
14094 : vector<SgNode*>
14095 2 : SgOmpTargetSimdStatement::get_traversalSuccessorContainer() {
14096 2 : vector<SgNode*> traversalSuccessorContainer;
14097 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14098 2 : traversalSuccessorContainer.push_back(p_body);
14099 2 : {
14100 2 : SgOmpClausePtrList::iterator iter;
14101 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14102 0 : traversalSuccessorContainer.push_back(*iter);
14103 : }
14104 2 : return traversalSuccessorContainer;
14105 : }
14106 : vector<string>
14107 2 : SgOmpTargetSimdStatement::get_traversalSuccessorNamesContainer() {
14108 2 : vector<string> traversalSuccessorContainer;
14109 2 : int i = 1;
14110 4 : traversalSuccessorContainer.push_back("p_body");
14111 2 : {
14112 2 : SgOmpClausePtrList::iterator iter;
14113 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14114 0 : char buf[20];
14115 0 : sprintf(buf,"*[%d]",i);
14116 0 : traversalSuccessorContainer.push_back(buf);
14117 : }
14118 : }
14119 2 : return traversalSuccessorContainer;
14120 : }
14121 : size_t
14122 16 : SgOmpTargetSimdStatement::get_numberOfTraversalSuccessors() {
14123 16 : return p_clauses.size() + 1;
14124 : }
14125 : SgNode *
14126 16 : SgOmpTargetSimdStatement::get_traversalSuccessorByIndex(size_t idx) {
14127 16 : if (idx == 0) return p_body;
14128 0 : else return p_clauses[idx-1];
14129 : }
14130 : size_t
14131 0 : SgOmpTargetSimdStatement::get_childIndex(SgNode *child) {
14132 0 : if (child == p_body) return 0;
14133 : else {
14134 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14135 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14136 : else return (size_t) -1;
14137 : }
14138 : }
14139 : vector<SgNode*>
14140 8 : SgOmpTargetTeamsStatement::get_traversalSuccessorContainer() {
14141 8 : vector<SgNode*> traversalSuccessorContainer;
14142 8 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14143 8 : traversalSuccessorContainer.push_back(p_body);
14144 8 : {
14145 8 : SgOmpClausePtrList::iterator iter;
14146 22 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14147 14 : traversalSuccessorContainer.push_back(*iter);
14148 : }
14149 8 : return traversalSuccessorContainer;
14150 : }
14151 : vector<string>
14152 8 : SgOmpTargetTeamsStatement::get_traversalSuccessorNamesContainer() {
14153 8 : vector<string> traversalSuccessorContainer;
14154 8 : int i = 1;
14155 16 : traversalSuccessorContainer.push_back("p_body");
14156 8 : {
14157 8 : SgOmpClausePtrList::iterator iter;
14158 22 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14159 14 : char buf[20];
14160 14 : sprintf(buf,"*[%d]",i);
14161 28 : traversalSuccessorContainer.push_back(buf);
14162 : }
14163 : }
14164 8 : return traversalSuccessorContainer;
14165 : }
14166 : size_t
14167 64 : SgOmpTargetTeamsStatement::get_numberOfTraversalSuccessors() {
14168 64 : return p_clauses.size() + 1;
14169 : }
14170 : SgNode *
14171 176 : SgOmpTargetTeamsStatement::get_traversalSuccessorByIndex(size_t idx) {
14172 176 : if (idx == 0) return p_body;
14173 112 : else return p_clauses[idx-1];
14174 : }
14175 : size_t
14176 0 : SgOmpTargetTeamsStatement::get_childIndex(SgNode *child) {
14177 0 : if (child == p_body) return 0;
14178 : else {
14179 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14180 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14181 : else return (size_t) -1;
14182 : }
14183 : }
14184 : vector<SgNode*>
14185 2 : SgOmpTargetTeamsDistributeStatement::get_traversalSuccessorContainer() {
14186 2 : vector<SgNode*> traversalSuccessorContainer;
14187 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14188 2 : traversalSuccessorContainer.push_back(p_body);
14189 2 : {
14190 2 : SgOmpClausePtrList::iterator iter;
14191 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14192 0 : traversalSuccessorContainer.push_back(*iter);
14193 : }
14194 2 : return traversalSuccessorContainer;
14195 : }
14196 : vector<string>
14197 2 : SgOmpTargetTeamsDistributeStatement::get_traversalSuccessorNamesContainer() {
14198 2 : vector<string> traversalSuccessorContainer;
14199 2 : int i = 1;
14200 4 : traversalSuccessorContainer.push_back("p_body");
14201 2 : {
14202 2 : SgOmpClausePtrList::iterator iter;
14203 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14204 0 : char buf[20];
14205 0 : sprintf(buf,"*[%d]",i);
14206 0 : traversalSuccessorContainer.push_back(buf);
14207 : }
14208 : }
14209 2 : return traversalSuccessorContainer;
14210 : }
14211 : size_t
14212 16 : SgOmpTargetTeamsDistributeStatement::get_numberOfTraversalSuccessors() {
14213 16 : return p_clauses.size() + 1;
14214 : }
14215 : SgNode *
14216 16 : SgOmpTargetTeamsDistributeStatement::get_traversalSuccessorByIndex(size_t idx) {
14217 16 : if (idx == 0) return p_body;
14218 0 : else return p_clauses[idx-1];
14219 : }
14220 : size_t
14221 0 : SgOmpTargetTeamsDistributeStatement::get_childIndex(SgNode *child) {
14222 0 : if (child == p_body) return 0;
14223 : else {
14224 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14225 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14226 : else return (size_t) -1;
14227 : }
14228 : }
14229 : vector<SgNode*>
14230 2 : SgOmpTargetTeamsDistributeSimdStatement::get_traversalSuccessorContainer() {
14231 2 : vector<SgNode*> traversalSuccessorContainer;
14232 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14233 2 : traversalSuccessorContainer.push_back(p_body);
14234 2 : {
14235 2 : SgOmpClausePtrList::iterator iter;
14236 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14237 0 : traversalSuccessorContainer.push_back(*iter);
14238 : }
14239 2 : return traversalSuccessorContainer;
14240 : }
14241 : vector<string>
14242 2 : SgOmpTargetTeamsDistributeSimdStatement::get_traversalSuccessorNamesContainer() {
14243 2 : vector<string> traversalSuccessorContainer;
14244 2 : int i = 1;
14245 4 : traversalSuccessorContainer.push_back("p_body");
14246 2 : {
14247 2 : SgOmpClausePtrList::iterator iter;
14248 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14249 0 : char buf[20];
14250 0 : sprintf(buf,"*[%d]",i);
14251 0 : traversalSuccessorContainer.push_back(buf);
14252 : }
14253 : }
14254 2 : return traversalSuccessorContainer;
14255 : }
14256 : size_t
14257 16 : SgOmpTargetTeamsDistributeSimdStatement::get_numberOfTraversalSuccessors() {
14258 16 : return p_clauses.size() + 1;
14259 : }
14260 : SgNode *
14261 16 : SgOmpTargetTeamsDistributeSimdStatement::get_traversalSuccessorByIndex(size_t idx) {
14262 16 : if (idx == 0) return p_body;
14263 0 : else return p_clauses[idx-1];
14264 : }
14265 : size_t
14266 0 : SgOmpTargetTeamsDistributeSimdStatement::get_childIndex(SgNode *child) {
14267 0 : if (child == p_body) return 0;
14268 : else {
14269 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14270 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14271 : else return (size_t) -1;
14272 : }
14273 : }
14274 : vector<SgNode*>
14275 2 : SgOmpTargetTeamsLoopStatement::get_traversalSuccessorContainer() {
14276 2 : vector<SgNode*> traversalSuccessorContainer;
14277 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14278 2 : traversalSuccessorContainer.push_back(p_body);
14279 2 : {
14280 2 : SgOmpClausePtrList::iterator iter;
14281 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14282 0 : traversalSuccessorContainer.push_back(*iter);
14283 : }
14284 2 : return traversalSuccessorContainer;
14285 : }
14286 : vector<string>
14287 2 : SgOmpTargetTeamsLoopStatement::get_traversalSuccessorNamesContainer() {
14288 2 : vector<string> traversalSuccessorContainer;
14289 2 : int i = 1;
14290 4 : traversalSuccessorContainer.push_back("p_body");
14291 2 : {
14292 2 : SgOmpClausePtrList::iterator iter;
14293 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14294 0 : char buf[20];
14295 0 : sprintf(buf,"*[%d]",i);
14296 0 : traversalSuccessorContainer.push_back(buf);
14297 : }
14298 : }
14299 2 : return traversalSuccessorContainer;
14300 : }
14301 : size_t
14302 16 : SgOmpTargetTeamsLoopStatement::get_numberOfTraversalSuccessors() {
14303 16 : return p_clauses.size() + 1;
14304 : }
14305 : SgNode *
14306 16 : SgOmpTargetTeamsLoopStatement::get_traversalSuccessorByIndex(size_t idx) {
14307 16 : if (idx == 0) return p_body;
14308 0 : else return p_clauses[idx-1];
14309 : }
14310 : size_t
14311 0 : SgOmpTargetTeamsLoopStatement::get_childIndex(SgNode *child) {
14312 0 : if (child == p_body) return 0;
14313 : else {
14314 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14315 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14316 : else return (size_t) -1;
14317 : }
14318 : }
14319 : vector<SgNode*>
14320 2 : SgOmpTargetTeamsDistributeParallelForStatement::get_traversalSuccessorContainer() {
14321 2 : vector<SgNode*> traversalSuccessorContainer;
14322 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14323 2 : traversalSuccessorContainer.push_back(p_body);
14324 2 : {
14325 2 : SgOmpClausePtrList::iterator iter;
14326 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14327 0 : traversalSuccessorContainer.push_back(*iter);
14328 : }
14329 2 : return traversalSuccessorContainer;
14330 : }
14331 : vector<string>
14332 2 : SgOmpTargetTeamsDistributeParallelForStatement::get_traversalSuccessorNamesContainer() {
14333 2 : vector<string> traversalSuccessorContainer;
14334 2 : int i = 1;
14335 4 : traversalSuccessorContainer.push_back("p_body");
14336 2 : {
14337 2 : SgOmpClausePtrList::iterator iter;
14338 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14339 0 : char buf[20];
14340 0 : sprintf(buf,"*[%d]",i);
14341 0 : traversalSuccessorContainer.push_back(buf);
14342 : }
14343 : }
14344 2 : return traversalSuccessorContainer;
14345 : }
14346 : size_t
14347 16 : SgOmpTargetTeamsDistributeParallelForStatement::get_numberOfTraversalSuccessors() {
14348 16 : return p_clauses.size() + 1;
14349 : }
14350 : SgNode *
14351 16 : SgOmpTargetTeamsDistributeParallelForStatement::get_traversalSuccessorByIndex(size_t idx) {
14352 16 : if (idx == 0) return p_body;
14353 0 : else return p_clauses[idx-1];
14354 : }
14355 : size_t
14356 0 : SgOmpTargetTeamsDistributeParallelForStatement::get_childIndex(SgNode *child) {
14357 0 : if (child == p_body) return 0;
14358 : else {
14359 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14360 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14361 : else return (size_t) -1;
14362 : }
14363 : }
14364 : vector<SgNode*>
14365 2 : SgOmpTargetTeamsDistributeParallelForSimdStatement::get_traversalSuccessorContainer() {
14366 2 : vector<SgNode*> traversalSuccessorContainer;
14367 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14368 2 : traversalSuccessorContainer.push_back(p_body);
14369 2 : {
14370 2 : SgOmpClausePtrList::iterator iter;
14371 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14372 0 : traversalSuccessorContainer.push_back(*iter);
14373 : }
14374 2 : return traversalSuccessorContainer;
14375 : }
14376 : vector<string>
14377 2 : SgOmpTargetTeamsDistributeParallelForSimdStatement::get_traversalSuccessorNamesContainer() {
14378 2 : vector<string> traversalSuccessorContainer;
14379 2 : int i = 1;
14380 4 : traversalSuccessorContainer.push_back("p_body");
14381 2 : {
14382 2 : SgOmpClausePtrList::iterator iter;
14383 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14384 0 : char buf[20];
14385 0 : sprintf(buf,"*[%d]",i);
14386 0 : traversalSuccessorContainer.push_back(buf);
14387 : }
14388 : }
14389 2 : return traversalSuccessorContainer;
14390 : }
14391 : size_t
14392 16 : SgOmpTargetTeamsDistributeParallelForSimdStatement::get_numberOfTraversalSuccessors() {
14393 16 : return p_clauses.size() + 1;
14394 : }
14395 : SgNode *
14396 16 : SgOmpTargetTeamsDistributeParallelForSimdStatement::get_traversalSuccessorByIndex(size_t idx) {
14397 16 : if (idx == 0) return p_body;
14398 0 : else return p_clauses[idx-1];
14399 : }
14400 : size_t
14401 0 : SgOmpTargetTeamsDistributeParallelForSimdStatement::get_childIndex(SgNode *child) {
14402 0 : if (child == p_body) return 0;
14403 : else {
14404 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14405 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14406 : else return (size_t) -1;
14407 : }
14408 : }
14409 : vector<SgNode*>
14410 2 : SgOmpDistributeSimdStatement::get_traversalSuccessorContainer() {
14411 2 : vector<SgNode*> traversalSuccessorContainer;
14412 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14413 2 : traversalSuccessorContainer.push_back(p_body);
14414 2 : {
14415 2 : SgOmpClausePtrList::iterator iter;
14416 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14417 0 : traversalSuccessorContainer.push_back(*iter);
14418 : }
14419 2 : return traversalSuccessorContainer;
14420 : }
14421 : vector<string>
14422 2 : SgOmpDistributeSimdStatement::get_traversalSuccessorNamesContainer() {
14423 2 : vector<string> traversalSuccessorContainer;
14424 2 : int i = 1;
14425 4 : traversalSuccessorContainer.push_back("p_body");
14426 2 : {
14427 2 : SgOmpClausePtrList::iterator iter;
14428 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14429 0 : char buf[20];
14430 0 : sprintf(buf,"*[%d]",i);
14431 0 : traversalSuccessorContainer.push_back(buf);
14432 : }
14433 : }
14434 2 : return traversalSuccessorContainer;
14435 : }
14436 : size_t
14437 16 : SgOmpDistributeSimdStatement::get_numberOfTraversalSuccessors() {
14438 16 : return p_clauses.size() + 1;
14439 : }
14440 : SgNode *
14441 16 : SgOmpDistributeSimdStatement::get_traversalSuccessorByIndex(size_t idx) {
14442 16 : if (idx == 0) return p_body;
14443 0 : else return p_clauses[idx-1];
14444 : }
14445 : size_t
14446 0 : SgOmpDistributeSimdStatement::get_childIndex(SgNode *child) {
14447 0 : if (child == p_body) return 0;
14448 : else {
14449 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14450 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14451 : else return (size_t) -1;
14452 : }
14453 : }
14454 : vector<SgNode*>
14455 2 : SgOmpDistributeParallelForStatement::get_traversalSuccessorContainer() {
14456 2 : vector<SgNode*> traversalSuccessorContainer;
14457 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14458 2 : traversalSuccessorContainer.push_back(p_body);
14459 2 : {
14460 2 : SgOmpClausePtrList::iterator iter;
14461 4 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14462 2 : traversalSuccessorContainer.push_back(*iter);
14463 : }
14464 2 : return traversalSuccessorContainer;
14465 : }
14466 : vector<string>
14467 2 : SgOmpDistributeParallelForStatement::get_traversalSuccessorNamesContainer() {
14468 2 : vector<string> traversalSuccessorContainer;
14469 2 : int i = 1;
14470 4 : traversalSuccessorContainer.push_back("p_body");
14471 2 : {
14472 2 : SgOmpClausePtrList::iterator iter;
14473 4 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14474 2 : char buf[20];
14475 2 : sprintf(buf,"*[%d]",i);
14476 4 : traversalSuccessorContainer.push_back(buf);
14477 : }
14478 : }
14479 2 : return traversalSuccessorContainer;
14480 : }
14481 : size_t
14482 16 : SgOmpDistributeParallelForStatement::get_numberOfTraversalSuccessors() {
14483 16 : return p_clauses.size() + 1;
14484 : }
14485 : SgNode *
14486 32 : SgOmpDistributeParallelForStatement::get_traversalSuccessorByIndex(size_t idx) {
14487 32 : if (idx == 0) return p_body;
14488 16 : else return p_clauses[idx-1];
14489 : }
14490 : size_t
14491 0 : SgOmpDistributeParallelForStatement::get_childIndex(SgNode *child) {
14492 0 : if (child == p_body) return 0;
14493 : else {
14494 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14495 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14496 : else return (size_t) -1;
14497 : }
14498 : }
14499 : vector<SgNode*>
14500 2 : SgOmpDistributeParallelForSimdStatement::get_traversalSuccessorContainer() {
14501 2 : vector<SgNode*> traversalSuccessorContainer;
14502 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14503 2 : traversalSuccessorContainer.push_back(p_body);
14504 2 : {
14505 2 : SgOmpClausePtrList::iterator iter;
14506 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14507 0 : traversalSuccessorContainer.push_back(*iter);
14508 : }
14509 2 : return traversalSuccessorContainer;
14510 : }
14511 : vector<string>
14512 2 : SgOmpDistributeParallelForSimdStatement::get_traversalSuccessorNamesContainer() {
14513 2 : vector<string> traversalSuccessorContainer;
14514 2 : int i = 1;
14515 4 : traversalSuccessorContainer.push_back("p_body");
14516 2 : {
14517 2 : SgOmpClausePtrList::iterator iter;
14518 2 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14519 0 : char buf[20];
14520 0 : sprintf(buf,"*[%d]",i);
14521 0 : traversalSuccessorContainer.push_back(buf);
14522 : }
14523 : }
14524 2 : return traversalSuccessorContainer;
14525 : }
14526 : size_t
14527 16 : SgOmpDistributeParallelForSimdStatement::get_numberOfTraversalSuccessors() {
14528 16 : return p_clauses.size() + 1;
14529 : }
14530 : SgNode *
14531 16 : SgOmpDistributeParallelForSimdStatement::get_traversalSuccessorByIndex(size_t idx) {
14532 16 : if (idx == 0) return p_body;
14533 0 : else return p_clauses[idx-1];
14534 : }
14535 : size_t
14536 0 : SgOmpDistributeParallelForSimdStatement::get_childIndex(SgNode *child) {
14537 0 : if (child == p_body) return 0;
14538 : else {
14539 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14540 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14541 : else return (size_t) -1;
14542 : }
14543 : }
14544 : vector<SgNode*>
14545 2 : SgOmpTaskloopSimdStatement::get_traversalSuccessorContainer() {
14546 2 : vector<SgNode*> traversalSuccessorContainer;
14547 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14548 2 : traversalSuccessorContainer.push_back(p_body);
14549 2 : {
14550 2 : SgOmpClausePtrList::iterator iter;
14551 4 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14552 2 : traversalSuccessorContainer.push_back(*iter);
14553 : }
14554 2 : return traversalSuccessorContainer;
14555 : }
14556 : vector<string>
14557 2 : SgOmpTaskloopSimdStatement::get_traversalSuccessorNamesContainer() {
14558 2 : vector<string> traversalSuccessorContainer;
14559 2 : int i = 1;
14560 4 : traversalSuccessorContainer.push_back("p_body");
14561 2 : {
14562 2 : SgOmpClausePtrList::iterator iter;
14563 4 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14564 2 : char buf[20];
14565 2 : sprintf(buf,"*[%d]",i);
14566 4 : traversalSuccessorContainer.push_back(buf);
14567 : }
14568 : }
14569 2 : return traversalSuccessorContainer;
14570 : }
14571 : size_t
14572 16 : SgOmpTaskloopSimdStatement::get_numberOfTraversalSuccessors() {
14573 16 : return p_clauses.size() + 1;
14574 : }
14575 : SgNode *
14576 32 : SgOmpTaskloopSimdStatement::get_traversalSuccessorByIndex(size_t idx) {
14577 32 : if (idx == 0) return p_body;
14578 16 : else return p_clauses[idx-1];
14579 : }
14580 : size_t
14581 0 : SgOmpTaskloopSimdStatement::get_childIndex(SgNode *child) {
14582 0 : if (child == p_body) return 0;
14583 : else {
14584 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14585 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14586 : else return (size_t) -1;
14587 : }
14588 : }
14589 : vector<SgNode*>
14590 4 : SgOmpMasterTaskloopSimdStatement::get_traversalSuccessorContainer() {
14591 4 : vector<SgNode*> traversalSuccessorContainer;
14592 4 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14593 4 : traversalSuccessorContainer.push_back(p_body);
14594 4 : {
14595 4 : SgOmpClausePtrList::iterator iter;
14596 8 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14597 4 : traversalSuccessorContainer.push_back(*iter);
14598 : }
14599 4 : return traversalSuccessorContainer;
14600 : }
14601 : vector<string>
14602 4 : SgOmpMasterTaskloopSimdStatement::get_traversalSuccessorNamesContainer() {
14603 4 : vector<string> traversalSuccessorContainer;
14604 4 : int i = 1;
14605 8 : traversalSuccessorContainer.push_back("p_body");
14606 4 : {
14607 4 : SgOmpClausePtrList::iterator iter;
14608 8 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14609 4 : char buf[20];
14610 4 : sprintf(buf,"*[%d]",i);
14611 8 : traversalSuccessorContainer.push_back(buf);
14612 : }
14613 : }
14614 4 : return traversalSuccessorContainer;
14615 : }
14616 : size_t
14617 32 : SgOmpMasterTaskloopSimdStatement::get_numberOfTraversalSuccessors() {
14618 32 : return p_clauses.size() + 1;
14619 : }
14620 : SgNode *
14621 64 : SgOmpMasterTaskloopSimdStatement::get_traversalSuccessorByIndex(size_t idx) {
14622 64 : if (idx == 0) return p_body;
14623 32 : else return p_clauses[idx-1];
14624 : }
14625 : size_t
14626 0 : SgOmpMasterTaskloopSimdStatement::get_childIndex(SgNode *child) {
14627 0 : if (child == p_body) return 0;
14628 : else {
14629 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14630 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14631 : else return (size_t) -1;
14632 : }
14633 : }
14634 : vector<SgNode*>
14635 2 : SgOmpParallelMasterTaskloopStatement::get_traversalSuccessorContainer() {
14636 2 : vector<SgNode*> traversalSuccessorContainer;
14637 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14638 2 : traversalSuccessorContainer.push_back(p_body);
14639 2 : {
14640 2 : SgOmpClausePtrList::iterator iter;
14641 4 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14642 2 : traversalSuccessorContainer.push_back(*iter);
14643 : }
14644 2 : return traversalSuccessorContainer;
14645 : }
14646 : vector<string>
14647 2 : SgOmpParallelMasterTaskloopStatement::get_traversalSuccessorNamesContainer() {
14648 2 : vector<string> traversalSuccessorContainer;
14649 2 : int i = 1;
14650 4 : traversalSuccessorContainer.push_back("p_body");
14651 2 : {
14652 2 : SgOmpClausePtrList::iterator iter;
14653 4 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14654 2 : char buf[20];
14655 2 : sprintf(buf,"*[%d]",i);
14656 4 : traversalSuccessorContainer.push_back(buf);
14657 : }
14658 : }
14659 2 : return traversalSuccessorContainer;
14660 : }
14661 : size_t
14662 16 : SgOmpParallelMasterTaskloopStatement::get_numberOfTraversalSuccessors() {
14663 16 : return p_clauses.size() + 1;
14664 : }
14665 : SgNode *
14666 32 : SgOmpParallelMasterTaskloopStatement::get_traversalSuccessorByIndex(size_t idx) {
14667 32 : if (idx == 0) return p_body;
14668 16 : else return p_clauses[idx-1];
14669 : }
14670 : size_t
14671 0 : SgOmpParallelMasterTaskloopStatement::get_childIndex(SgNode *child) {
14672 0 : if (child == p_body) return 0;
14673 : else {
14674 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14675 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14676 : else return (size_t) -1;
14677 : }
14678 : }
14679 : vector<SgNode*>
14680 2 : SgOmpParallelMasterTaskloopSimdStatement::get_traversalSuccessorContainer() {
14681 2 : vector<SgNode*> traversalSuccessorContainer;
14682 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14683 2 : traversalSuccessorContainer.push_back(p_body);
14684 2 : {
14685 2 : SgOmpClausePtrList::iterator iter;
14686 4 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14687 2 : traversalSuccessorContainer.push_back(*iter);
14688 : }
14689 2 : return traversalSuccessorContainer;
14690 : }
14691 : vector<string>
14692 2 : SgOmpParallelMasterTaskloopSimdStatement::get_traversalSuccessorNamesContainer() {
14693 2 : vector<string> traversalSuccessorContainer;
14694 2 : int i = 1;
14695 4 : traversalSuccessorContainer.push_back("p_body");
14696 2 : {
14697 2 : SgOmpClausePtrList::iterator iter;
14698 4 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14699 2 : char buf[20];
14700 2 : sprintf(buf,"*[%d]",i);
14701 4 : traversalSuccessorContainer.push_back(buf);
14702 : }
14703 : }
14704 2 : return traversalSuccessorContainer;
14705 : }
14706 : size_t
14707 16 : SgOmpParallelMasterTaskloopSimdStatement::get_numberOfTraversalSuccessors() {
14708 16 : return p_clauses.size() + 1;
14709 : }
14710 : SgNode *
14711 32 : SgOmpParallelMasterTaskloopSimdStatement::get_traversalSuccessorByIndex(size_t idx) {
14712 32 : if (idx == 0) return p_body;
14713 16 : else return p_clauses[idx-1];
14714 : }
14715 : size_t
14716 0 : SgOmpParallelMasterTaskloopSimdStatement::get_childIndex(SgNode *child) {
14717 0 : if (child == p_body) return 0;
14718 : else {
14719 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14720 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14721 : else return (size_t) -1;
14722 : }
14723 : }
14724 : vector<SgNode*>
14725 2 : SgOmpTeamsDistributeStatement::get_traversalSuccessorContainer() {
14726 2 : vector<SgNode*> traversalSuccessorContainer;
14727 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14728 2 : traversalSuccessorContainer.push_back(p_body);
14729 2 : {
14730 2 : SgOmpClausePtrList::iterator iter;
14731 6 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14732 4 : traversalSuccessorContainer.push_back(*iter);
14733 : }
14734 2 : return traversalSuccessorContainer;
14735 : }
14736 : vector<string>
14737 2 : SgOmpTeamsDistributeStatement::get_traversalSuccessorNamesContainer() {
14738 2 : vector<string> traversalSuccessorContainer;
14739 2 : int i = 1;
14740 4 : traversalSuccessorContainer.push_back("p_body");
14741 2 : {
14742 2 : SgOmpClausePtrList::iterator iter;
14743 6 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14744 4 : char buf[20];
14745 4 : sprintf(buf,"*[%d]",i);
14746 8 : traversalSuccessorContainer.push_back(buf);
14747 : }
14748 : }
14749 2 : return traversalSuccessorContainer;
14750 : }
14751 : size_t
14752 16 : SgOmpTeamsDistributeStatement::get_numberOfTraversalSuccessors() {
14753 16 : return p_clauses.size() + 1;
14754 : }
14755 : SgNode *
14756 48 : SgOmpTeamsDistributeStatement::get_traversalSuccessorByIndex(size_t idx) {
14757 48 : if (idx == 0) return p_body;
14758 32 : else return p_clauses[idx-1];
14759 : }
14760 : size_t
14761 0 : SgOmpTeamsDistributeStatement::get_childIndex(SgNode *child) {
14762 0 : if (child == p_body) return 0;
14763 : else {
14764 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14765 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14766 : else return (size_t) -1;
14767 : }
14768 : }
14769 : vector<SgNode*>
14770 2 : SgOmpTeamsDistributeSimdStatement::get_traversalSuccessorContainer() {
14771 2 : vector<SgNode*> traversalSuccessorContainer;
14772 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14773 2 : traversalSuccessorContainer.push_back(p_body);
14774 2 : {
14775 2 : SgOmpClausePtrList::iterator iter;
14776 6 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14777 4 : traversalSuccessorContainer.push_back(*iter);
14778 : }
14779 2 : return traversalSuccessorContainer;
14780 : }
14781 : vector<string>
14782 2 : SgOmpTeamsDistributeSimdStatement::get_traversalSuccessorNamesContainer() {
14783 2 : vector<string> traversalSuccessorContainer;
14784 2 : int i = 1;
14785 4 : traversalSuccessorContainer.push_back("p_body");
14786 2 : {
14787 2 : SgOmpClausePtrList::iterator iter;
14788 6 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14789 4 : char buf[20];
14790 4 : sprintf(buf,"*[%d]",i);
14791 8 : traversalSuccessorContainer.push_back(buf);
14792 : }
14793 : }
14794 2 : return traversalSuccessorContainer;
14795 : }
14796 : size_t
14797 16 : SgOmpTeamsDistributeSimdStatement::get_numberOfTraversalSuccessors() {
14798 16 : return p_clauses.size() + 1;
14799 : }
14800 : SgNode *
14801 48 : SgOmpTeamsDistributeSimdStatement::get_traversalSuccessorByIndex(size_t idx) {
14802 48 : if (idx == 0) return p_body;
14803 32 : else return p_clauses[idx-1];
14804 : }
14805 : size_t
14806 0 : SgOmpTeamsDistributeSimdStatement::get_childIndex(SgNode *child) {
14807 0 : if (child == p_body) return 0;
14808 : else {
14809 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14810 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14811 : else return (size_t) -1;
14812 : }
14813 : }
14814 : vector<SgNode*>
14815 2 : SgOmpTeamsDistributeParallelForStatement::get_traversalSuccessorContainer() {
14816 2 : vector<SgNode*> traversalSuccessorContainer;
14817 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14818 2 : traversalSuccessorContainer.push_back(p_body);
14819 2 : {
14820 2 : SgOmpClausePtrList::iterator iter;
14821 6 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14822 4 : traversalSuccessorContainer.push_back(*iter);
14823 : }
14824 2 : return traversalSuccessorContainer;
14825 : }
14826 : vector<string>
14827 2 : SgOmpTeamsDistributeParallelForStatement::get_traversalSuccessorNamesContainer() {
14828 2 : vector<string> traversalSuccessorContainer;
14829 2 : int i = 1;
14830 4 : traversalSuccessorContainer.push_back("p_body");
14831 2 : {
14832 2 : SgOmpClausePtrList::iterator iter;
14833 6 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14834 4 : char buf[20];
14835 4 : sprintf(buf,"*[%d]",i);
14836 8 : traversalSuccessorContainer.push_back(buf);
14837 : }
14838 : }
14839 2 : return traversalSuccessorContainer;
14840 : }
14841 : size_t
14842 16 : SgOmpTeamsDistributeParallelForStatement::get_numberOfTraversalSuccessors() {
14843 16 : return p_clauses.size() + 1;
14844 : }
14845 : SgNode *
14846 48 : SgOmpTeamsDistributeParallelForStatement::get_traversalSuccessorByIndex(size_t idx) {
14847 48 : if (idx == 0) return p_body;
14848 32 : else return p_clauses[idx-1];
14849 : }
14850 : size_t
14851 0 : SgOmpTeamsDistributeParallelForStatement::get_childIndex(SgNode *child) {
14852 0 : if (child == p_body) return 0;
14853 : else {
14854 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14855 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14856 : else return (size_t) -1;
14857 : }
14858 : }
14859 : vector<SgNode*>
14860 2 : SgOmpTeamsDistributeParallelForSimdStatement::get_traversalSuccessorContainer() {
14861 2 : vector<SgNode*> traversalSuccessorContainer;
14862 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14863 2 : traversalSuccessorContainer.push_back(p_body);
14864 2 : {
14865 2 : SgOmpClausePtrList::iterator iter;
14866 6 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14867 4 : traversalSuccessorContainer.push_back(*iter);
14868 : }
14869 2 : return traversalSuccessorContainer;
14870 : }
14871 : vector<string>
14872 2 : SgOmpTeamsDistributeParallelForSimdStatement::get_traversalSuccessorNamesContainer() {
14873 2 : vector<string> traversalSuccessorContainer;
14874 2 : int i = 1;
14875 4 : traversalSuccessorContainer.push_back("p_body");
14876 2 : {
14877 2 : SgOmpClausePtrList::iterator iter;
14878 6 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14879 4 : char buf[20];
14880 4 : sprintf(buf,"*[%d]",i);
14881 8 : traversalSuccessorContainer.push_back(buf);
14882 : }
14883 : }
14884 2 : return traversalSuccessorContainer;
14885 : }
14886 : size_t
14887 16 : SgOmpTeamsDistributeParallelForSimdStatement::get_numberOfTraversalSuccessors() {
14888 16 : return p_clauses.size() + 1;
14889 : }
14890 : SgNode *
14891 48 : SgOmpTeamsDistributeParallelForSimdStatement::get_traversalSuccessorByIndex(size_t idx) {
14892 48 : if (idx == 0) return p_body;
14893 32 : else return p_clauses[idx-1];
14894 : }
14895 : size_t
14896 0 : SgOmpTeamsDistributeParallelForSimdStatement::get_childIndex(SgNode *child) {
14897 0 : if (child == p_body) return 0;
14898 : else {
14899 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14900 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14901 : else return (size_t) -1;
14902 : }
14903 : }
14904 : vector<SgNode*>
14905 2 : SgOmpTeamsLoopStatement::get_traversalSuccessorContainer() {
14906 2 : vector<SgNode*> traversalSuccessorContainer;
14907 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14908 2 : traversalSuccessorContainer.push_back(p_body);
14909 2 : {
14910 2 : SgOmpClausePtrList::iterator iter;
14911 6 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14912 4 : traversalSuccessorContainer.push_back(*iter);
14913 : }
14914 2 : return traversalSuccessorContainer;
14915 : }
14916 : vector<string>
14917 2 : SgOmpTeamsLoopStatement::get_traversalSuccessorNamesContainer() {
14918 2 : vector<string> traversalSuccessorContainer;
14919 2 : int i = 1;
14920 4 : traversalSuccessorContainer.push_back("p_body");
14921 2 : {
14922 2 : SgOmpClausePtrList::iterator iter;
14923 6 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14924 4 : char buf[20];
14925 4 : sprintf(buf,"*[%d]",i);
14926 8 : traversalSuccessorContainer.push_back(buf);
14927 : }
14928 : }
14929 2 : return traversalSuccessorContainer;
14930 : }
14931 : size_t
14932 16 : SgOmpTeamsLoopStatement::get_numberOfTraversalSuccessors() {
14933 16 : return p_clauses.size() + 1;
14934 : }
14935 : SgNode *
14936 48 : SgOmpTeamsLoopStatement::get_traversalSuccessorByIndex(size_t idx) {
14937 48 : if (idx == 0) return p_body;
14938 32 : else return p_clauses[idx-1];
14939 : }
14940 : size_t
14941 0 : SgOmpTeamsLoopStatement::get_childIndex(SgNode *child) {
14942 0 : if (child == p_body) return 0;
14943 : else {
14944 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14945 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14946 : else return (size_t) -1;
14947 : }
14948 : }
14949 : vector<SgNode*>
14950 2 : SgOmpForSimdStatement::get_traversalSuccessorContainer() {
14951 2 : vector<SgNode*> traversalSuccessorContainer;
14952 2 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14953 2 : traversalSuccessorContainer.push_back(p_body);
14954 2 : {
14955 2 : SgOmpClausePtrList::iterator iter;
14956 6 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
14957 4 : traversalSuccessorContainer.push_back(*iter);
14958 : }
14959 2 : return traversalSuccessorContainer;
14960 : }
14961 : vector<string>
14962 2 : SgOmpForSimdStatement::get_traversalSuccessorNamesContainer() {
14963 2 : vector<string> traversalSuccessorContainer;
14964 2 : int i = 1;
14965 4 : traversalSuccessorContainer.push_back("p_body");
14966 2 : {
14967 2 : SgOmpClausePtrList::iterator iter;
14968 6 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
14969 4 : char buf[20];
14970 4 : sprintf(buf,"*[%d]",i);
14971 8 : traversalSuccessorContainer.push_back(buf);
14972 : }
14973 : }
14974 2 : return traversalSuccessorContainer;
14975 : }
14976 : size_t
14977 16 : SgOmpForSimdStatement::get_numberOfTraversalSuccessors() {
14978 16 : return p_clauses.size() + 1;
14979 : }
14980 : SgNode *
14981 48 : SgOmpForSimdStatement::get_traversalSuccessorByIndex(size_t idx) {
14982 48 : if (idx == 0) return p_body;
14983 32 : else return p_clauses[idx-1];
14984 : }
14985 : size_t
14986 0 : SgOmpForSimdStatement::get_childIndex(SgNode *child) {
14987 0 : if (child == p_body) return 0;
14988 : else {
14989 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
14990 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
14991 : else return (size_t) -1;
14992 : }
14993 : }
14994 : vector<SgNode*>
14995 118 : SgOmpCriticalStatement::get_traversalSuccessorContainer() {
14996 118 : vector<SgNode*> traversalSuccessorContainer;
14997 118 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
14998 118 : traversalSuccessorContainer.push_back(p_body);
14999 118 : {
15000 118 : SgOmpClausePtrList::iterator iter;
15001 122 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
15002 4 : traversalSuccessorContainer.push_back(*iter);
15003 : }
15004 118 : return traversalSuccessorContainer;
15005 : }
15006 : vector<string>
15007 118 : SgOmpCriticalStatement::get_traversalSuccessorNamesContainer() {
15008 118 : vector<string> traversalSuccessorContainer;
15009 118 : int i = 1;
15010 236 : traversalSuccessorContainer.push_back("p_body");
15011 118 : {
15012 118 : SgOmpClausePtrList::iterator iter;
15013 122 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
15014 4 : char buf[20];
15015 4 : sprintf(buf,"*[%d]",i);
15016 8 : traversalSuccessorContainer.push_back(buf);
15017 : }
15018 : }
15019 118 : return traversalSuccessorContainer;
15020 : }
15021 : size_t
15022 976 : SgOmpCriticalStatement::get_numberOfTraversalSuccessors() {
15023 976 : return p_clauses.size() + 1;
15024 : }
15025 : SgNode *
15026 1008 : SgOmpCriticalStatement::get_traversalSuccessorByIndex(size_t idx) {
15027 1008 : if (idx == 0) return p_body;
15028 32 : else return p_clauses[idx-1];
15029 : }
15030 : size_t
15031 0 : SgOmpCriticalStatement::get_childIndex(SgNode *child) {
15032 0 : if (child == p_body) return 0;
15033 : else {
15034 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
15035 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
15036 : else return (size_t) -1;
15037 : }
15038 : }
15039 : vector<SgNode*>
15040 4 : SgOmpDistributeStatement::get_traversalSuccessorContainer() {
15041 4 : vector<SgNode*> traversalSuccessorContainer;
15042 4 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
15043 4 : traversalSuccessorContainer.push_back(p_body);
15044 4 : {
15045 4 : SgOmpClausePtrList::iterator iter;
15046 6 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
15047 2 : traversalSuccessorContainer.push_back(*iter);
15048 : }
15049 4 : return traversalSuccessorContainer;
15050 : }
15051 : vector<string>
15052 4 : SgOmpDistributeStatement::get_traversalSuccessorNamesContainer() {
15053 4 : vector<string> traversalSuccessorContainer;
15054 4 : int i = 1;
15055 8 : traversalSuccessorContainer.push_back("p_body");
15056 4 : {
15057 4 : SgOmpClausePtrList::iterator iter;
15058 6 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
15059 2 : char buf[20];
15060 2 : sprintf(buf,"*[%d]",i);
15061 4 : traversalSuccessorContainer.push_back(buf);
15062 : }
15063 : }
15064 4 : return traversalSuccessorContainer;
15065 : }
15066 : size_t
15067 32 : SgOmpDistributeStatement::get_numberOfTraversalSuccessors() {
15068 32 : return p_clauses.size() + 1;
15069 : }
15070 : SgNode *
15071 48 : SgOmpDistributeStatement::get_traversalSuccessorByIndex(size_t idx) {
15072 48 : if (idx == 0) return p_body;
15073 16 : else return p_clauses[idx-1];
15074 : }
15075 : size_t
15076 0 : SgOmpDistributeStatement::get_childIndex(SgNode *child) {
15077 0 : if (child == p_body) return 0;
15078 : else {
15079 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
15080 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
15081 : else return (size_t) -1;
15082 : }
15083 : }
15084 : vector<SgNode*>
15085 0 : SgOmpUnrollStatement::get_traversalSuccessorContainer() {
15086 0 : vector<SgNode*> traversalSuccessorContainer;
15087 0 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
15088 0 : traversalSuccessorContainer.push_back(p_body);
15089 0 : {
15090 0 : SgOmpClausePtrList::iterator iter;
15091 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
15092 0 : traversalSuccessorContainer.push_back(*iter);
15093 : }
15094 0 : return traversalSuccessorContainer;
15095 : }
15096 : vector<string>
15097 0 : SgOmpUnrollStatement::get_traversalSuccessorNamesContainer() {
15098 0 : vector<string> traversalSuccessorContainer;
15099 0 : int i = 1;
15100 0 : traversalSuccessorContainer.push_back("p_body");
15101 0 : {
15102 0 : SgOmpClausePtrList::iterator iter;
15103 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
15104 0 : char buf[20];
15105 0 : sprintf(buf,"*[%d]",i);
15106 0 : traversalSuccessorContainer.push_back(buf);
15107 : }
15108 : }
15109 0 : return traversalSuccessorContainer;
15110 : }
15111 : size_t
15112 0 : SgOmpUnrollStatement::get_numberOfTraversalSuccessors() {
15113 0 : return p_clauses.size() + 1;
15114 : }
15115 : SgNode *
15116 0 : SgOmpUnrollStatement::get_traversalSuccessorByIndex(size_t idx) {
15117 0 : if (idx == 0) return p_body;
15118 0 : else return p_clauses[idx-1];
15119 : }
15120 : size_t
15121 0 : SgOmpUnrollStatement::get_childIndex(SgNode *child) {
15122 0 : if (child == p_body) return 0;
15123 : else {
15124 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
15125 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
15126 : else return (size_t) -1;
15127 : }
15128 : }
15129 : vector<SgNode*>
15130 0 : SgOmpTileStatement::get_traversalSuccessorContainer() {
15131 0 : vector<SgNode*> traversalSuccessorContainer;
15132 0 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
15133 0 : traversalSuccessorContainer.push_back(p_body);
15134 0 : {
15135 0 : SgOmpClausePtrList::iterator iter;
15136 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
15137 0 : traversalSuccessorContainer.push_back(*iter);
15138 : }
15139 0 : return traversalSuccessorContainer;
15140 : }
15141 : vector<string>
15142 0 : SgOmpTileStatement::get_traversalSuccessorNamesContainer() {
15143 0 : vector<string> traversalSuccessorContainer;
15144 0 : int i = 1;
15145 0 : traversalSuccessorContainer.push_back("p_body");
15146 0 : {
15147 0 : SgOmpClausePtrList::iterator iter;
15148 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
15149 0 : char buf[20];
15150 0 : sprintf(buf,"*[%d]",i);
15151 0 : traversalSuccessorContainer.push_back(buf);
15152 : }
15153 : }
15154 0 : return traversalSuccessorContainer;
15155 : }
15156 : size_t
15157 0 : SgOmpTileStatement::get_numberOfTraversalSuccessors() {
15158 0 : return p_clauses.size() + 1;
15159 : }
15160 : SgNode *
15161 0 : SgOmpTileStatement::get_traversalSuccessorByIndex(size_t idx) {
15162 0 : if (idx == 0) return p_body;
15163 0 : else return p_clauses[idx-1];
15164 : }
15165 : size_t
15166 0 : SgOmpTileStatement::get_childIndex(SgNode *child) {
15167 0 : if (child == p_body) return 0;
15168 : else {
15169 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
15170 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
15171 : else return (size_t) -1;
15172 : }
15173 : }
15174 : vector<SgNode*>
15175 0 : SgUpirLoopStatement::get_traversalSuccessorContainer() {
15176 0 : vector<SgNode*> traversalSuccessorContainer;
15177 0 : traversalSuccessorContainer.reserve(p_clauses.size() + 1);
15178 0 : traversalSuccessorContainer.push_back(p_body);
15179 0 : {
15180 0 : SgOmpClausePtrList::iterator iter;
15181 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); iter++)
15182 0 : traversalSuccessorContainer.push_back(*iter);
15183 : }
15184 0 : return traversalSuccessorContainer;
15185 : }
15186 : vector<string>
15187 0 : SgUpirLoopStatement::get_traversalSuccessorNamesContainer() {
15188 0 : vector<string> traversalSuccessorContainer;
15189 0 : int i = 1;
15190 0 : traversalSuccessorContainer.push_back("p_body");
15191 0 : {
15192 0 : SgOmpClausePtrList::iterator iter;
15193 0 : for (iter = p_clauses.begin(); iter != p_clauses.end(); (iter++,i++)) {
15194 0 : char buf[20];
15195 0 : sprintf(buf,"*[%d]",i);
15196 0 : traversalSuccessorContainer.push_back(buf);
15197 : }
15198 : }
15199 0 : return traversalSuccessorContainer;
15200 : }
15201 : size_t
15202 0 : SgUpirLoopStatement::get_numberOfTraversalSuccessors() {
15203 0 : return p_clauses.size() + 1;
15204 : }
15205 : SgNode *
15206 0 : SgUpirLoopStatement::get_traversalSuccessorByIndex(size_t idx) {
15207 0 : if (idx == 0) return p_body;
15208 0 : else return p_clauses[idx-1];
15209 : }
15210 : size_t
15211 0 : SgUpirLoopStatement::get_childIndex(SgNode *child) {
15212 0 : if (child == p_body) return 0;
15213 : else {
15214 0 : SgOmpClausePtrList::iterator itr = find(p_clauses.begin(), p_clauses.end(), child);
15215 0 : if (itr != p_clauses.end()) return (itr - p_clauses.begin()) + 1;
15216 : else return (size_t) -1;
15217 : }
15218 : }
15219 : vector<SgNode*>
15220 0 : SgUpirFieldStatement::get_traversalSuccessorContainer() {
15221 0 : vector<SgNode*> traversalSuccessorContainer;
15222 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
15223 0 : << "static: SgUpirFieldStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
15224 0 : cerr << "Aborting ..." << endl;
15225 0 : ROSE_ASSERT(false);
15226 : return traversalSuccessorContainer;
15227 : }
15228 :
15229 : vector<string>
15230 0 : SgUpirFieldStatement::get_traversalSuccessorNamesContainer() {
15231 0 : vector<string> traversalSuccessorContainer;
15232 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
15233 0 : << "static: SgUpirFieldStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
15234 0 : cerr << "Aborting ..." << endl;
15235 0 : ROSE_ASSERT(false);
15236 : return traversalSuccessorContainer;
15237 : }
15238 :
15239 : size_t
15240 0 : SgUpirFieldStatement::get_numberOfTraversalSuccessors() {
15241 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
15242 0 : << "static: SgUpirFieldStatement" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
15243 0 : cerr << "Aborting ..." << endl;
15244 0 : ROSE_ASSERT(false);
15245 : return 42;
15246 : }
15247 :
15248 : SgNode*
15249 0 : SgUpirFieldStatement::get_traversalSuccessorByIndex(size_t) {
15250 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
15251 0 : << "static: SgUpirFieldStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
15252 0 : cerr << "Aborting ..." << endl;
15253 0 : ROSE_ASSERT(false);
15254 : return NULL;
15255 : }
15256 :
15257 : size_t
15258 0 : SgUpirFieldStatement::get_childIndex(SgNode *) {
15259 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
15260 0 : << "static: SgUpirFieldStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
15261 0 : cerr << "Aborting ..." << endl;
15262 0 : ROSE_ASSERT(false);
15263 : return 42;
15264 : }
15265 :
15266 : vector<SgNode*>
15267 2 : SgOmpCancelStatement::get_traversalSuccessorContainer() {
15268 2 : vector<SgNode*> traversalSuccessorContainer;
15269 2 : return traversalSuccessorContainer;
15270 : }
15271 : vector<string>
15272 2 : SgOmpCancelStatement::get_traversalSuccessorNamesContainer() {
15273 2 : vector<string> traversalSuccessorContainer;
15274 2 : return traversalSuccessorContainer;
15275 : }
15276 : size_t
15277 16 : SgOmpCancelStatement::get_numberOfTraversalSuccessors() {
15278 16 : return 0;
15279 : }
15280 : SgNode *
15281 0 : SgOmpCancelStatement::get_traversalSuccessorByIndex(size_t idx) {
15282 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpCancelStatement" << " that has no successors!" << endl;
15283 0 : ROSE_ASSERT(false);
15284 : return NULL;
15285 : }
15286 : size_t
15287 0 : SgOmpCancelStatement::get_childIndex(SgNode *child) {
15288 0 : cout << "error: get_childIndex called on node of type " << "SgOmpCancelStatement" << " that has no successors!" << endl;
15289 0 : ROSE_ASSERT(false);
15290 : return 0;
15291 : }
15292 : vector<SgNode*>
15293 2 : SgOmpCancellationPointStatement::get_traversalSuccessorContainer() {
15294 2 : vector<SgNode*> traversalSuccessorContainer;
15295 2 : return traversalSuccessorContainer;
15296 : }
15297 : vector<string>
15298 2 : SgOmpCancellationPointStatement::get_traversalSuccessorNamesContainer() {
15299 2 : vector<string> traversalSuccessorContainer;
15300 2 : return traversalSuccessorContainer;
15301 : }
15302 : size_t
15303 16 : SgOmpCancellationPointStatement::get_numberOfTraversalSuccessors() {
15304 16 : return 0;
15305 : }
15306 : SgNode *
15307 0 : SgOmpCancellationPointStatement::get_traversalSuccessorByIndex(size_t idx) {
15308 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpCancellationPointStatement" << " that has no successors!" << endl;
15309 0 : ROSE_ASSERT(false);
15310 : return NULL;
15311 : }
15312 : size_t
15313 0 : SgOmpCancellationPointStatement::get_childIndex(SgNode *child) {
15314 0 : cout << "error: get_childIndex called on node of type " << "SgOmpCancellationPointStatement" << " that has no successors!" << endl;
15315 0 : ROSE_ASSERT(false);
15316 : return 0;
15317 : }
15318 : vector<SgNode*>
15319 10 : SgOmpTargetUpdateStatement::get_traversalSuccessorContainer() {
15320 10 : vector<SgNode*> traversalSuccessorContainer;
15321 10 : return traversalSuccessorContainer;
15322 : }
15323 : vector<string>
15324 10 : SgOmpTargetUpdateStatement::get_traversalSuccessorNamesContainer() {
15325 10 : vector<string> traversalSuccessorContainer;
15326 10 : return traversalSuccessorContainer;
15327 : }
15328 : size_t
15329 80 : SgOmpTargetUpdateStatement::get_numberOfTraversalSuccessors() {
15330 80 : return 0;
15331 : }
15332 : SgNode *
15333 0 : SgOmpTargetUpdateStatement::get_traversalSuccessorByIndex(size_t idx) {
15334 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpTargetUpdateStatement" << " that has no successors!" << endl;
15335 0 : ROSE_ASSERT(false);
15336 : return NULL;
15337 : }
15338 : size_t
15339 0 : SgOmpTargetUpdateStatement::get_childIndex(SgNode *child) {
15340 0 : cout << "error: get_childIndex called on node of type " << "SgOmpTargetUpdateStatement" << " that has no successors!" << endl;
15341 0 : ROSE_ASSERT(false);
15342 : return 0;
15343 : }
15344 : vector<SgNode*>
15345 18 : SgOmpFlushStatement::get_traversalSuccessorContainer() {
15346 18 : vector<SgNode*> traversalSuccessorContainer;
15347 18 : traversalSuccessorContainer.reserve(p_variables.size() + 0);
15348 18 : {
15349 18 : SgVarRefExpPtrList::iterator iter;
15350 44 : for (iter = p_variables.begin(); iter != p_variables.end(); iter++)
15351 26 : traversalSuccessorContainer.push_back(*iter);
15352 : }
15353 18 : return traversalSuccessorContainer;
15354 : }
15355 : vector<string>
15356 25 : SgOmpFlushStatement::get_traversalSuccessorNamesContainer() {
15357 25 : vector<string> traversalSuccessorContainer;
15358 25 : int i = 0;
15359 25 : {
15360 25 : SgVarRefExpPtrList::iterator iter;
15361 64 : for (iter = p_variables.begin(); iter != p_variables.end(); (iter++,i++)) {
15362 39 : char buf[20];
15363 39 : sprintf(buf,"*[%d]",i);
15364 78 : traversalSuccessorContainer.push_back(buf);
15365 : }
15366 : }
15367 25 : return traversalSuccessorContainer;
15368 : }
15369 : size_t
15370 142 : SgOmpFlushStatement::get_numberOfTraversalSuccessors() {
15371 142 : return p_variables.size() + 0;
15372 : }
15373 : SgNode *
15374 202 : SgOmpFlushStatement::get_traversalSuccessorByIndex(size_t idx) {
15375 202 : ROSE_ASSERT(idx < p_variables.size());
15376 202 : return p_variables[idx];
15377 : }
15378 : size_t
15379 0 : SgOmpFlushStatement::get_childIndex(SgNode *child) {
15380 0 : SgVarRefExpPtrList::iterator itr = find(p_variables.begin(), p_variables.end(), child);
15381 0 : if (itr != p_variables.end()) return itr - p_variables.begin();
15382 : else return (size_t) -1;
15383 : }
15384 : vector<SgNode*>
15385 2 : SgOmpAllocateStatement::get_traversalSuccessorContainer() {
15386 2 : vector<SgNode*> traversalSuccessorContainer;
15387 2 : traversalSuccessorContainer.reserve(p_variables.size() + 0);
15388 2 : {
15389 2 : SgVarRefExpPtrList::iterator iter;
15390 4 : for (iter = p_variables.begin(); iter != p_variables.end(); iter++)
15391 2 : traversalSuccessorContainer.push_back(*iter);
15392 : }
15393 2 : return traversalSuccessorContainer;
15394 : }
15395 : vector<string>
15396 3 : SgOmpAllocateStatement::get_traversalSuccessorNamesContainer() {
15397 3 : vector<string> traversalSuccessorContainer;
15398 3 : int i = 0;
15399 3 : {
15400 3 : SgVarRefExpPtrList::iterator iter;
15401 6 : for (iter = p_variables.begin(); iter != p_variables.end(); (iter++,i++)) {
15402 3 : char buf[20];
15403 3 : sprintf(buf,"*[%d]",i);
15404 6 : traversalSuccessorContainer.push_back(buf);
15405 : }
15406 : }
15407 3 : return traversalSuccessorContainer;
15408 : }
15409 : size_t
15410 16 : SgOmpAllocateStatement::get_numberOfTraversalSuccessors() {
15411 16 : return p_variables.size() + 0;
15412 : }
15413 : SgNode *
15414 16 : SgOmpAllocateStatement::get_traversalSuccessorByIndex(size_t idx) {
15415 16 : ROSE_ASSERT(idx < p_variables.size());
15416 16 : return p_variables[idx];
15417 : }
15418 : size_t
15419 0 : SgOmpAllocateStatement::get_childIndex(SgNode *child) {
15420 0 : SgVarRefExpPtrList::iterator itr = find(p_variables.begin(), p_variables.end(), child);
15421 0 : if (itr != p_variables.end()) return itr - p_variables.begin();
15422 : else return (size_t) -1;
15423 : }
15424 : vector<SgNode*>
15425 0 : SgOmpOrderedDependStatement::get_traversalSuccessorContainer() {
15426 0 : vector<SgNode*> traversalSuccessorContainer;
15427 0 : return traversalSuccessorContainer;
15428 : }
15429 : vector<string>
15430 0 : SgOmpOrderedDependStatement::get_traversalSuccessorNamesContainer() {
15431 0 : vector<string> traversalSuccessorContainer;
15432 0 : return traversalSuccessorContainer;
15433 : }
15434 : size_t
15435 0 : SgOmpOrderedDependStatement::get_numberOfTraversalSuccessors() {
15436 0 : return 0;
15437 : }
15438 : SgNode *
15439 0 : SgOmpOrderedDependStatement::get_traversalSuccessorByIndex(size_t idx) {
15440 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpOrderedDependStatement" << " that has no successors!" << endl;
15441 0 : ROSE_ASSERT(false);
15442 : return NULL;
15443 : }
15444 : size_t
15445 0 : SgOmpOrderedDependStatement::get_childIndex(SgNode *child) {
15446 0 : cout << "error: get_childIndex called on node of type " << "SgOmpOrderedDependStatement" << " that has no successors!" << endl;
15447 0 : ROSE_ASSERT(false);
15448 : return 0;
15449 : }
15450 : vector<SgNode*>
15451 0 : SgUpirSyncStatement::get_traversalSuccessorContainer() {
15452 0 : vector<SgNode*> traversalSuccessorContainer;
15453 0 : return traversalSuccessorContainer;
15454 : }
15455 : vector<string>
15456 0 : SgUpirSyncStatement::get_traversalSuccessorNamesContainer() {
15457 0 : vector<string> traversalSuccessorContainer;
15458 0 : return traversalSuccessorContainer;
15459 : }
15460 : size_t
15461 0 : SgUpirSyncStatement::get_numberOfTraversalSuccessors() {
15462 0 : return 0;
15463 : }
15464 : SgNode *
15465 0 : SgUpirSyncStatement::get_traversalSuccessorByIndex(size_t idx) {
15466 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUpirSyncStatement" << " that has no successors!" << endl;
15467 0 : ROSE_ASSERT(false);
15468 : return NULL;
15469 : }
15470 : size_t
15471 0 : SgUpirSyncStatement::get_childIndex(SgNode *child) {
15472 0 : cout << "error: get_childIndex called on node of type " << "SgUpirSyncStatement" << " that has no successors!" << endl;
15473 0 : ROSE_ASSERT(false);
15474 : return 0;
15475 : }
15476 : vector<SgNode*>
15477 398 : SgUpirLoopParallelStatement::get_traversalSuccessorContainer() {
15478 398 : vector<SgNode*> traversalSuccessorContainer;
15479 398 : return traversalSuccessorContainer;
15480 : }
15481 : vector<string>
15482 398 : SgUpirLoopParallelStatement::get_traversalSuccessorNamesContainer() {
15483 398 : vector<string> traversalSuccessorContainer;
15484 398 : return traversalSuccessorContainer;
15485 : }
15486 : size_t
15487 3184 : SgUpirLoopParallelStatement::get_numberOfTraversalSuccessors() {
15488 3184 : return 0;
15489 : }
15490 : SgNode *
15491 0 : SgUpirLoopParallelStatement::get_traversalSuccessorByIndex(size_t idx) {
15492 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUpirLoopParallelStatement" << " that has no successors!" << endl;
15493 0 : ROSE_ASSERT(false);
15494 : return NULL;
15495 : }
15496 : size_t
15497 0 : SgUpirLoopParallelStatement::get_childIndex(SgNode *child) {
15498 0 : cout << "error: get_childIndex called on node of type " << "SgUpirLoopParallelStatement" << " that has no successors!" << endl;
15499 0 : ROSE_ASSERT(false);
15500 : return 0;
15501 : }
15502 : vector<SgNode*>
15503 0 : SgUpirWorksharingStatement::get_traversalSuccessorContainer() {
15504 0 : vector<SgNode*> traversalSuccessorContainer;
15505 0 : return traversalSuccessorContainer;
15506 : }
15507 : vector<string>
15508 0 : SgUpirWorksharingStatement::get_traversalSuccessorNamesContainer() {
15509 0 : vector<string> traversalSuccessorContainer;
15510 0 : return traversalSuccessorContainer;
15511 : }
15512 : size_t
15513 0 : SgUpirWorksharingStatement::get_numberOfTraversalSuccessors() {
15514 0 : return 0;
15515 : }
15516 : SgNode *
15517 0 : SgUpirWorksharingStatement::get_traversalSuccessorByIndex(size_t idx) {
15518 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUpirWorksharingStatement" << " that has no successors!" << endl;
15519 0 : ROSE_ASSERT(false);
15520 : return NULL;
15521 : }
15522 : size_t
15523 0 : SgUpirWorksharingStatement::get_childIndex(SgNode *child) {
15524 0 : cout << "error: get_childIndex called on node of type " << "SgUpirWorksharingStatement" << " that has no successors!" << endl;
15525 0 : ROSE_ASSERT(false);
15526 : return 0;
15527 : }
15528 : vector<SgNode*>
15529 0 : SgUpirSimdStatement::get_traversalSuccessorContainer() {
15530 0 : vector<SgNode*> traversalSuccessorContainer;
15531 0 : return traversalSuccessorContainer;
15532 : }
15533 : vector<string>
15534 0 : SgUpirSimdStatement::get_traversalSuccessorNamesContainer() {
15535 0 : vector<string> traversalSuccessorContainer;
15536 0 : return traversalSuccessorContainer;
15537 : }
15538 : size_t
15539 0 : SgUpirSimdStatement::get_numberOfTraversalSuccessors() {
15540 0 : return 0;
15541 : }
15542 : SgNode *
15543 0 : SgUpirSimdStatement::get_traversalSuccessorByIndex(size_t idx) {
15544 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUpirSimdStatement" << " that has no successors!" << endl;
15545 0 : ROSE_ASSERT(false);
15546 : return NULL;
15547 : }
15548 : size_t
15549 0 : SgUpirSimdStatement::get_childIndex(SgNode *child) {
15550 0 : cout << "error: get_childIndex called on node of type " << "SgUpirSimdStatement" << " that has no successors!" << endl;
15551 0 : ROSE_ASSERT(false);
15552 : return 0;
15553 : }
15554 : vector<SgNode*>
15555 0 : SgOmpDeclareMapperStatement::get_traversalSuccessorContainer() {
15556 0 : vector<SgNode*> traversalSuccessorContainer;
15557 0 : return traversalSuccessorContainer;
15558 : }
15559 : vector<string>
15560 0 : SgOmpDeclareMapperStatement::get_traversalSuccessorNamesContainer() {
15561 0 : vector<string> traversalSuccessorContainer;
15562 0 : return traversalSuccessorContainer;
15563 : }
15564 : size_t
15565 0 : SgOmpDeclareMapperStatement::get_numberOfTraversalSuccessors() {
15566 0 : return 0;
15567 : }
15568 : SgNode *
15569 0 : SgOmpDeclareMapperStatement::get_traversalSuccessorByIndex(size_t idx) {
15570 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgOmpDeclareMapperStatement" << " that has no successors!" << endl;
15571 0 : ROSE_ASSERT(false);
15572 : return NULL;
15573 : }
15574 : size_t
15575 0 : SgOmpDeclareMapperStatement::get_childIndex(SgNode *child) {
15576 0 : cout << "error: get_childIndex called on node of type " << "SgOmpDeclareMapperStatement" << " that has no successors!" << endl;
15577 0 : ROSE_ASSERT(false);
15578 : return 0;
15579 : }
15580 : vector<SgNode*>
15581 0 : SgSequenceStatement::get_traversalSuccessorContainer() {
15582 0 : vector<SgNode*> traversalSuccessorContainer;
15583 0 : return traversalSuccessorContainer;
15584 : }
15585 : vector<string>
15586 0 : SgSequenceStatement::get_traversalSuccessorNamesContainer() {
15587 0 : vector<string> traversalSuccessorContainer;
15588 0 : return traversalSuccessorContainer;
15589 : }
15590 : size_t
15591 0 : SgSequenceStatement::get_numberOfTraversalSuccessors() {
15592 0 : return 0;
15593 : }
15594 : SgNode *
15595 0 : SgSequenceStatement::get_traversalSuccessorByIndex(size_t idx) {
15596 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgSequenceStatement" << " that has no successors!" << endl;
15597 0 : ROSE_ASSERT(false);
15598 : return NULL;
15599 : }
15600 : size_t
15601 0 : SgSequenceStatement::get_childIndex(SgNode *child) {
15602 0 : cout << "error: get_childIndex called on node of type " << "SgSequenceStatement" << " that has no successors!" << endl;
15603 0 : ROSE_ASSERT(false);
15604 : return 0;
15605 : }
15606 : vector<SgNode*>
15607 0 : SgWithStatement::get_traversalSuccessorContainer() {
15608 0 : vector<SgNode*> traversalSuccessorContainer;
15609 0 : traversalSuccessorContainer.reserve(2);
15610 0 : traversalSuccessorContainer.push_back(p_expression);
15611 0 : traversalSuccessorContainer.push_back(p_body);
15612 0 : return traversalSuccessorContainer;
15613 : }
15614 : vector<string>
15615 0 : SgWithStatement::get_traversalSuccessorNamesContainer() {
15616 0 : vector<string> traversalSuccessorContainer;
15617 0 : traversalSuccessorContainer.push_back("p_expression");
15618 0 : traversalSuccessorContainer.push_back("p_body");
15619 0 : return traversalSuccessorContainer;
15620 : }
15621 : size_t
15622 0 : SgWithStatement::get_numberOfTraversalSuccessors() {
15623 0 : return 2;
15624 : }
15625 : SgNode *
15626 0 : SgWithStatement::get_traversalSuccessorByIndex(size_t idx) {
15627 0 : switch (idx) {
15628 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
15629 0 : case 1: ROSE_ASSERT(p_body == NULL || p_body != NULL); return p_body;
15630 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
15631 0 : ROSE_ASSERT(false);
15632 : return NULL;
15633 : }
15634 : }
15635 : size_t
15636 0 : SgWithStatement::get_childIndex(SgNode *child) {
15637 0 : if (child == p_expression) return 0;
15638 0 : else if (child == p_body) return 1;
15639 0 : else return (size_t) -1;
15640 : }
15641 : vector<SgNode*>
15642 0 : SgPassStatement::get_traversalSuccessorContainer() {
15643 0 : vector<SgNode*> traversalSuccessorContainer;
15644 0 : return traversalSuccessorContainer;
15645 : }
15646 : vector<string>
15647 0 : SgPassStatement::get_traversalSuccessorNamesContainer() {
15648 0 : vector<string> traversalSuccessorContainer;
15649 0 : return traversalSuccessorContainer;
15650 : }
15651 : size_t
15652 0 : SgPassStatement::get_numberOfTraversalSuccessors() {
15653 0 : return 0;
15654 : }
15655 : SgNode *
15656 0 : SgPassStatement::get_traversalSuccessorByIndex(size_t idx) {
15657 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgPassStatement" << " that has no successors!" << endl;
15658 0 : ROSE_ASSERT(false);
15659 : return NULL;
15660 : }
15661 : size_t
15662 0 : SgPassStatement::get_childIndex(SgNode *child) {
15663 0 : cout << "error: get_childIndex called on node of type " << "SgPassStatement" << " that has no successors!" << endl;
15664 0 : ROSE_ASSERT(false);
15665 : return 0;
15666 : }
15667 : vector<SgNode*>
15668 0 : SgAssertStmt::get_traversalSuccessorContainer() {
15669 0 : vector<SgNode*> traversalSuccessorContainer;
15670 0 : traversalSuccessorContainer.reserve(2);
15671 0 : traversalSuccessorContainer.push_back(p_test);
15672 0 : traversalSuccessorContainer.push_back(p_exception_argument);
15673 0 : return traversalSuccessorContainer;
15674 : }
15675 : vector<string>
15676 0 : SgAssertStmt::get_traversalSuccessorNamesContainer() {
15677 0 : vector<string> traversalSuccessorContainer;
15678 0 : traversalSuccessorContainer.push_back("p_test");
15679 0 : traversalSuccessorContainer.push_back("p_exception_argument");
15680 0 : return traversalSuccessorContainer;
15681 : }
15682 : size_t
15683 0 : SgAssertStmt::get_numberOfTraversalSuccessors() {
15684 0 : return 2;
15685 : }
15686 : SgNode *
15687 0 : SgAssertStmt::get_traversalSuccessorByIndex(size_t idx) {
15688 0 : switch (idx) {
15689 0 : case 0: ROSE_ASSERT(p_test == NULL || p_test != NULL); return p_test;
15690 0 : case 1: ROSE_ASSERT(p_exception_argument == NULL || p_exception_argument != NULL); return p_exception_argument;
15691 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
15692 0 : ROSE_ASSERT(false);
15693 : return NULL;
15694 : }
15695 : }
15696 : size_t
15697 0 : SgAssertStmt::get_childIndex(SgNode *child) {
15698 0 : if (child == p_test) return 0;
15699 0 : else if (child == p_exception_argument) return 1;
15700 0 : else return (size_t) -1;
15701 : }
15702 : vector<SgNode*>
15703 0 : SgExecStatement::get_traversalSuccessorContainer() {
15704 0 : vector<SgNode*> traversalSuccessorContainer;
15705 0 : traversalSuccessorContainer.reserve(3);
15706 0 : traversalSuccessorContainer.push_back(p_executable);
15707 0 : traversalSuccessorContainer.push_back(p_globals);
15708 0 : traversalSuccessorContainer.push_back(p_locals);
15709 0 : return traversalSuccessorContainer;
15710 : }
15711 : vector<string>
15712 0 : SgExecStatement::get_traversalSuccessorNamesContainer() {
15713 0 : vector<string> traversalSuccessorContainer;
15714 0 : traversalSuccessorContainer.push_back("p_executable");
15715 0 : traversalSuccessorContainer.push_back("p_globals");
15716 0 : traversalSuccessorContainer.push_back("p_locals");
15717 0 : return traversalSuccessorContainer;
15718 : }
15719 : size_t
15720 0 : SgExecStatement::get_numberOfTraversalSuccessors() {
15721 0 : return 3;
15722 : }
15723 : SgNode *
15724 0 : SgExecStatement::get_traversalSuccessorByIndex(size_t idx) {
15725 0 : switch (idx) {
15726 0 : case 0: ROSE_ASSERT(p_executable == NULL || p_executable != NULL); return p_executable;
15727 0 : case 1: ROSE_ASSERT(p_globals == NULL || p_globals != NULL); return p_globals;
15728 0 : case 2: ROSE_ASSERT(p_locals == NULL || p_locals != NULL); return p_locals;
15729 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
15730 0 : ROSE_ASSERT(false);
15731 : return NULL;
15732 : }
15733 : }
15734 : size_t
15735 0 : SgExecStatement::get_childIndex(SgNode *child) {
15736 0 : if (child == p_executable) return 0;
15737 0 : else if (child == p_globals) return 1;
15738 0 : else if (child == p_locals) return 2;
15739 0 : else return (size_t) -1;
15740 : }
15741 : vector<SgNode*>
15742 0 : SgImageControlStatement::get_traversalSuccessorContainer() {
15743 0 : vector<SgNode*> traversalSuccessorContainer;
15744 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
15745 0 : << "static: SgImageControlStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
15746 0 : cerr << "Aborting ..." << endl;
15747 0 : ROSE_ASSERT(false);
15748 : return traversalSuccessorContainer;
15749 : }
15750 :
15751 : vector<string>
15752 0 : SgImageControlStatement::get_traversalSuccessorNamesContainer() {
15753 0 : vector<string> traversalSuccessorContainer;
15754 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
15755 0 : << "static: SgImageControlStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
15756 0 : cerr << "Aborting ..." << endl;
15757 0 : ROSE_ASSERT(false);
15758 : return traversalSuccessorContainer;
15759 : }
15760 :
15761 : size_t
15762 0 : SgImageControlStatement::get_numberOfTraversalSuccessors() {
15763 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
15764 0 : << "static: SgImageControlStatement" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
15765 0 : cerr << "Aborting ..." << endl;
15766 0 : ROSE_ASSERT(false);
15767 : return 42;
15768 : }
15769 :
15770 : SgNode*
15771 0 : SgImageControlStatement::get_traversalSuccessorByIndex(size_t) {
15772 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
15773 0 : << "static: SgImageControlStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
15774 0 : cerr << "Aborting ..." << endl;
15775 0 : ROSE_ASSERT(false);
15776 : return NULL;
15777 : }
15778 :
15779 : size_t
15780 0 : SgImageControlStatement::get_childIndex(SgNode *) {
15781 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
15782 0 : << "static: SgImageControlStatement" << endl << "dynamic: " << this->sage_class_name() << endl;
15783 0 : cerr << "Aborting ..." << endl;
15784 0 : ROSE_ASSERT(false);
15785 : return 42;
15786 : }
15787 :
15788 : vector<SgNode*>
15789 0 : SgSyncAllStatement::get_traversalSuccessorContainer() {
15790 0 : vector<SgNode*> traversalSuccessorContainer;
15791 0 : traversalSuccessorContainer.reserve(3);
15792 0 : traversalSuccessorContainer.push_back(p_stat);
15793 0 : traversalSuccessorContainer.push_back(p_err_msg);
15794 0 : traversalSuccessorContainer.push_back(p_acquired_lock);
15795 0 : return traversalSuccessorContainer;
15796 : }
15797 : vector<string>
15798 0 : SgSyncAllStatement::get_traversalSuccessorNamesContainer() {
15799 0 : vector<string> traversalSuccessorContainer;
15800 0 : traversalSuccessorContainer.push_back("p_stat");
15801 0 : traversalSuccessorContainer.push_back("p_err_msg");
15802 0 : traversalSuccessorContainer.push_back("p_acquired_lock");
15803 0 : return traversalSuccessorContainer;
15804 : }
15805 : size_t
15806 0 : SgSyncAllStatement::get_numberOfTraversalSuccessors() {
15807 0 : return 3;
15808 : }
15809 : SgNode *
15810 0 : SgSyncAllStatement::get_traversalSuccessorByIndex(size_t idx) {
15811 0 : switch (idx) {
15812 0 : case 0: ROSE_ASSERT(p_stat == NULL || p_stat != NULL); return p_stat;
15813 0 : case 1: ROSE_ASSERT(p_err_msg == NULL || p_err_msg != NULL); return p_err_msg;
15814 0 : case 2: ROSE_ASSERT(p_acquired_lock == NULL || p_acquired_lock != NULL); return p_acquired_lock;
15815 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
15816 0 : ROSE_ASSERT(false);
15817 : return NULL;
15818 : }
15819 : }
15820 : size_t
15821 0 : SgSyncAllStatement::get_childIndex(SgNode *child) {
15822 0 : if (child == p_stat) return 0;
15823 0 : else if (child == p_err_msg) return 1;
15824 0 : else if (child == p_acquired_lock) return 2;
15825 0 : else return (size_t) -1;
15826 : }
15827 : vector<SgNode*>
15828 0 : SgSyncImagesStatement::get_traversalSuccessorContainer() {
15829 0 : vector<SgNode*> traversalSuccessorContainer;
15830 0 : traversalSuccessorContainer.reserve(4);
15831 0 : traversalSuccessorContainer.push_back(p_stat);
15832 0 : traversalSuccessorContainer.push_back(p_err_msg);
15833 0 : traversalSuccessorContainer.push_back(p_acquired_lock);
15834 0 : traversalSuccessorContainer.push_back(p_image_set);
15835 0 : return traversalSuccessorContainer;
15836 : }
15837 : vector<string>
15838 0 : SgSyncImagesStatement::get_traversalSuccessorNamesContainer() {
15839 0 : vector<string> traversalSuccessorContainer;
15840 0 : traversalSuccessorContainer.push_back("p_stat");
15841 0 : traversalSuccessorContainer.push_back("p_err_msg");
15842 0 : traversalSuccessorContainer.push_back("p_acquired_lock");
15843 0 : traversalSuccessorContainer.push_back("p_image_set");
15844 0 : return traversalSuccessorContainer;
15845 : }
15846 : size_t
15847 0 : SgSyncImagesStatement::get_numberOfTraversalSuccessors() {
15848 0 : return 4;
15849 : }
15850 : SgNode *
15851 0 : SgSyncImagesStatement::get_traversalSuccessorByIndex(size_t idx) {
15852 0 : switch (idx) {
15853 0 : case 0: ROSE_ASSERT(p_stat == NULL || p_stat != NULL); return p_stat;
15854 0 : case 1: ROSE_ASSERT(p_err_msg == NULL || p_err_msg != NULL); return p_err_msg;
15855 0 : case 2: ROSE_ASSERT(p_acquired_lock == NULL || p_acquired_lock != NULL); return p_acquired_lock;
15856 0 : case 3: ROSE_ASSERT(p_image_set == NULL || p_image_set != NULL); return p_image_set;
15857 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
15858 0 : ROSE_ASSERT(false);
15859 : return NULL;
15860 : }
15861 : }
15862 : size_t
15863 0 : SgSyncImagesStatement::get_childIndex(SgNode *child) {
15864 0 : if (child == p_stat) return 0;
15865 0 : else if (child == p_err_msg) return 1;
15866 0 : else if (child == p_acquired_lock) return 2;
15867 0 : else if (child == p_image_set) return 3;
15868 0 : else return (size_t) -1;
15869 : }
15870 : vector<SgNode*>
15871 0 : SgSyncMemoryStatement::get_traversalSuccessorContainer() {
15872 0 : vector<SgNode*> traversalSuccessorContainer;
15873 0 : traversalSuccessorContainer.reserve(3);
15874 0 : traversalSuccessorContainer.push_back(p_stat);
15875 0 : traversalSuccessorContainer.push_back(p_err_msg);
15876 0 : traversalSuccessorContainer.push_back(p_acquired_lock);
15877 0 : return traversalSuccessorContainer;
15878 : }
15879 : vector<string>
15880 0 : SgSyncMemoryStatement::get_traversalSuccessorNamesContainer() {
15881 0 : vector<string> traversalSuccessorContainer;
15882 0 : traversalSuccessorContainer.push_back("p_stat");
15883 0 : traversalSuccessorContainer.push_back("p_err_msg");
15884 0 : traversalSuccessorContainer.push_back("p_acquired_lock");
15885 0 : return traversalSuccessorContainer;
15886 : }
15887 : size_t
15888 0 : SgSyncMemoryStatement::get_numberOfTraversalSuccessors() {
15889 0 : return 3;
15890 : }
15891 : SgNode *
15892 0 : SgSyncMemoryStatement::get_traversalSuccessorByIndex(size_t idx) {
15893 0 : switch (idx) {
15894 0 : case 0: ROSE_ASSERT(p_stat == NULL || p_stat != NULL); return p_stat;
15895 0 : case 1: ROSE_ASSERT(p_err_msg == NULL || p_err_msg != NULL); return p_err_msg;
15896 0 : case 2: ROSE_ASSERT(p_acquired_lock == NULL || p_acquired_lock != NULL); return p_acquired_lock;
15897 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
15898 0 : ROSE_ASSERT(false);
15899 : return NULL;
15900 : }
15901 : }
15902 : size_t
15903 0 : SgSyncMemoryStatement::get_childIndex(SgNode *child) {
15904 0 : if (child == p_stat) return 0;
15905 0 : else if (child == p_err_msg) return 1;
15906 0 : else if (child == p_acquired_lock) return 2;
15907 0 : else return (size_t) -1;
15908 : }
15909 : vector<SgNode*>
15910 0 : SgSyncTeamStatement::get_traversalSuccessorContainer() {
15911 0 : vector<SgNode*> traversalSuccessorContainer;
15912 0 : traversalSuccessorContainer.reserve(4);
15913 0 : traversalSuccessorContainer.push_back(p_stat);
15914 0 : traversalSuccessorContainer.push_back(p_err_msg);
15915 0 : traversalSuccessorContainer.push_back(p_acquired_lock);
15916 0 : traversalSuccessorContainer.push_back(p_team_value);
15917 0 : return traversalSuccessorContainer;
15918 : }
15919 : vector<string>
15920 0 : SgSyncTeamStatement::get_traversalSuccessorNamesContainer() {
15921 0 : vector<string> traversalSuccessorContainer;
15922 0 : traversalSuccessorContainer.push_back("p_stat");
15923 0 : traversalSuccessorContainer.push_back("p_err_msg");
15924 0 : traversalSuccessorContainer.push_back("p_acquired_lock");
15925 0 : traversalSuccessorContainer.push_back("p_team_value");
15926 0 : return traversalSuccessorContainer;
15927 : }
15928 : size_t
15929 0 : SgSyncTeamStatement::get_numberOfTraversalSuccessors() {
15930 0 : return 4;
15931 : }
15932 : SgNode *
15933 0 : SgSyncTeamStatement::get_traversalSuccessorByIndex(size_t idx) {
15934 0 : switch (idx) {
15935 0 : case 0: ROSE_ASSERT(p_stat == NULL || p_stat != NULL); return p_stat;
15936 0 : case 1: ROSE_ASSERT(p_err_msg == NULL || p_err_msg != NULL); return p_err_msg;
15937 0 : case 2: ROSE_ASSERT(p_acquired_lock == NULL || p_acquired_lock != NULL); return p_acquired_lock;
15938 0 : case 3: ROSE_ASSERT(p_team_value == NULL || p_team_value != NULL); return p_team_value;
15939 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
15940 0 : ROSE_ASSERT(false);
15941 : return NULL;
15942 : }
15943 : }
15944 : size_t
15945 0 : SgSyncTeamStatement::get_childIndex(SgNode *child) {
15946 0 : if (child == p_stat) return 0;
15947 0 : else if (child == p_err_msg) return 1;
15948 0 : else if (child == p_acquired_lock) return 2;
15949 0 : else if (child == p_team_value) return 3;
15950 0 : else return (size_t) -1;
15951 : }
15952 : vector<SgNode*>
15953 0 : SgLockStatement::get_traversalSuccessorContainer() {
15954 0 : vector<SgNode*> traversalSuccessorContainer;
15955 0 : traversalSuccessorContainer.reserve(4);
15956 0 : traversalSuccessorContainer.push_back(p_stat);
15957 0 : traversalSuccessorContainer.push_back(p_err_msg);
15958 0 : traversalSuccessorContainer.push_back(p_acquired_lock);
15959 0 : traversalSuccessorContainer.push_back(p_lock_variable);
15960 0 : return traversalSuccessorContainer;
15961 : }
15962 : vector<string>
15963 0 : SgLockStatement::get_traversalSuccessorNamesContainer() {
15964 0 : vector<string> traversalSuccessorContainer;
15965 0 : traversalSuccessorContainer.push_back("p_stat");
15966 0 : traversalSuccessorContainer.push_back("p_err_msg");
15967 0 : traversalSuccessorContainer.push_back("p_acquired_lock");
15968 0 : traversalSuccessorContainer.push_back("p_lock_variable");
15969 0 : return traversalSuccessorContainer;
15970 : }
15971 : size_t
15972 0 : SgLockStatement::get_numberOfTraversalSuccessors() {
15973 0 : return 4;
15974 : }
15975 : SgNode *
15976 0 : SgLockStatement::get_traversalSuccessorByIndex(size_t idx) {
15977 0 : switch (idx) {
15978 0 : case 0: ROSE_ASSERT(p_stat == NULL || p_stat != NULL); return p_stat;
15979 0 : case 1: ROSE_ASSERT(p_err_msg == NULL || p_err_msg != NULL); return p_err_msg;
15980 0 : case 2: ROSE_ASSERT(p_acquired_lock == NULL || p_acquired_lock != NULL); return p_acquired_lock;
15981 0 : case 3: ROSE_ASSERT(p_lock_variable == NULL || p_lock_variable != NULL); return p_lock_variable;
15982 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
15983 0 : ROSE_ASSERT(false);
15984 : return NULL;
15985 : }
15986 : }
15987 : size_t
15988 0 : SgLockStatement::get_childIndex(SgNode *child) {
15989 0 : if (child == p_stat) return 0;
15990 0 : else if (child == p_err_msg) return 1;
15991 0 : else if (child == p_acquired_lock) return 2;
15992 0 : else if (child == p_lock_variable) return 3;
15993 0 : else return (size_t) -1;
15994 : }
15995 : vector<SgNode*>
15996 0 : SgUnlockStatement::get_traversalSuccessorContainer() {
15997 0 : vector<SgNode*> traversalSuccessorContainer;
15998 0 : traversalSuccessorContainer.reserve(4);
15999 0 : traversalSuccessorContainer.push_back(p_stat);
16000 0 : traversalSuccessorContainer.push_back(p_err_msg);
16001 0 : traversalSuccessorContainer.push_back(p_acquired_lock);
16002 0 : traversalSuccessorContainer.push_back(p_lock_variable);
16003 0 : return traversalSuccessorContainer;
16004 : }
16005 : vector<string>
16006 0 : SgUnlockStatement::get_traversalSuccessorNamesContainer() {
16007 0 : vector<string> traversalSuccessorContainer;
16008 0 : traversalSuccessorContainer.push_back("p_stat");
16009 0 : traversalSuccessorContainer.push_back("p_err_msg");
16010 0 : traversalSuccessorContainer.push_back("p_acquired_lock");
16011 0 : traversalSuccessorContainer.push_back("p_lock_variable");
16012 0 : return traversalSuccessorContainer;
16013 : }
16014 : size_t
16015 0 : SgUnlockStatement::get_numberOfTraversalSuccessors() {
16016 0 : return 4;
16017 : }
16018 : SgNode *
16019 0 : SgUnlockStatement::get_traversalSuccessorByIndex(size_t idx) {
16020 0 : switch (idx) {
16021 0 : case 0: ROSE_ASSERT(p_stat == NULL || p_stat != NULL); return p_stat;
16022 0 : case 1: ROSE_ASSERT(p_err_msg == NULL || p_err_msg != NULL); return p_err_msg;
16023 0 : case 2: ROSE_ASSERT(p_acquired_lock == NULL || p_acquired_lock != NULL); return p_acquired_lock;
16024 0 : case 3: ROSE_ASSERT(p_lock_variable == NULL || p_lock_variable != NULL); return p_lock_variable;
16025 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16026 0 : ROSE_ASSERT(false);
16027 : return NULL;
16028 : }
16029 : }
16030 : size_t
16031 0 : SgUnlockStatement::get_childIndex(SgNode *child) {
16032 0 : if (child == p_stat) return 0;
16033 0 : else if (child == p_err_msg) return 1;
16034 0 : else if (child == p_acquired_lock) return 2;
16035 0 : else if (child == p_lock_variable) return 3;
16036 0 : else return (size_t) -1;
16037 : }
16038 : vector<SgNode*>
16039 0 : SgExpression::get_traversalSuccessorContainer() {
16040 0 : vector<SgNode*> traversalSuccessorContainer;
16041 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
16042 0 : << "static: SgExpression" << endl << "dynamic: " << this->sage_class_name() << endl;
16043 0 : cerr << "Aborting ..." << endl;
16044 0 : ROSE_ASSERT(false);
16045 : return traversalSuccessorContainer;
16046 : }
16047 :
16048 : vector<string>
16049 0 : SgExpression::get_traversalSuccessorNamesContainer() {
16050 0 : vector<string> traversalSuccessorContainer;
16051 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
16052 0 : << "static: SgExpression" << endl << "dynamic: " << this->sage_class_name() << endl;
16053 0 : cerr << "Aborting ..." << endl;
16054 0 : ROSE_ASSERT(false);
16055 : return traversalSuccessorContainer;
16056 : }
16057 :
16058 : size_t
16059 0 : SgExpression::get_numberOfTraversalSuccessors() {
16060 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
16061 0 : << "static: SgExpression" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
16062 0 : cerr << "Aborting ..." << endl;
16063 0 : ROSE_ASSERT(false);
16064 : return 42;
16065 : }
16066 :
16067 : SgNode*
16068 0 : SgExpression::get_traversalSuccessorByIndex(size_t) {
16069 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
16070 0 : << "static: SgExpression" << endl << "dynamic: " << this->sage_class_name() << endl;
16071 0 : cerr << "Aborting ..." << endl;
16072 0 : ROSE_ASSERT(false);
16073 : return NULL;
16074 : }
16075 :
16076 : size_t
16077 0 : SgExpression::get_childIndex(SgNode *) {
16078 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
16079 0 : << "static: SgExpression" << endl << "dynamic: " << this->sage_class_name() << endl;
16080 0 : cerr << "Aborting ..." << endl;
16081 0 : ROSE_ASSERT(false);
16082 : return 42;
16083 : }
16084 :
16085 : vector<SgNode*>
16086 0 : SgUnaryOp::get_traversalSuccessorContainer() {
16087 0 : vector<SgNode*> traversalSuccessorContainer;
16088 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
16089 0 : << "static: SgUnaryOp" << endl << "dynamic: " << this->sage_class_name() << endl;
16090 0 : cerr << "Aborting ..." << endl;
16091 0 : ROSE_ASSERT(false);
16092 : return traversalSuccessorContainer;
16093 : }
16094 :
16095 : vector<string>
16096 0 : SgUnaryOp::get_traversalSuccessorNamesContainer() {
16097 0 : vector<string> traversalSuccessorContainer;
16098 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
16099 0 : << "static: SgUnaryOp" << endl << "dynamic: " << this->sage_class_name() << endl;
16100 0 : cerr << "Aborting ..." << endl;
16101 0 : ROSE_ASSERT(false);
16102 : return traversalSuccessorContainer;
16103 : }
16104 :
16105 : size_t
16106 0 : SgUnaryOp::get_numberOfTraversalSuccessors() {
16107 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
16108 0 : << "static: SgUnaryOp" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
16109 0 : cerr << "Aborting ..." << endl;
16110 0 : ROSE_ASSERT(false);
16111 : return 42;
16112 : }
16113 :
16114 : SgNode*
16115 0 : SgUnaryOp::get_traversalSuccessorByIndex(size_t) {
16116 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
16117 0 : << "static: SgUnaryOp" << endl << "dynamic: " << this->sage_class_name() << endl;
16118 0 : cerr << "Aborting ..." << endl;
16119 0 : ROSE_ASSERT(false);
16120 : return NULL;
16121 : }
16122 :
16123 : size_t
16124 0 : SgUnaryOp::get_childIndex(SgNode *) {
16125 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
16126 0 : << "static: SgUnaryOp" << endl << "dynamic: " << this->sage_class_name() << endl;
16127 0 : cerr << "Aborting ..." << endl;
16128 0 : ROSE_ASSERT(false);
16129 : return 42;
16130 : }
16131 :
16132 : vector<SgNode*>
16133 0 : SgExpressionRoot::get_traversalSuccessorContainer() {
16134 0 : vector<SgNode*> traversalSuccessorContainer;
16135 0 : traversalSuccessorContainer.reserve(1);
16136 0 : traversalSuccessorContainer.push_back(p_operand_i);
16137 0 : return traversalSuccessorContainer;
16138 : }
16139 : vector<string>
16140 0 : SgExpressionRoot::get_traversalSuccessorNamesContainer() {
16141 0 : vector<string> traversalSuccessorContainer;
16142 0 : traversalSuccessorContainer.push_back("p_operand_i");
16143 0 : return traversalSuccessorContainer;
16144 : }
16145 : size_t
16146 0 : SgExpressionRoot::get_numberOfTraversalSuccessors() {
16147 0 : return 1;
16148 : }
16149 : SgNode *
16150 0 : SgExpressionRoot::get_traversalSuccessorByIndex(size_t idx) {
16151 0 : switch (idx) {
16152 0 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
16153 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16154 0 : ROSE_ASSERT(false);
16155 : return NULL;
16156 : }
16157 : }
16158 : size_t
16159 0 : SgExpressionRoot::get_childIndex(SgNode *child) {
16160 0 : if (child == p_operand_i) return 0;
16161 0 : else return (size_t) -1;
16162 : }
16163 : vector<SgNode*>
16164 11659 : SgMinusOp::get_traversalSuccessorContainer() {
16165 11659 : vector<SgNode*> traversalSuccessorContainer;
16166 11659 : traversalSuccessorContainer.reserve(1);
16167 11659 : traversalSuccessorContainer.push_back(p_operand_i);
16168 11659 : return traversalSuccessorContainer;
16169 : }
16170 : vector<string>
16171 802 : SgMinusOp::get_traversalSuccessorNamesContainer() {
16172 802 : vector<string> traversalSuccessorContainer;
16173 1604 : traversalSuccessorContainer.push_back("p_operand_i");
16174 802 : return traversalSuccessorContainer;
16175 : }
16176 : size_t
16177 26771 : SgMinusOp::get_numberOfTraversalSuccessors() {
16178 26771 : return 1;
16179 : }
16180 : SgNode *
16181 26756 : SgMinusOp::get_traversalSuccessorByIndex(size_t idx) {
16182 26756 : switch (idx) {
16183 26756 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
16184 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16185 0 : ROSE_ASSERT(false);
16186 : return NULL;
16187 : }
16188 : }
16189 : size_t
16190 0 : SgMinusOp::get_childIndex(SgNode *child) {
16191 0 : if (child == p_operand_i) return 0;
16192 0 : else return (size_t) -1;
16193 : }
16194 : vector<SgNode*>
16195 6 : SgUnaryAddOp::get_traversalSuccessorContainer() {
16196 6 : vector<SgNode*> traversalSuccessorContainer;
16197 6 : traversalSuccessorContainer.reserve(1);
16198 6 : traversalSuccessorContainer.push_back(p_operand_i);
16199 6 : return traversalSuccessorContainer;
16200 : }
16201 : vector<string>
16202 0 : SgUnaryAddOp::get_traversalSuccessorNamesContainer() {
16203 0 : vector<string> traversalSuccessorContainer;
16204 0 : traversalSuccessorContainer.push_back("p_operand_i");
16205 0 : return traversalSuccessorContainer;
16206 : }
16207 : size_t
16208 39 : SgUnaryAddOp::get_numberOfTraversalSuccessors() {
16209 39 : return 1;
16210 : }
16211 : SgNode *
16212 39 : SgUnaryAddOp::get_traversalSuccessorByIndex(size_t idx) {
16213 39 : switch (idx) {
16214 39 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
16215 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16216 0 : ROSE_ASSERT(false);
16217 : return NULL;
16218 : }
16219 : }
16220 : size_t
16221 0 : SgUnaryAddOp::get_childIndex(SgNode *child) {
16222 0 : if (child == p_operand_i) return 0;
16223 0 : else return (size_t) -1;
16224 : }
16225 : vector<SgNode*>
16226 34358 : SgNotOp::get_traversalSuccessorContainer() {
16227 34358 : vector<SgNode*> traversalSuccessorContainer;
16228 34358 : traversalSuccessorContainer.reserve(1);
16229 34358 : traversalSuccessorContainer.push_back(p_operand_i);
16230 34358 : return traversalSuccessorContainer;
16231 : }
16232 : vector<string>
16233 2474 : SgNotOp::get_traversalSuccessorNamesContainer() {
16234 2474 : vector<string> traversalSuccessorContainer;
16235 4948 : traversalSuccessorContainer.push_back("p_operand_i");
16236 2474 : return traversalSuccessorContainer;
16237 : }
16238 : size_t
16239 95611 : SgNotOp::get_numberOfTraversalSuccessors() {
16240 95611 : return 1;
16241 : }
16242 : SgNode *
16243 95569 : SgNotOp::get_traversalSuccessorByIndex(size_t idx) {
16244 95569 : switch (idx) {
16245 95569 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
16246 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16247 0 : ROSE_ASSERT(false);
16248 : return NULL;
16249 : }
16250 : }
16251 : size_t
16252 0 : SgNotOp::get_childIndex(SgNode *child) {
16253 0 : if (child == p_operand_i) return 0;
16254 0 : else return (size_t) -1;
16255 : }
16256 : vector<SgNode*>
16257 127221 : SgPointerDerefExp::get_traversalSuccessorContainer() {
16258 127221 : vector<SgNode*> traversalSuccessorContainer;
16259 127221 : traversalSuccessorContainer.reserve(1);
16260 127221 : traversalSuccessorContainer.push_back(p_operand_i);
16261 127221 : return traversalSuccessorContainer;
16262 : }
16263 : vector<string>
16264 4982 : SgPointerDerefExp::get_traversalSuccessorNamesContainer() {
16265 4982 : vector<string> traversalSuccessorContainer;
16266 9964 : traversalSuccessorContainer.push_back("p_operand_i");
16267 4982 : return traversalSuccessorContainer;
16268 : }
16269 : size_t
16270 259485 : SgPointerDerefExp::get_numberOfTraversalSuccessors() {
16271 259485 : return 1;
16272 : }
16273 : SgNode *
16274 259293 : SgPointerDerefExp::get_traversalSuccessorByIndex(size_t idx) {
16275 259293 : switch (idx) {
16276 259293 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
16277 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16278 0 : ROSE_ASSERT(false);
16279 : return NULL;
16280 : }
16281 : }
16282 : size_t
16283 0 : SgPointerDerefExp::get_childIndex(SgNode *child) {
16284 0 : if (child == p_operand_i) return 0;
16285 0 : else return (size_t) -1;
16286 : }
16287 : vector<SgNode*>
16288 10692 : SgAddressOfOp::get_traversalSuccessorContainer() {
16289 10692 : vector<SgNode*> traversalSuccessorContainer;
16290 10692 : traversalSuccessorContainer.reserve(1);
16291 10692 : traversalSuccessorContainer.push_back(p_operand_i);
16292 10692 : return traversalSuccessorContainer;
16293 : }
16294 : vector<string>
16295 1152 : SgAddressOfOp::get_traversalSuccessorNamesContainer() {
16296 1152 : vector<string> traversalSuccessorContainer;
16297 2304 : traversalSuccessorContainer.push_back("p_operand_i");
16298 1152 : return traversalSuccessorContainer;
16299 : }
16300 : size_t
16301 39701 : SgAddressOfOp::get_numberOfTraversalSuccessors() {
16302 39701 : return 1;
16303 : }
16304 : SgNode *
16305 39688 : SgAddressOfOp::get_traversalSuccessorByIndex(size_t idx) {
16306 39688 : switch (idx) {
16307 39688 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
16308 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16309 0 : ROSE_ASSERT(false);
16310 : return NULL;
16311 : }
16312 : }
16313 : size_t
16314 0 : SgAddressOfOp::get_childIndex(SgNode *child) {
16315 0 : if (child == p_operand_i) return 0;
16316 0 : else return (size_t) -1;
16317 : }
16318 : vector<SgNode*>
16319 26440 : SgMinusMinusOp::get_traversalSuccessorContainer() {
16320 26440 : vector<SgNode*> traversalSuccessorContainer;
16321 26440 : traversalSuccessorContainer.reserve(1);
16322 26440 : traversalSuccessorContainer.push_back(p_operand_i);
16323 26440 : return traversalSuccessorContainer;
16324 : }
16325 : vector<string>
16326 675 : SgMinusMinusOp::get_traversalSuccessorNamesContainer() {
16327 675 : vector<string> traversalSuccessorContainer;
16328 1350 : traversalSuccessorContainer.push_back("p_operand_i");
16329 675 : return traversalSuccessorContainer;
16330 : }
16331 : size_t
16332 44273 : SgMinusMinusOp::get_numberOfTraversalSuccessors() {
16333 44273 : return 1;
16334 : }
16335 : SgNode *
16336 44232 : SgMinusMinusOp::get_traversalSuccessorByIndex(size_t idx) {
16337 44232 : switch (idx) {
16338 44232 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
16339 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16340 0 : ROSE_ASSERT(false);
16341 : return NULL;
16342 : }
16343 : }
16344 : size_t
16345 0 : SgMinusMinusOp::get_childIndex(SgNode *child) {
16346 0 : if (child == p_operand_i) return 0;
16347 0 : else return (size_t) -1;
16348 : }
16349 : vector<SgNode*>
16350 65741 : SgPlusPlusOp::get_traversalSuccessorContainer() {
16351 65741 : vector<SgNode*> traversalSuccessorContainer;
16352 65741 : traversalSuccessorContainer.reserve(1);
16353 65741 : traversalSuccessorContainer.push_back(p_operand_i);
16354 65741 : return traversalSuccessorContainer;
16355 : }
16356 : vector<string>
16357 2479 : SgPlusPlusOp::get_traversalSuccessorNamesContainer() {
16358 2479 : vector<string> traversalSuccessorContainer;
16359 4958 : traversalSuccessorContainer.push_back("p_operand_i");
16360 2479 : return traversalSuccessorContainer;
16361 : }
16362 : size_t
16363 129757 : SgPlusPlusOp::get_numberOfTraversalSuccessors() {
16364 129757 : return 1;
16365 : }
16366 : SgNode *
16367 129660 : SgPlusPlusOp::get_traversalSuccessorByIndex(size_t idx) {
16368 129660 : switch (idx) {
16369 129660 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
16370 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16371 0 : ROSE_ASSERT(false);
16372 : return NULL;
16373 : }
16374 : }
16375 : size_t
16376 0 : SgPlusPlusOp::get_childIndex(SgNode *child) {
16377 0 : if (child == p_operand_i) return 0;
16378 0 : else return (size_t) -1;
16379 : }
16380 : vector<SgNode*>
16381 6749 : SgBitComplementOp::get_traversalSuccessorContainer() {
16382 6749 : vector<SgNode*> traversalSuccessorContainer;
16383 6749 : traversalSuccessorContainer.reserve(1);
16384 6749 : traversalSuccessorContainer.push_back(p_operand_i);
16385 6749 : return traversalSuccessorContainer;
16386 : }
16387 : vector<string>
16388 142 : SgBitComplementOp::get_traversalSuccessorNamesContainer() {
16389 142 : vector<string> traversalSuccessorContainer;
16390 284 : traversalSuccessorContainer.push_back("p_operand_i");
16391 142 : return traversalSuccessorContainer;
16392 : }
16393 : size_t
16394 10137 : SgBitComplementOp::get_numberOfTraversalSuccessors() {
16395 10137 : return 1;
16396 : }
16397 : SgNode *
16398 10126 : SgBitComplementOp::get_traversalSuccessorByIndex(size_t idx) {
16399 10126 : switch (idx) {
16400 10126 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
16401 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16402 0 : ROSE_ASSERT(false);
16403 : return NULL;
16404 : }
16405 : }
16406 : size_t
16407 0 : SgBitComplementOp::get_childIndex(SgNode *child) {
16408 0 : if (child == p_operand_i) return 0;
16409 0 : else return (size_t) -1;
16410 : }
16411 : vector<SgNode*>
16412 546086 : SgCastExp::get_traversalSuccessorContainer() {
16413 546086 : vector<SgNode*> traversalSuccessorContainer;
16414 546086 : traversalSuccessorContainer.reserve(1);
16415 546086 : traversalSuccessorContainer.push_back(p_operand_i);
16416 546086 : return traversalSuccessorContainer;
16417 : }
16418 : vector<string>
16419 27990 : SgCastExp::get_traversalSuccessorNamesContainer() {
16420 27990 : vector<string> traversalSuccessorContainer;
16421 55980 : traversalSuccessorContainer.push_back("p_operand_i");
16422 27990 : return traversalSuccessorContainer;
16423 : }
16424 : size_t
16425 1203450 : SgCastExp::get_numberOfTraversalSuccessors() {
16426 1203450 : return 1;
16427 : }
16428 : SgNode *
16429 1202720 : SgCastExp::get_traversalSuccessorByIndex(size_t idx) {
16430 1202720 : switch (idx) {
16431 1202720 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
16432 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16433 0 : ROSE_ASSERT(false);
16434 : return NULL;
16435 : }
16436 : }
16437 : size_t
16438 0 : SgCastExp::get_childIndex(SgNode *child) {
16439 0 : if (child == p_operand_i) return 0;
16440 0 : else return (size_t) -1;
16441 : }
16442 : vector<SgNode*>
16443 17688 : SgThrowOp::get_traversalSuccessorContainer() {
16444 17688 : vector<SgNode*> traversalSuccessorContainer;
16445 17688 : traversalSuccessorContainer.reserve(1);
16446 17688 : traversalSuccessorContainer.push_back(p_operand_i);
16447 17688 : return traversalSuccessorContainer;
16448 : }
16449 : vector<string>
16450 678 : SgThrowOp::get_traversalSuccessorNamesContainer() {
16451 678 : vector<string> traversalSuccessorContainer;
16452 1356 : traversalSuccessorContainer.push_back("p_operand_i");
16453 678 : return traversalSuccessorContainer;
16454 : }
16455 : size_t
16456 35283 : SgThrowOp::get_numberOfTraversalSuccessors() {
16457 35283 : return 1;
16458 : }
16459 : SgNode *
16460 35256 : SgThrowOp::get_traversalSuccessorByIndex(size_t idx) {
16461 35256 : switch (idx) {
16462 35256 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
16463 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16464 0 : ROSE_ASSERT(false);
16465 : return NULL;
16466 : }
16467 : }
16468 : size_t
16469 0 : SgThrowOp::get_childIndex(SgNode *child) {
16470 0 : if (child == p_operand_i) return 0;
16471 0 : else return (size_t) -1;
16472 : }
16473 : vector<SgNode*>
16474 0 : SgRealPartOp::get_traversalSuccessorContainer() {
16475 0 : vector<SgNode*> traversalSuccessorContainer;
16476 0 : traversalSuccessorContainer.reserve(1);
16477 0 : traversalSuccessorContainer.push_back(p_operand_i);
16478 0 : return traversalSuccessorContainer;
16479 : }
16480 : vector<string>
16481 0 : SgRealPartOp::get_traversalSuccessorNamesContainer() {
16482 0 : vector<string> traversalSuccessorContainer;
16483 0 : traversalSuccessorContainer.push_back("p_operand_i");
16484 0 : return traversalSuccessorContainer;
16485 : }
16486 : size_t
16487 0 : SgRealPartOp::get_numberOfTraversalSuccessors() {
16488 0 : return 1;
16489 : }
16490 : SgNode *
16491 0 : SgRealPartOp::get_traversalSuccessorByIndex(size_t idx) {
16492 0 : switch (idx) {
16493 0 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
16494 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16495 0 : ROSE_ASSERT(false);
16496 : return NULL;
16497 : }
16498 : }
16499 : size_t
16500 0 : SgRealPartOp::get_childIndex(SgNode *child) {
16501 0 : if (child == p_operand_i) return 0;
16502 0 : else return (size_t) -1;
16503 : }
16504 : vector<SgNode*>
16505 0 : SgImagPartOp::get_traversalSuccessorContainer() {
16506 0 : vector<SgNode*> traversalSuccessorContainer;
16507 0 : traversalSuccessorContainer.reserve(1);
16508 0 : traversalSuccessorContainer.push_back(p_operand_i);
16509 0 : return traversalSuccessorContainer;
16510 : }
16511 : vector<string>
16512 0 : SgImagPartOp::get_traversalSuccessorNamesContainer() {
16513 0 : vector<string> traversalSuccessorContainer;
16514 0 : traversalSuccessorContainer.push_back("p_operand_i");
16515 0 : return traversalSuccessorContainer;
16516 : }
16517 : size_t
16518 0 : SgImagPartOp::get_numberOfTraversalSuccessors() {
16519 0 : return 1;
16520 : }
16521 : SgNode *
16522 0 : SgImagPartOp::get_traversalSuccessorByIndex(size_t idx) {
16523 0 : switch (idx) {
16524 0 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
16525 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16526 0 : ROSE_ASSERT(false);
16527 : return NULL;
16528 : }
16529 : }
16530 : size_t
16531 0 : SgImagPartOp::get_childIndex(SgNode *child) {
16532 0 : if (child == p_operand_i) return 0;
16533 0 : else return (size_t) -1;
16534 : }
16535 : vector<SgNode*>
16536 0 : SgConjugateOp::get_traversalSuccessorContainer() {
16537 0 : vector<SgNode*> traversalSuccessorContainer;
16538 0 : traversalSuccessorContainer.reserve(1);
16539 0 : traversalSuccessorContainer.push_back(p_operand_i);
16540 0 : return traversalSuccessorContainer;
16541 : }
16542 : vector<string>
16543 0 : SgConjugateOp::get_traversalSuccessorNamesContainer() {
16544 0 : vector<string> traversalSuccessorContainer;
16545 0 : traversalSuccessorContainer.push_back("p_operand_i");
16546 0 : return traversalSuccessorContainer;
16547 : }
16548 : size_t
16549 0 : SgConjugateOp::get_numberOfTraversalSuccessors() {
16550 0 : return 1;
16551 : }
16552 : SgNode *
16553 0 : SgConjugateOp::get_traversalSuccessorByIndex(size_t idx) {
16554 0 : switch (idx) {
16555 0 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
16556 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16557 0 : ROSE_ASSERT(false);
16558 : return NULL;
16559 : }
16560 : }
16561 : size_t
16562 0 : SgConjugateOp::get_childIndex(SgNode *child) {
16563 0 : if (child == p_operand_i) return 0;
16564 0 : else return (size_t) -1;
16565 : }
16566 : vector<SgNode*>
16567 0 : SgUserDefinedUnaryOp::get_traversalSuccessorContainer() {
16568 0 : vector<SgNode*> traversalSuccessorContainer;
16569 0 : traversalSuccessorContainer.reserve(1);
16570 0 : traversalSuccessorContainer.push_back(p_operand_i);
16571 0 : return traversalSuccessorContainer;
16572 : }
16573 : vector<string>
16574 0 : SgUserDefinedUnaryOp::get_traversalSuccessorNamesContainer() {
16575 0 : vector<string> traversalSuccessorContainer;
16576 0 : traversalSuccessorContainer.push_back("p_operand_i");
16577 0 : return traversalSuccessorContainer;
16578 : }
16579 : size_t
16580 0 : SgUserDefinedUnaryOp::get_numberOfTraversalSuccessors() {
16581 0 : return 1;
16582 : }
16583 : SgNode *
16584 0 : SgUserDefinedUnaryOp::get_traversalSuccessorByIndex(size_t idx) {
16585 0 : switch (idx) {
16586 0 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
16587 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16588 0 : ROSE_ASSERT(false);
16589 : return NULL;
16590 : }
16591 : }
16592 : size_t
16593 0 : SgUserDefinedUnaryOp::get_childIndex(SgNode *child) {
16594 0 : if (child == p_operand_i) return 0;
16595 0 : else return (size_t) -1;
16596 : }
16597 : vector<SgNode*>
16598 0 : SgMatrixTransposeOp::get_traversalSuccessorContainer() {
16599 0 : vector<SgNode*> traversalSuccessorContainer;
16600 0 : traversalSuccessorContainer.reserve(1);
16601 0 : traversalSuccessorContainer.push_back(p_operand_i);
16602 0 : return traversalSuccessorContainer;
16603 : }
16604 : vector<string>
16605 0 : SgMatrixTransposeOp::get_traversalSuccessorNamesContainer() {
16606 0 : vector<string> traversalSuccessorContainer;
16607 0 : traversalSuccessorContainer.push_back("p_operand_i");
16608 0 : return traversalSuccessorContainer;
16609 : }
16610 : size_t
16611 0 : SgMatrixTransposeOp::get_numberOfTraversalSuccessors() {
16612 0 : return 1;
16613 : }
16614 : SgNode *
16615 0 : SgMatrixTransposeOp::get_traversalSuccessorByIndex(size_t idx) {
16616 0 : switch (idx) {
16617 0 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
16618 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16619 0 : ROSE_ASSERT(false);
16620 : return NULL;
16621 : }
16622 : }
16623 : size_t
16624 0 : SgMatrixTransposeOp::get_childIndex(SgNode *child) {
16625 0 : if (child == p_operand_i) return 0;
16626 0 : else return (size_t) -1;
16627 : }
16628 : vector<SgNode*>
16629 0 : SgBinaryOp::get_traversalSuccessorContainer() {
16630 0 : vector<SgNode*> traversalSuccessorContainer;
16631 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
16632 0 : << "static: SgBinaryOp" << endl << "dynamic: " << this->sage_class_name() << endl;
16633 0 : cerr << "Aborting ..." << endl;
16634 0 : ROSE_ASSERT(false);
16635 : return traversalSuccessorContainer;
16636 : }
16637 :
16638 : vector<string>
16639 0 : SgBinaryOp::get_traversalSuccessorNamesContainer() {
16640 0 : vector<string> traversalSuccessorContainer;
16641 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
16642 0 : << "static: SgBinaryOp" << endl << "dynamic: " << this->sage_class_name() << endl;
16643 0 : cerr << "Aborting ..." << endl;
16644 0 : ROSE_ASSERT(false);
16645 : return traversalSuccessorContainer;
16646 : }
16647 :
16648 : size_t
16649 0 : SgBinaryOp::get_numberOfTraversalSuccessors() {
16650 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
16651 0 : << "static: SgBinaryOp" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
16652 0 : cerr << "Aborting ..." << endl;
16653 0 : ROSE_ASSERT(false);
16654 : return 42;
16655 : }
16656 :
16657 : SgNode*
16658 0 : SgBinaryOp::get_traversalSuccessorByIndex(size_t) {
16659 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
16660 0 : << "static: SgBinaryOp" << endl << "dynamic: " << this->sage_class_name() << endl;
16661 0 : cerr << "Aborting ..." << endl;
16662 0 : ROSE_ASSERT(false);
16663 : return NULL;
16664 : }
16665 :
16666 : size_t
16667 0 : SgBinaryOp::get_childIndex(SgNode *) {
16668 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
16669 0 : << "static: SgBinaryOp" << endl << "dynamic: " << this->sage_class_name() << endl;
16670 0 : cerr << "Aborting ..." << endl;
16671 0 : ROSE_ASSERT(false);
16672 : return 42;
16673 : }
16674 :
16675 : vector<SgNode*>
16676 390367 : SgArrowExp::get_traversalSuccessorContainer() {
16677 390367 : vector<SgNode*> traversalSuccessorContainer;
16678 390367 : traversalSuccessorContainer.reserve(2);
16679 390367 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
16680 390367 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
16681 390367 : return traversalSuccessorContainer;
16682 : }
16683 : vector<string>
16684 16114 : SgArrowExp::get_traversalSuccessorNamesContainer() {
16685 16114 : vector<string> traversalSuccessorContainer;
16686 32228 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
16687 32228 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
16688 16114 : return traversalSuccessorContainer;
16689 : }
16690 : size_t
16691 807539 : SgArrowExp::get_numberOfTraversalSuccessors() {
16692 807539 : return 2;
16693 : }
16694 : SgNode *
16695 1610490 : SgArrowExp::get_traversalSuccessorByIndex(size_t idx) {
16696 1610490 : switch (idx) {
16697 805247 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
16698 805247 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
16699 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16700 0 : ROSE_ASSERT(false);
16701 : return NULL;
16702 : }
16703 : }
16704 : size_t
16705 0 : SgArrowExp::get_childIndex(SgNode *child) {
16706 0 : if (child == p_lhs_operand_i) return 0;
16707 0 : else if (child == p_rhs_operand_i) return 1;
16708 0 : else return (size_t) -1;
16709 : }
16710 : vector<SgNode*>
16711 428723 : SgDotExp::get_traversalSuccessorContainer() {
16712 428723 : vector<SgNode*> traversalSuccessorContainer;
16713 428723 : traversalSuccessorContainer.reserve(2);
16714 428723 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
16715 428723 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
16716 428723 : return traversalSuccessorContainer;
16717 : }
16718 : vector<string>
16719 10898 : SgDotExp::get_traversalSuccessorNamesContainer() {
16720 10898 : vector<string> traversalSuccessorContainer;
16721 21796 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
16722 21796 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
16723 10898 : return traversalSuccessorContainer;
16724 : }
16725 : size_t
16726 718845 : SgDotExp::get_numberOfTraversalSuccessors() {
16727 718845 : return 2;
16728 : }
16729 : SgNode *
16730 1432310 : SgDotExp::get_traversalSuccessorByIndex(size_t idx) {
16731 1432310 : switch (idx) {
16732 716153 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
16733 716153 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
16734 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16735 0 : ROSE_ASSERT(false);
16736 : return NULL;
16737 : }
16738 : }
16739 : size_t
16740 0 : SgDotExp::get_childIndex(SgNode *child) {
16741 0 : if (child == p_lhs_operand_i) return 0;
16742 0 : else if (child == p_rhs_operand_i) return 1;
16743 0 : else return (size_t) -1;
16744 : }
16745 : vector<SgNode*>
16746 2692 : SgDotStarOp::get_traversalSuccessorContainer() {
16747 2692 : vector<SgNode*> traversalSuccessorContainer;
16748 2692 : traversalSuccessorContainer.reserve(2);
16749 2692 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
16750 2692 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
16751 2692 : return traversalSuccessorContainer;
16752 : }
16753 : vector<string>
16754 104 : SgDotStarOp::get_traversalSuccessorNamesContainer() {
16755 104 : vector<string> traversalSuccessorContainer;
16756 208 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
16757 208 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
16758 104 : return traversalSuccessorContainer;
16759 : }
16760 : size_t
16761 5170 : SgDotStarOp::get_numberOfTraversalSuccessors() {
16762 5170 : return 2;
16763 : }
16764 : SgNode *
16765 10308 : SgDotStarOp::get_traversalSuccessorByIndex(size_t idx) {
16766 10308 : switch (idx) {
16767 5154 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
16768 5154 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
16769 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16770 0 : ROSE_ASSERT(false);
16771 : return NULL;
16772 : }
16773 : }
16774 : size_t
16775 0 : SgDotStarOp::get_childIndex(SgNode *child) {
16776 0 : if (child == p_lhs_operand_i) return 0;
16777 0 : else if (child == p_rhs_operand_i) return 1;
16778 0 : else return (size_t) -1;
16779 : }
16780 : vector<SgNode*>
16781 168 : SgArrowStarOp::get_traversalSuccessorContainer() {
16782 168 : vector<SgNode*> traversalSuccessorContainer;
16783 168 : traversalSuccessorContainer.reserve(2);
16784 168 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
16785 168 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
16786 168 : return traversalSuccessorContainer;
16787 : }
16788 : vector<string>
16789 48 : SgArrowStarOp::get_traversalSuccessorNamesContainer() {
16790 48 : vector<string> traversalSuccessorContainer;
16791 96 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
16792 96 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
16793 48 : return traversalSuccessorContainer;
16794 : }
16795 : size_t
16796 1268 : SgArrowStarOp::get_numberOfTraversalSuccessors() {
16797 1268 : return 2;
16798 : }
16799 : SgNode *
16800 2536 : SgArrowStarOp::get_traversalSuccessorByIndex(size_t idx) {
16801 2536 : switch (idx) {
16802 1268 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
16803 1268 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
16804 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16805 0 : ROSE_ASSERT(false);
16806 : return NULL;
16807 : }
16808 : }
16809 : size_t
16810 0 : SgArrowStarOp::get_childIndex(SgNode *child) {
16811 0 : if (child == p_lhs_operand_i) return 0;
16812 0 : else if (child == p_rhs_operand_i) return 1;
16813 0 : else return (size_t) -1;
16814 : }
16815 : vector<SgNode*>
16816 45688 : SgEqualityOp::get_traversalSuccessorContainer() {
16817 45688 : vector<SgNode*> traversalSuccessorContainer;
16818 45688 : traversalSuccessorContainer.reserve(2);
16819 45688 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
16820 45688 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
16821 45688 : return traversalSuccessorContainer;
16822 : }
16823 : vector<string>
16824 3376 : SgEqualityOp::get_traversalSuccessorNamesContainer() {
16825 3376 : vector<string> traversalSuccessorContainer;
16826 6752 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
16827 6752 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
16828 3376 : return traversalSuccessorContainer;
16829 : }
16830 : size_t
16831 126014 : SgEqualityOp::get_numberOfTraversalSuccessors() {
16832 126014 : return 2;
16833 : }
16834 : SgNode *
16835 251604 : SgEqualityOp::get_traversalSuccessorByIndex(size_t idx) {
16836 251604 : switch (idx) {
16837 125802 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
16838 125802 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
16839 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16840 0 : ROSE_ASSERT(false);
16841 : return NULL;
16842 : }
16843 : }
16844 : size_t
16845 0 : SgEqualityOp::get_childIndex(SgNode *child) {
16846 0 : if (child == p_lhs_operand_i) return 0;
16847 0 : else if (child == p_rhs_operand_i) return 1;
16848 0 : else return (size_t) -1;
16849 : }
16850 : vector<SgNode*>
16851 48434 : SgLessThanOp::get_traversalSuccessorContainer() {
16852 48434 : vector<SgNode*> traversalSuccessorContainer;
16853 48434 : traversalSuccessorContainer.reserve(2);
16854 48434 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
16855 48434 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
16856 48434 : return traversalSuccessorContainer;
16857 : }
16858 : vector<string>
16859 2342 : SgLessThanOp::get_traversalSuccessorNamesContainer() {
16860 2342 : vector<string> traversalSuccessorContainer;
16861 4684 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
16862 4684 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
16863 2342 : return traversalSuccessorContainer;
16864 : }
16865 : size_t
16866 104449 : SgLessThanOp::get_numberOfTraversalSuccessors() {
16867 104449 : return 2;
16868 : }
16869 : SgNode *
16870 208402 : SgLessThanOp::get_traversalSuccessorByIndex(size_t idx) {
16871 208402 : switch (idx) {
16872 104201 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
16873 104201 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
16874 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16875 0 : ROSE_ASSERT(false);
16876 : return NULL;
16877 : }
16878 : }
16879 : size_t
16880 100 : SgLessThanOp::get_childIndex(SgNode *child) {
16881 100 : if (child == p_lhs_operand_i) return 0;
16882 39 : else if (child == p_rhs_operand_i) return 1;
16883 0 : else return (size_t) -1;
16884 : }
16885 : vector<SgNode*>
16886 30967 : SgGreaterThanOp::get_traversalSuccessorContainer() {
16887 30967 : vector<SgNode*> traversalSuccessorContainer;
16888 30967 : traversalSuccessorContainer.reserve(2);
16889 30967 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
16890 30967 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
16891 30967 : return traversalSuccessorContainer;
16892 : }
16893 : vector<string>
16894 1416 : SgGreaterThanOp::get_traversalSuccessorNamesContainer() {
16895 1416 : vector<string> traversalSuccessorContainer;
16896 2832 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
16897 2832 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
16898 1416 : return traversalSuccessorContainer;
16899 : }
16900 : size_t
16901 66550 : SgGreaterThanOp::get_numberOfTraversalSuccessors() {
16902 66550 : return 2;
16903 : }
16904 : SgNode *
16905 132764 : SgGreaterThanOp::get_traversalSuccessorByIndex(size_t idx) {
16906 132764 : switch (idx) {
16907 66382 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
16908 66382 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
16909 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16910 0 : ROSE_ASSERT(false);
16911 : return NULL;
16912 : }
16913 : }
16914 : size_t
16915 0 : SgGreaterThanOp::get_childIndex(SgNode *child) {
16916 0 : if (child == p_lhs_operand_i) return 0;
16917 0 : else if (child == p_rhs_operand_i) return 1;
16918 0 : else return (size_t) -1;
16919 : }
16920 : vector<SgNode*>
16921 54936 : SgNotEqualOp::get_traversalSuccessorContainer() {
16922 54936 : vector<SgNode*> traversalSuccessorContainer;
16923 54936 : traversalSuccessorContainer.reserve(2);
16924 54936 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
16925 54936 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
16926 54936 : return traversalSuccessorContainer;
16927 : }
16928 : vector<string>
16929 1400 : SgNotEqualOp::get_traversalSuccessorNamesContainer() {
16930 1400 : vector<string> traversalSuccessorContainer;
16931 2800 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
16932 2800 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
16933 1400 : return traversalSuccessorContainer;
16934 : }
16935 : size_t
16936 93200 : SgNotEqualOp::get_numberOfTraversalSuccessors() {
16937 93200 : return 2;
16938 : }
16939 : SgNode *
16940 185816 : SgNotEqualOp::get_traversalSuccessorByIndex(size_t idx) {
16941 185816 : switch (idx) {
16942 92908 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
16943 92908 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
16944 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16945 0 : ROSE_ASSERT(false);
16946 : return NULL;
16947 : }
16948 : }
16949 : size_t
16950 0 : SgNotEqualOp::get_childIndex(SgNode *child) {
16951 0 : if (child == p_lhs_operand_i) return 0;
16952 0 : else if (child == p_rhs_operand_i) return 1;
16953 0 : else return (size_t) -1;
16954 : }
16955 : vector<SgNode*>
16956 4131 : SgLessOrEqualOp::get_traversalSuccessorContainer() {
16957 4131 : vector<SgNode*> traversalSuccessorContainer;
16958 4131 : traversalSuccessorContainer.reserve(2);
16959 4131 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
16960 4131 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
16961 4131 : return traversalSuccessorContainer;
16962 : }
16963 : vector<string>
16964 372 : SgLessOrEqualOp::get_traversalSuccessorNamesContainer() {
16965 372 : vector<string> traversalSuccessorContainer;
16966 744 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
16967 744 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
16968 372 : return traversalSuccessorContainer;
16969 : }
16970 : size_t
16971 13563 : SgLessOrEqualOp::get_numberOfTraversalSuccessors() {
16972 13563 : return 2;
16973 : }
16974 : SgNode *
16975 27094 : SgLessOrEqualOp::get_traversalSuccessorByIndex(size_t idx) {
16976 27094 : switch (idx) {
16977 13547 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
16978 13547 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
16979 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
16980 0 : ROSE_ASSERT(false);
16981 : return NULL;
16982 : }
16983 : }
16984 : size_t
16985 0 : SgLessOrEqualOp::get_childIndex(SgNode *child) {
16986 0 : if (child == p_lhs_operand_i) return 0;
16987 0 : else if (child == p_rhs_operand_i) return 1;
16988 0 : else return (size_t) -1;
16989 : }
16990 : vector<SgNode*>
16991 8718 : SgGreaterOrEqualOp::get_traversalSuccessorContainer() {
16992 8718 : vector<SgNode*> traversalSuccessorContainer;
16993 8718 : traversalSuccessorContainer.reserve(2);
16994 8718 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
16995 8718 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
16996 8718 : return traversalSuccessorContainer;
16997 : }
16998 : vector<string>
16999 398 : SgGreaterOrEqualOp::get_traversalSuccessorNamesContainer() {
17000 398 : vector<string> traversalSuccessorContainer;
17001 796 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17002 796 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17003 398 : return traversalSuccessorContainer;
17004 : }
17005 : size_t
17006 18064 : SgGreaterOrEqualOp::get_numberOfTraversalSuccessors() {
17007 18064 : return 2;
17008 : }
17009 : SgNode *
17010 36032 : SgGreaterOrEqualOp::get_traversalSuccessorByIndex(size_t idx) {
17011 36032 : switch (idx) {
17012 18016 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17013 18016 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17014 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17015 0 : ROSE_ASSERT(false);
17016 : return NULL;
17017 : }
17018 : }
17019 : size_t
17020 0 : SgGreaterOrEqualOp::get_childIndex(SgNode *child) {
17021 0 : if (child == p_lhs_operand_i) return 0;
17022 0 : else if (child == p_rhs_operand_i) return 1;
17023 0 : else return (size_t) -1;
17024 : }
17025 : vector<SgNode*>
17026 76228 : SgAddOp::get_traversalSuccessorContainer() {
17027 76228 : vector<SgNode*> traversalSuccessorContainer;
17028 76228 : traversalSuccessorContainer.reserve(2);
17029 76228 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17030 76228 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17031 76228 : return traversalSuccessorContainer;
17032 : }
17033 : vector<string>
17034 2750 : SgAddOp::get_traversalSuccessorNamesContainer() {
17035 2750 : vector<string> traversalSuccessorContainer;
17036 5500 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17037 5500 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17038 2750 : return traversalSuccessorContainer;
17039 : }
17040 : size_t
17041 148759 : SgAddOp::get_numberOfTraversalSuccessors() {
17042 148759 : return 2;
17043 : }
17044 : SgNode *
17045 296246 : SgAddOp::get_traversalSuccessorByIndex(size_t idx) {
17046 296246 : switch (idx) {
17047 148123 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17048 148123 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17049 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17050 0 : ROSE_ASSERT(false);
17051 : return NULL;
17052 : }
17053 : }
17054 : size_t
17055 203 : SgAddOp::get_childIndex(SgNode *child) {
17056 203 : if (child == p_lhs_operand_i) return 0;
17057 104 : else if (child == p_rhs_operand_i) return 1;
17058 0 : else return (size_t) -1;
17059 : }
17060 : vector<SgNode*>
17061 97561 : SgSubtractOp::get_traversalSuccessorContainer() {
17062 97561 : vector<SgNode*> traversalSuccessorContainer;
17063 97561 : traversalSuccessorContainer.reserve(2);
17064 97561 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17065 97561 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17066 97561 : return traversalSuccessorContainer;
17067 : }
17068 : vector<string>
17069 3058 : SgSubtractOp::get_traversalSuccessorNamesContainer() {
17070 3058 : vector<string> traversalSuccessorContainer;
17071 6116 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17072 6116 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17073 3058 : return traversalSuccessorContainer;
17074 : }
17075 : size_t
17076 175353 : SgSubtractOp::get_numberOfTraversalSuccessors() {
17077 175353 : return 2;
17078 : }
17079 : SgNode *
17080 349586 : SgSubtractOp::get_traversalSuccessorByIndex(size_t idx) {
17081 349586 : switch (idx) {
17082 174793 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17083 174793 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17084 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17085 0 : ROSE_ASSERT(false);
17086 : return NULL;
17087 : }
17088 : }
17089 : size_t
17090 0 : SgSubtractOp::get_childIndex(SgNode *child) {
17091 0 : if (child == p_lhs_operand_i) return 0;
17092 0 : else if (child == p_rhs_operand_i) return 1;
17093 0 : else return (size_t) -1;
17094 : }
17095 : vector<SgNode*>
17096 38691 : SgMultiplyOp::get_traversalSuccessorContainer() {
17097 38691 : vector<SgNode*> traversalSuccessorContainer;
17098 38691 : traversalSuccessorContainer.reserve(2);
17099 38691 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17100 38691 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17101 38691 : return traversalSuccessorContainer;
17102 : }
17103 : vector<string>
17104 1298 : SgMultiplyOp::get_traversalSuccessorNamesContainer() {
17105 1298 : vector<string> traversalSuccessorContainer;
17106 2596 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17107 2596 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17108 1298 : return traversalSuccessorContainer;
17109 : }
17110 : size_t
17111 70258 : SgMultiplyOp::get_numberOfTraversalSuccessors() {
17112 70258 : return 2;
17113 : }
17114 : SgNode *
17115 140116 : SgMultiplyOp::get_traversalSuccessorByIndex(size_t idx) {
17116 140116 : switch (idx) {
17117 70058 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17118 70058 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17119 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17120 0 : ROSE_ASSERT(false);
17121 : return NULL;
17122 : }
17123 : }
17124 : size_t
17125 0 : SgMultiplyOp::get_childIndex(SgNode *child) {
17126 0 : if (child == p_lhs_operand_i) return 0;
17127 0 : else if (child == p_rhs_operand_i) return 1;
17128 0 : else return (size_t) -1;
17129 : }
17130 : vector<SgNode*>
17131 17762 : SgDivideOp::get_traversalSuccessorContainer() {
17132 17762 : vector<SgNode*> traversalSuccessorContainer;
17133 17762 : traversalSuccessorContainer.reserve(2);
17134 17762 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17135 17762 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17136 17762 : return traversalSuccessorContainer;
17137 : }
17138 : vector<string>
17139 812 : SgDivideOp::get_traversalSuccessorNamesContainer() {
17140 812 : vector<string> traversalSuccessorContainer;
17141 1624 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17142 1624 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17143 812 : return traversalSuccessorContainer;
17144 : }
17145 : size_t
17146 35176 : SgDivideOp::get_numberOfTraversalSuccessors() {
17147 35176 : return 2;
17148 : }
17149 : SgNode *
17150 70176 : SgDivideOp::get_traversalSuccessorByIndex(size_t idx) {
17151 70176 : switch (idx) {
17152 35088 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17153 35088 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17154 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17155 0 : ROSE_ASSERT(false);
17156 : return NULL;
17157 : }
17158 : }
17159 : size_t
17160 0 : SgDivideOp::get_childIndex(SgNode *child) {
17161 0 : if (child == p_lhs_operand_i) return 0;
17162 0 : else if (child == p_rhs_operand_i) return 1;
17163 0 : else return (size_t) -1;
17164 : }
17165 : vector<SgNode*>
17166 0 : SgIntegerDivideOp::get_traversalSuccessorContainer() {
17167 0 : vector<SgNode*> traversalSuccessorContainer;
17168 0 : traversalSuccessorContainer.reserve(2);
17169 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17170 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17171 0 : return traversalSuccessorContainer;
17172 : }
17173 : vector<string>
17174 0 : SgIntegerDivideOp::get_traversalSuccessorNamesContainer() {
17175 0 : vector<string> traversalSuccessorContainer;
17176 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17177 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17178 0 : return traversalSuccessorContainer;
17179 : }
17180 : size_t
17181 0 : SgIntegerDivideOp::get_numberOfTraversalSuccessors() {
17182 0 : return 2;
17183 : }
17184 : SgNode *
17185 0 : SgIntegerDivideOp::get_traversalSuccessorByIndex(size_t idx) {
17186 0 : switch (idx) {
17187 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17188 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17189 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17190 0 : ROSE_ASSERT(false);
17191 : return NULL;
17192 : }
17193 : }
17194 : size_t
17195 0 : SgIntegerDivideOp::get_childIndex(SgNode *child) {
17196 0 : if (child == p_lhs_operand_i) return 0;
17197 0 : else if (child == p_rhs_operand_i) return 1;
17198 0 : else return (size_t) -1;
17199 : }
17200 : vector<SgNode*>
17201 3427 : SgModOp::get_traversalSuccessorContainer() {
17202 3427 : vector<SgNode*> traversalSuccessorContainer;
17203 3427 : traversalSuccessorContainer.reserve(2);
17204 3427 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17205 3427 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17206 3427 : return traversalSuccessorContainer;
17207 : }
17208 : vector<string>
17209 98 : SgModOp::get_traversalSuccessorNamesContainer() {
17210 98 : vector<string> traversalSuccessorContainer;
17211 196 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17212 196 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17213 98 : return traversalSuccessorContainer;
17214 : }
17215 : size_t
17216 6083 : SgModOp::get_numberOfTraversalSuccessors() {
17217 6083 : return 2;
17218 : }
17219 : SgNode *
17220 12126 : SgModOp::get_traversalSuccessorByIndex(size_t idx) {
17221 12126 : switch (idx) {
17222 6063 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17223 6063 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17224 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17225 0 : ROSE_ASSERT(false);
17226 : return NULL;
17227 : }
17228 : }
17229 : size_t
17230 0 : SgModOp::get_childIndex(SgNode *child) {
17231 0 : if (child == p_lhs_operand_i) return 0;
17232 0 : else if (child == p_rhs_operand_i) return 1;
17233 0 : else return (size_t) -1;
17234 : }
17235 : vector<SgNode*>
17236 31174 : SgAndOp::get_traversalSuccessorContainer() {
17237 31174 : vector<SgNode*> traversalSuccessorContainer;
17238 31174 : traversalSuccessorContainer.reserve(2);
17239 31174 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17240 31174 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17241 31174 : return traversalSuccessorContainer;
17242 : }
17243 : vector<string>
17244 2070 : SgAndOp::get_traversalSuccessorNamesContainer() {
17245 2070 : vector<string> traversalSuccessorContainer;
17246 4140 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17247 4140 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17248 2070 : return traversalSuccessorContainer;
17249 : }
17250 : size_t
17251 81433 : SgAndOp::get_numberOfTraversalSuccessors() {
17252 81433 : return 2;
17253 : }
17254 : SgNode *
17255 162578 : SgAndOp::get_traversalSuccessorByIndex(size_t idx) {
17256 162578 : switch (idx) {
17257 81289 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17258 81289 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17259 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17260 0 : ROSE_ASSERT(false);
17261 : return NULL;
17262 : }
17263 : }
17264 : size_t
17265 0 : SgAndOp::get_childIndex(SgNode *child) {
17266 0 : if (child == p_lhs_operand_i) return 0;
17267 0 : else if (child == p_rhs_operand_i) return 1;
17268 0 : else return (size_t) -1;
17269 : }
17270 : vector<SgNode*>
17271 9884 : SgOrOp::get_traversalSuccessorContainer() {
17272 9884 : vector<SgNode*> traversalSuccessorContainer;
17273 9884 : traversalSuccessorContainer.reserve(2);
17274 9884 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17275 9884 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17276 9884 : return traversalSuccessorContainer;
17277 : }
17278 : vector<string>
17279 942 : SgOrOp::get_traversalSuccessorNamesContainer() {
17280 942 : vector<string> traversalSuccessorContainer;
17281 1884 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17282 1884 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17283 942 : return traversalSuccessorContainer;
17284 : }
17285 : size_t
17286 33286 : SgOrOp::get_numberOfTraversalSuccessors() {
17287 33286 : return 2;
17288 : }
17289 : SgNode *
17290 66492 : SgOrOp::get_traversalSuccessorByIndex(size_t idx) {
17291 66492 : switch (idx) {
17292 33246 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17293 33246 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17294 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17295 0 : ROSE_ASSERT(false);
17296 : return NULL;
17297 : }
17298 : }
17299 : size_t
17300 0 : SgOrOp::get_childIndex(SgNode *child) {
17301 0 : if (child == p_lhs_operand_i) return 0;
17302 0 : else if (child == p_rhs_operand_i) return 1;
17303 0 : else return (size_t) -1;
17304 : }
17305 : vector<SgNode*>
17306 238 : SgBitXorOp::get_traversalSuccessorContainer() {
17307 238 : vector<SgNode*> traversalSuccessorContainer;
17308 238 : traversalSuccessorContainer.reserve(2);
17309 238 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17310 238 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17311 238 : return traversalSuccessorContainer;
17312 : }
17313 : vector<string>
17314 60 : SgBitXorOp::get_traversalSuccessorNamesContainer() {
17315 60 : vector<string> traversalSuccessorContainer;
17316 120 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17317 120 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17318 60 : return traversalSuccessorContainer;
17319 : }
17320 : size_t
17321 1713 : SgBitXorOp::get_numberOfTraversalSuccessors() {
17322 1713 : return 2;
17323 : }
17324 : SgNode *
17325 3426 : SgBitXorOp::get_traversalSuccessorByIndex(size_t idx) {
17326 3426 : switch (idx) {
17327 1713 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17328 1713 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17329 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17330 0 : ROSE_ASSERT(false);
17331 : return NULL;
17332 : }
17333 : }
17334 : size_t
17335 0 : SgBitXorOp::get_childIndex(SgNode *child) {
17336 0 : if (child == p_lhs_operand_i) return 0;
17337 0 : else if (child == p_rhs_operand_i) return 1;
17338 0 : else return (size_t) -1;
17339 : }
17340 : vector<SgNode*>
17341 2054 : SgBitAndOp::get_traversalSuccessorContainer() {
17342 2054 : vector<SgNode*> traversalSuccessorContainer;
17343 2054 : traversalSuccessorContainer.reserve(2);
17344 2054 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17345 2054 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17346 2054 : return traversalSuccessorContainer;
17347 : }
17348 : vector<string>
17349 232 : SgBitAndOp::get_traversalSuccessorNamesContainer() {
17350 232 : vector<string> traversalSuccessorContainer;
17351 464 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17352 464 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17353 232 : return traversalSuccessorContainer;
17354 : }
17355 : size_t
17356 7934 : SgBitAndOp::get_numberOfTraversalSuccessors() {
17357 7934 : return 2;
17358 : }
17359 : SgNode *
17360 15852 : SgBitAndOp::get_traversalSuccessorByIndex(size_t idx) {
17361 15852 : switch (idx) {
17362 7926 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17363 7926 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17364 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17365 0 : ROSE_ASSERT(false);
17366 : return NULL;
17367 : }
17368 : }
17369 : size_t
17370 0 : SgBitAndOp::get_childIndex(SgNode *child) {
17371 0 : if (child == p_lhs_operand_i) return 0;
17372 0 : else if (child == p_rhs_operand_i) return 1;
17373 0 : else return (size_t) -1;
17374 : }
17375 : vector<SgNode*>
17376 968 : SgBitOrOp::get_traversalSuccessorContainer() {
17377 968 : vector<SgNode*> traversalSuccessorContainer;
17378 968 : traversalSuccessorContainer.reserve(2);
17379 968 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17380 968 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17381 968 : return traversalSuccessorContainer;
17382 : }
17383 : vector<string>
17384 168 : SgBitOrOp::get_traversalSuccessorNamesContainer() {
17385 168 : vector<string> traversalSuccessorContainer;
17386 336 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17387 336 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17388 168 : return traversalSuccessorContainer;
17389 : }
17390 : size_t
17391 4309 : SgBitOrOp::get_numberOfTraversalSuccessors() {
17392 4309 : return 2;
17393 : }
17394 : SgNode *
17395 8618 : SgBitOrOp::get_traversalSuccessorByIndex(size_t idx) {
17396 8618 : switch (idx) {
17397 4309 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17398 4309 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17399 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17400 0 : ROSE_ASSERT(false);
17401 : return NULL;
17402 : }
17403 : }
17404 : size_t
17405 0 : SgBitOrOp::get_childIndex(SgNode *child) {
17406 0 : if (child == p_lhs_operand_i) return 0;
17407 0 : else if (child == p_rhs_operand_i) return 1;
17408 0 : else return (size_t) -1;
17409 : }
17410 : vector<SgNode*>
17411 0 : SgBitEqvOp::get_traversalSuccessorContainer() {
17412 0 : vector<SgNode*> traversalSuccessorContainer;
17413 0 : traversalSuccessorContainer.reserve(2);
17414 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17415 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17416 0 : return traversalSuccessorContainer;
17417 : }
17418 : vector<string>
17419 0 : SgBitEqvOp::get_traversalSuccessorNamesContainer() {
17420 0 : vector<string> traversalSuccessorContainer;
17421 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17422 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17423 0 : return traversalSuccessorContainer;
17424 : }
17425 : size_t
17426 0 : SgBitEqvOp::get_numberOfTraversalSuccessors() {
17427 0 : return 2;
17428 : }
17429 : SgNode *
17430 0 : SgBitEqvOp::get_traversalSuccessorByIndex(size_t idx) {
17431 0 : switch (idx) {
17432 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17433 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17434 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17435 0 : ROSE_ASSERT(false);
17436 : return NULL;
17437 : }
17438 : }
17439 : size_t
17440 0 : SgBitEqvOp::get_childIndex(SgNode *child) {
17441 0 : if (child == p_lhs_operand_i) return 0;
17442 0 : else if (child == p_rhs_operand_i) return 1;
17443 0 : else return (size_t) -1;
17444 : }
17445 : vector<SgNode*>
17446 18200 : SgCommaOpExp::get_traversalSuccessorContainer() {
17447 18200 : vector<SgNode*> traversalSuccessorContainer;
17448 18200 : traversalSuccessorContainer.reserve(2);
17449 18200 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17450 18200 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17451 18200 : return traversalSuccessorContainer;
17452 : }
17453 : vector<string>
17454 370 : SgCommaOpExp::get_traversalSuccessorNamesContainer() {
17455 370 : vector<string> traversalSuccessorContainer;
17456 740 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17457 740 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17458 370 : return traversalSuccessorContainer;
17459 : }
17460 : size_t
17461 27236 : SgCommaOpExp::get_numberOfTraversalSuccessors() {
17462 27236 : return 2;
17463 : }
17464 : SgNode *
17465 54248 : SgCommaOpExp::get_traversalSuccessorByIndex(size_t idx) {
17466 54248 : switch (idx) {
17467 27124 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17468 27124 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17469 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17470 0 : ROSE_ASSERT(false);
17471 : return NULL;
17472 : }
17473 : }
17474 : size_t
17475 0 : SgCommaOpExp::get_childIndex(SgNode *child) {
17476 0 : if (child == p_lhs_operand_i) return 0;
17477 0 : else if (child == p_rhs_operand_i) return 1;
17478 0 : else return (size_t) -1;
17479 : }
17480 : vector<SgNode*>
17481 14431 : SgLshiftOp::get_traversalSuccessorContainer() {
17482 14431 : vector<SgNode*> traversalSuccessorContainer;
17483 14431 : traversalSuccessorContainer.reserve(2);
17484 14431 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17485 14431 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17486 14431 : return traversalSuccessorContainer;
17487 : }
17488 : vector<string>
17489 332 : SgLshiftOp::get_traversalSuccessorNamesContainer() {
17490 332 : vector<string> traversalSuccessorContainer;
17491 664 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17492 664 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17493 332 : return traversalSuccessorContainer;
17494 : }
17495 : size_t
17496 15997 : SgLshiftOp::get_numberOfTraversalSuccessors() {
17497 15997 : return 2;
17498 : }
17499 : SgNode *
17500 31930 : SgLshiftOp::get_traversalSuccessorByIndex(size_t idx) {
17501 31930 : switch (idx) {
17502 15965 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17503 15965 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17504 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17505 0 : ROSE_ASSERT(false);
17506 : return NULL;
17507 : }
17508 : }
17509 : size_t
17510 0 : SgLshiftOp::get_childIndex(SgNode *child) {
17511 0 : if (child == p_lhs_operand_i) return 0;
17512 0 : else if (child == p_rhs_operand_i) return 1;
17513 0 : else return (size_t) -1;
17514 : }
17515 : vector<SgNode*>
17516 3611 : SgRshiftOp::get_traversalSuccessorContainer() {
17517 3611 : vector<SgNode*> traversalSuccessorContainer;
17518 3611 : traversalSuccessorContainer.reserve(2);
17519 3611 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17520 3611 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17521 3611 : return traversalSuccessorContainer;
17522 : }
17523 : vector<string>
17524 88 : SgRshiftOp::get_traversalSuccessorNamesContainer() {
17525 88 : vector<string> traversalSuccessorContainer;
17526 176 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17527 176 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17528 88 : return traversalSuccessorContainer;
17529 : }
17530 : size_t
17531 4745 : SgRshiftOp::get_numberOfTraversalSuccessors() {
17532 4745 : return 2;
17533 : }
17534 : SgNode *
17535 9474 : SgRshiftOp::get_traversalSuccessorByIndex(size_t idx) {
17536 9474 : switch (idx) {
17537 4737 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17538 4737 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17539 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17540 0 : ROSE_ASSERT(false);
17541 : return NULL;
17542 : }
17543 : }
17544 : size_t
17545 0 : SgRshiftOp::get_childIndex(SgNode *child) {
17546 0 : if (child == p_lhs_operand_i) return 0;
17547 0 : else if (child == p_rhs_operand_i) return 1;
17548 0 : else return (size_t) -1;
17549 : }
17550 : vector<SgNode*>
17551 35988 : SgPntrArrRefExp::get_traversalSuccessorContainer() {
17552 35988 : vector<SgNode*> traversalSuccessorContainer;
17553 35988 : traversalSuccessorContainer.reserve(2);
17554 35988 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17555 35988 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17556 35988 : return traversalSuccessorContainer;
17557 : }
17558 : vector<string>
17559 2596 : SgPntrArrRefExp::get_traversalSuccessorNamesContainer() {
17560 2596 : vector<string> traversalSuccessorContainer;
17561 5192 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17562 5192 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17563 2596 : return traversalSuccessorContainer;
17564 : }
17565 : size_t
17566 104651 : SgPntrArrRefExp::get_numberOfTraversalSuccessors() {
17567 104651 : return 2;
17568 : }
17569 : SgNode *
17570 208518 : SgPntrArrRefExp::get_traversalSuccessorByIndex(size_t idx) {
17571 208518 : switch (idx) {
17572 104259 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17573 104259 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17574 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17575 0 : ROSE_ASSERT(false);
17576 : return NULL;
17577 : }
17578 : }
17579 : size_t
17580 160 : SgPntrArrRefExp::get_childIndex(SgNode *child) {
17581 160 : if (child == p_lhs_operand_i) return 0;
17582 80 : else if (child == p_rhs_operand_i) return 1;
17583 0 : else return (size_t) -1;
17584 : }
17585 : vector<SgNode*>
17586 0 : SgScopeOp::get_traversalSuccessorContainer() {
17587 0 : vector<SgNode*> traversalSuccessorContainer;
17588 0 : traversalSuccessorContainer.reserve(2);
17589 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17590 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17591 0 : return traversalSuccessorContainer;
17592 : }
17593 : vector<string>
17594 0 : SgScopeOp::get_traversalSuccessorNamesContainer() {
17595 0 : vector<string> traversalSuccessorContainer;
17596 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17597 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17598 0 : return traversalSuccessorContainer;
17599 : }
17600 : size_t
17601 0 : SgScopeOp::get_numberOfTraversalSuccessors() {
17602 0 : return 2;
17603 : }
17604 : SgNode *
17605 0 : SgScopeOp::get_traversalSuccessorByIndex(size_t idx) {
17606 0 : switch (idx) {
17607 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17608 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17609 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17610 0 : ROSE_ASSERT(false);
17611 : return NULL;
17612 : }
17613 : }
17614 : size_t
17615 0 : SgScopeOp::get_childIndex(SgNode *child) {
17616 0 : if (child == p_lhs_operand_i) return 0;
17617 0 : else if (child == p_rhs_operand_i) return 1;
17618 0 : else return (size_t) -1;
17619 : }
17620 : vector<SgNode*>
17621 137208 : SgAssignOp::get_traversalSuccessorContainer() {
17622 137208 : vector<SgNode*> traversalSuccessorContainer;
17623 137208 : traversalSuccessorContainer.reserve(2);
17624 137208 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17625 137208 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17626 137208 : return traversalSuccessorContainer;
17627 : }
17628 : vector<string>
17629 7954 : SgAssignOp::get_traversalSuccessorNamesContainer() {
17630 7954 : vector<string> traversalSuccessorContainer;
17631 15908 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17632 15908 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17633 7954 : return traversalSuccessorContainer;
17634 : }
17635 : size_t
17636 327739 : SgAssignOp::get_numberOfTraversalSuccessors() {
17637 327739 : return 2;
17638 : }
17639 : SgNode *
17640 653846 : SgAssignOp::get_traversalSuccessorByIndex(size_t idx) {
17641 653846 : switch (idx) {
17642 326923 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17643 326923 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17644 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17645 0 : ROSE_ASSERT(false);
17646 : return NULL;
17647 : }
17648 : }
17649 : size_t
17650 222 : SgAssignOp::get_childIndex(SgNode *child) {
17651 222 : if (child == p_lhs_operand_i) return 0;
17652 112 : else if (child == p_rhs_operand_i) return 1;
17653 0 : else return (size_t) -1;
17654 : }
17655 : vector<SgNode*>
17656 0 : SgExponentiationOp::get_traversalSuccessorContainer() {
17657 0 : vector<SgNode*> traversalSuccessorContainer;
17658 0 : traversalSuccessorContainer.reserve(2);
17659 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17660 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17661 0 : return traversalSuccessorContainer;
17662 : }
17663 : vector<string>
17664 0 : SgExponentiationOp::get_traversalSuccessorNamesContainer() {
17665 0 : vector<string> traversalSuccessorContainer;
17666 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17667 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17668 0 : return traversalSuccessorContainer;
17669 : }
17670 : size_t
17671 0 : SgExponentiationOp::get_numberOfTraversalSuccessors() {
17672 0 : return 2;
17673 : }
17674 : SgNode *
17675 0 : SgExponentiationOp::get_traversalSuccessorByIndex(size_t idx) {
17676 0 : switch (idx) {
17677 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17678 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17679 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17680 0 : ROSE_ASSERT(false);
17681 : return NULL;
17682 : }
17683 : }
17684 : size_t
17685 0 : SgExponentiationOp::get_childIndex(SgNode *child) {
17686 0 : if (child == p_lhs_operand_i) return 0;
17687 0 : else if (child == p_rhs_operand_i) return 1;
17688 0 : else return (size_t) -1;
17689 : }
17690 : vector<SgNode*>
17691 0 : SgConcatenationOp::get_traversalSuccessorContainer() {
17692 0 : vector<SgNode*> traversalSuccessorContainer;
17693 0 : traversalSuccessorContainer.reserve(2);
17694 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17695 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17696 0 : return traversalSuccessorContainer;
17697 : }
17698 : vector<string>
17699 0 : SgConcatenationOp::get_traversalSuccessorNamesContainer() {
17700 0 : vector<string> traversalSuccessorContainer;
17701 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17702 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17703 0 : return traversalSuccessorContainer;
17704 : }
17705 : size_t
17706 0 : SgConcatenationOp::get_numberOfTraversalSuccessors() {
17707 0 : return 2;
17708 : }
17709 : SgNode *
17710 0 : SgConcatenationOp::get_traversalSuccessorByIndex(size_t idx) {
17711 0 : switch (idx) {
17712 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17713 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17714 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17715 0 : ROSE_ASSERT(false);
17716 : return NULL;
17717 : }
17718 : }
17719 : size_t
17720 0 : SgConcatenationOp::get_childIndex(SgNode *child) {
17721 0 : if (child == p_lhs_operand_i) return 0;
17722 0 : else if (child == p_rhs_operand_i) return 1;
17723 0 : else return (size_t) -1;
17724 : }
17725 : vector<SgNode*>
17726 4 : SgPointerAssignOp::get_traversalSuccessorContainer() {
17727 4 : vector<SgNode*> traversalSuccessorContainer;
17728 4 : traversalSuccessorContainer.reserve(2);
17729 4 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17730 4 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17731 4 : return traversalSuccessorContainer;
17732 : }
17733 : vector<string>
17734 2 : SgPointerAssignOp::get_traversalSuccessorNamesContainer() {
17735 2 : vector<string> traversalSuccessorContainer;
17736 4 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17737 4 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17738 2 : return traversalSuccessorContainer;
17739 : }
17740 : size_t
17741 42 : SgPointerAssignOp::get_numberOfTraversalSuccessors() {
17742 42 : return 2;
17743 : }
17744 : SgNode *
17745 84 : SgPointerAssignOp::get_traversalSuccessorByIndex(size_t idx) {
17746 84 : switch (idx) {
17747 42 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17748 42 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17749 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17750 0 : ROSE_ASSERT(false);
17751 : return NULL;
17752 : }
17753 : }
17754 : size_t
17755 0 : SgPointerAssignOp::get_childIndex(SgNode *child) {
17756 0 : if (child == p_lhs_operand_i) return 0;
17757 0 : else if (child == p_rhs_operand_i) return 1;
17758 0 : else return (size_t) -1;
17759 : }
17760 : vector<SgNode*>
17761 0 : SgUserDefinedBinaryOp::get_traversalSuccessorContainer() {
17762 0 : vector<SgNode*> traversalSuccessorContainer;
17763 0 : traversalSuccessorContainer.reserve(2);
17764 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17765 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17766 0 : return traversalSuccessorContainer;
17767 : }
17768 : vector<string>
17769 0 : SgUserDefinedBinaryOp::get_traversalSuccessorNamesContainer() {
17770 0 : vector<string> traversalSuccessorContainer;
17771 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17772 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17773 0 : return traversalSuccessorContainer;
17774 : }
17775 : size_t
17776 0 : SgUserDefinedBinaryOp::get_numberOfTraversalSuccessors() {
17777 0 : return 2;
17778 : }
17779 : SgNode *
17780 0 : SgUserDefinedBinaryOp::get_traversalSuccessorByIndex(size_t idx) {
17781 0 : switch (idx) {
17782 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17783 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17784 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17785 0 : ROSE_ASSERT(false);
17786 : return NULL;
17787 : }
17788 : }
17789 : size_t
17790 0 : SgUserDefinedBinaryOp::get_childIndex(SgNode *child) {
17791 0 : if (child == p_lhs_operand_i) return 0;
17792 0 : else if (child == p_rhs_operand_i) return 1;
17793 0 : else return (size_t) -1;
17794 : }
17795 : vector<SgNode*>
17796 0 : SgCompoundAssignOp::get_traversalSuccessorContainer() {
17797 0 : vector<SgNode*> traversalSuccessorContainer;
17798 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
17799 0 : << "static: SgCompoundAssignOp" << endl << "dynamic: " << this->sage_class_name() << endl;
17800 0 : cerr << "Aborting ..." << endl;
17801 0 : ROSE_ASSERT(false);
17802 : return traversalSuccessorContainer;
17803 : }
17804 :
17805 : vector<string>
17806 0 : SgCompoundAssignOp::get_traversalSuccessorNamesContainer() {
17807 0 : vector<string> traversalSuccessorContainer;
17808 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
17809 0 : << "static: SgCompoundAssignOp" << endl << "dynamic: " << this->sage_class_name() << endl;
17810 0 : cerr << "Aborting ..." << endl;
17811 0 : ROSE_ASSERT(false);
17812 : return traversalSuccessorContainer;
17813 : }
17814 :
17815 : size_t
17816 0 : SgCompoundAssignOp::get_numberOfTraversalSuccessors() {
17817 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
17818 0 : << "static: SgCompoundAssignOp" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
17819 0 : cerr << "Aborting ..." << endl;
17820 0 : ROSE_ASSERT(false);
17821 : return 42;
17822 : }
17823 :
17824 : SgNode*
17825 0 : SgCompoundAssignOp::get_traversalSuccessorByIndex(size_t) {
17826 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
17827 0 : << "static: SgCompoundAssignOp" << endl << "dynamic: " << this->sage_class_name() << endl;
17828 0 : cerr << "Aborting ..." << endl;
17829 0 : ROSE_ASSERT(false);
17830 : return NULL;
17831 : }
17832 :
17833 : size_t
17834 0 : SgCompoundAssignOp::get_childIndex(SgNode *) {
17835 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
17836 0 : << "static: SgCompoundAssignOp" << endl << "dynamic: " << this->sage_class_name() << endl;
17837 0 : cerr << "Aborting ..." << endl;
17838 0 : ROSE_ASSERT(false);
17839 : return 42;
17840 : }
17841 :
17842 : vector<SgNode*>
17843 10115 : SgPlusAssignOp::get_traversalSuccessorContainer() {
17844 10115 : vector<SgNode*> traversalSuccessorContainer;
17845 10115 : traversalSuccessorContainer.reserve(2);
17846 10115 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17847 10115 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17848 10115 : return traversalSuccessorContainer;
17849 : }
17850 : vector<string>
17851 492 : SgPlusAssignOp::get_traversalSuccessorNamesContainer() {
17852 492 : vector<string> traversalSuccessorContainer;
17853 984 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17854 984 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17855 492 : return traversalSuccessorContainer;
17856 : }
17857 : size_t
17858 22132 : SgPlusAssignOp::get_numberOfTraversalSuccessors() {
17859 22132 : return 2;
17860 : }
17861 : SgNode *
17862 44152 : SgPlusAssignOp::get_traversalSuccessorByIndex(size_t idx) {
17863 44152 : switch (idx) {
17864 22076 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17865 22076 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17866 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17867 0 : ROSE_ASSERT(false);
17868 : return NULL;
17869 : }
17870 : }
17871 : size_t
17872 84 : SgPlusAssignOp::get_childIndex(SgNode *child) {
17873 84 : if (child == p_lhs_operand_i) return 0;
17874 39 : else if (child == p_rhs_operand_i) return 1;
17875 0 : else return (size_t) -1;
17876 : }
17877 : vector<SgNode*>
17878 2150 : SgMinusAssignOp::get_traversalSuccessorContainer() {
17879 2150 : vector<SgNode*> traversalSuccessorContainer;
17880 2150 : traversalSuccessorContainer.reserve(2);
17881 2150 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17882 2150 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17883 2150 : return traversalSuccessorContainer;
17884 : }
17885 : vector<string>
17886 132 : SgMinusAssignOp::get_traversalSuccessorNamesContainer() {
17887 132 : vector<string> traversalSuccessorContainer;
17888 264 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17889 264 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17890 132 : return traversalSuccessorContainer;
17891 : }
17892 : size_t
17893 5359 : SgMinusAssignOp::get_numberOfTraversalSuccessors() {
17894 5359 : return 2;
17895 : }
17896 : SgNode *
17897 10694 : SgMinusAssignOp::get_traversalSuccessorByIndex(size_t idx) {
17898 10694 : switch (idx) {
17899 5347 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17900 5347 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17901 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17902 0 : ROSE_ASSERT(false);
17903 : return NULL;
17904 : }
17905 : }
17906 : size_t
17907 0 : SgMinusAssignOp::get_childIndex(SgNode *child) {
17908 0 : if (child == p_lhs_operand_i) return 0;
17909 0 : else if (child == p_rhs_operand_i) return 1;
17910 0 : else return (size_t) -1;
17911 : }
17912 : vector<SgNode*>
17913 1753 : SgAndAssignOp::get_traversalSuccessorContainer() {
17914 1753 : vector<SgNode*> traversalSuccessorContainer;
17915 1753 : traversalSuccessorContainer.reserve(2);
17916 1753 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17917 1753 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17918 1753 : return traversalSuccessorContainer;
17919 : }
17920 : vector<string>
17921 6 : SgAndAssignOp::get_traversalSuccessorNamesContainer() {
17922 6 : vector<string> traversalSuccessorContainer;
17923 12 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17924 12 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17925 6 : return traversalSuccessorContainer;
17926 : }
17927 : size_t
17928 2034 : SgAndAssignOp::get_numberOfTraversalSuccessors() {
17929 2034 : return 2;
17930 : }
17931 : SgNode *
17932 4044 : SgAndAssignOp::get_traversalSuccessorByIndex(size_t idx) {
17933 4044 : switch (idx) {
17934 2022 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17935 2022 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17936 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17937 0 : ROSE_ASSERT(false);
17938 : return NULL;
17939 : }
17940 : }
17941 : size_t
17942 0 : SgAndAssignOp::get_childIndex(SgNode *child) {
17943 0 : if (child == p_lhs_operand_i) return 0;
17944 0 : else if (child == p_rhs_operand_i) return 1;
17945 0 : else return (size_t) -1;
17946 : }
17947 : vector<SgNode*>
17948 1488 : SgIorAssignOp::get_traversalSuccessorContainer() {
17949 1488 : vector<SgNode*> traversalSuccessorContainer;
17950 1488 : traversalSuccessorContainer.reserve(2);
17951 1488 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17952 1488 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17953 1488 : return traversalSuccessorContainer;
17954 : }
17955 : vector<string>
17956 88 : SgIorAssignOp::get_traversalSuccessorNamesContainer() {
17957 88 : vector<string> traversalSuccessorContainer;
17958 176 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17959 176 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17960 88 : return traversalSuccessorContainer;
17961 : }
17962 : size_t
17963 3607 : SgIorAssignOp::get_numberOfTraversalSuccessors() {
17964 3607 : return 2;
17965 : }
17966 : SgNode *
17967 7198 : SgIorAssignOp::get_traversalSuccessorByIndex(size_t idx) {
17968 7198 : switch (idx) {
17969 3599 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
17970 3599 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
17971 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
17972 0 : ROSE_ASSERT(false);
17973 : return NULL;
17974 : }
17975 : }
17976 : size_t
17977 0 : SgIorAssignOp::get_childIndex(SgNode *child) {
17978 0 : if (child == p_lhs_operand_i) return 0;
17979 0 : else if (child == p_rhs_operand_i) return 1;
17980 0 : else return (size_t) -1;
17981 : }
17982 : vector<SgNode*>
17983 148 : SgMultAssignOp::get_traversalSuccessorContainer() {
17984 148 : vector<SgNode*> traversalSuccessorContainer;
17985 148 : traversalSuccessorContainer.reserve(2);
17986 148 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
17987 148 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
17988 148 : return traversalSuccessorContainer;
17989 : }
17990 : vector<string>
17991 40 : SgMultAssignOp::get_traversalSuccessorNamesContainer() {
17992 40 : vector<string> traversalSuccessorContainer;
17993 80 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
17994 80 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
17995 40 : return traversalSuccessorContainer;
17996 : }
17997 : size_t
17998 1092 : SgMultAssignOp::get_numberOfTraversalSuccessors() {
17999 1092 : return 2;
18000 : }
18001 : SgNode *
18002 2184 : SgMultAssignOp::get_traversalSuccessorByIndex(size_t idx) {
18003 2184 : switch (idx) {
18004 1092 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18005 1092 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18006 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18007 0 : ROSE_ASSERT(false);
18008 : return NULL;
18009 : }
18010 : }
18011 : size_t
18012 0 : SgMultAssignOp::get_childIndex(SgNode *child) {
18013 0 : if (child == p_lhs_operand_i) return 0;
18014 0 : else if (child == p_rhs_operand_i) return 1;
18015 0 : else return (size_t) -1;
18016 : }
18017 : vector<SgNode*>
18018 46 : SgDivAssignOp::get_traversalSuccessorContainer() {
18019 46 : vector<SgNode*> traversalSuccessorContainer;
18020 46 : traversalSuccessorContainer.reserve(2);
18021 46 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18022 46 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18023 46 : return traversalSuccessorContainer;
18024 : }
18025 : vector<string>
18026 12 : SgDivAssignOp::get_traversalSuccessorNamesContainer() {
18027 12 : vector<string> traversalSuccessorContainer;
18028 24 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18029 24 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18030 12 : return traversalSuccessorContainer;
18031 : }
18032 : size_t
18033 348 : SgDivAssignOp::get_numberOfTraversalSuccessors() {
18034 348 : return 2;
18035 : }
18036 : SgNode *
18037 696 : SgDivAssignOp::get_traversalSuccessorByIndex(size_t idx) {
18038 696 : switch (idx) {
18039 348 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18040 348 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18041 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18042 0 : ROSE_ASSERT(false);
18043 : return NULL;
18044 : }
18045 : }
18046 : size_t
18047 0 : SgDivAssignOp::get_childIndex(SgNode *child) {
18048 0 : if (child == p_lhs_operand_i) return 0;
18049 0 : else if (child == p_rhs_operand_i) return 1;
18050 0 : else return (size_t) -1;
18051 : }
18052 : vector<SgNode*>
18053 0 : SgModAssignOp::get_traversalSuccessorContainer() {
18054 0 : vector<SgNode*> traversalSuccessorContainer;
18055 0 : traversalSuccessorContainer.reserve(2);
18056 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18057 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18058 0 : return traversalSuccessorContainer;
18059 : }
18060 : vector<string>
18061 0 : SgModAssignOp::get_traversalSuccessorNamesContainer() {
18062 0 : vector<string> traversalSuccessorContainer;
18063 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18064 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18065 0 : return traversalSuccessorContainer;
18066 : }
18067 : size_t
18068 0 : SgModAssignOp::get_numberOfTraversalSuccessors() {
18069 0 : return 2;
18070 : }
18071 : SgNode *
18072 0 : SgModAssignOp::get_traversalSuccessorByIndex(size_t idx) {
18073 0 : switch (idx) {
18074 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18075 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18076 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18077 0 : ROSE_ASSERT(false);
18078 : return NULL;
18079 : }
18080 : }
18081 : size_t
18082 0 : SgModAssignOp::get_childIndex(SgNode *child) {
18083 0 : if (child == p_lhs_operand_i) return 0;
18084 0 : else if (child == p_rhs_operand_i) return 1;
18085 0 : else return (size_t) -1;
18086 : }
18087 : vector<SgNode*>
18088 593 : SgXorAssignOp::get_traversalSuccessorContainer() {
18089 593 : vector<SgNode*> traversalSuccessorContainer;
18090 593 : traversalSuccessorContainer.reserve(2);
18091 593 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18092 593 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18093 593 : return traversalSuccessorContainer;
18094 : }
18095 : vector<string>
18096 2 : SgXorAssignOp::get_traversalSuccessorNamesContainer() {
18097 2 : vector<string> traversalSuccessorContainer;
18098 4 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18099 4 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18100 2 : return traversalSuccessorContainer;
18101 : }
18102 : size_t
18103 686 : SgXorAssignOp::get_numberOfTraversalSuccessors() {
18104 686 : return 2;
18105 : }
18106 : SgNode *
18107 1364 : SgXorAssignOp::get_traversalSuccessorByIndex(size_t idx) {
18108 1364 : switch (idx) {
18109 682 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18110 682 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18111 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18112 0 : ROSE_ASSERT(false);
18113 : return NULL;
18114 : }
18115 : }
18116 : size_t
18117 0 : SgXorAssignOp::get_childIndex(SgNode *child) {
18118 0 : if (child == p_lhs_operand_i) return 0;
18119 0 : else if (child == p_rhs_operand_i) return 1;
18120 0 : else return (size_t) -1;
18121 : }
18122 : vector<SgNode*>
18123 0 : SgLshiftAssignOp::get_traversalSuccessorContainer() {
18124 0 : vector<SgNode*> traversalSuccessorContainer;
18125 0 : traversalSuccessorContainer.reserve(2);
18126 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18127 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18128 0 : return traversalSuccessorContainer;
18129 : }
18130 : vector<string>
18131 0 : SgLshiftAssignOp::get_traversalSuccessorNamesContainer() {
18132 0 : vector<string> traversalSuccessorContainer;
18133 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18134 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18135 0 : return traversalSuccessorContainer;
18136 : }
18137 : size_t
18138 0 : SgLshiftAssignOp::get_numberOfTraversalSuccessors() {
18139 0 : return 2;
18140 : }
18141 : SgNode *
18142 0 : SgLshiftAssignOp::get_traversalSuccessorByIndex(size_t idx) {
18143 0 : switch (idx) {
18144 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18145 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18146 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18147 0 : ROSE_ASSERT(false);
18148 : return NULL;
18149 : }
18150 : }
18151 : size_t
18152 0 : SgLshiftAssignOp::get_childIndex(SgNode *child) {
18153 0 : if (child == p_lhs_operand_i) return 0;
18154 0 : else if (child == p_rhs_operand_i) return 1;
18155 0 : else return (size_t) -1;
18156 : }
18157 : vector<SgNode*>
18158 88 : SgRshiftAssignOp::get_traversalSuccessorContainer() {
18159 88 : vector<SgNode*> traversalSuccessorContainer;
18160 88 : traversalSuccessorContainer.reserve(2);
18161 88 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18162 88 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18163 88 : return traversalSuccessorContainer;
18164 : }
18165 : vector<string>
18166 24 : SgRshiftAssignOp::get_traversalSuccessorNamesContainer() {
18167 24 : vector<string> traversalSuccessorContainer;
18168 48 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18169 48 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18170 24 : return traversalSuccessorContainer;
18171 : }
18172 : size_t
18173 652 : SgRshiftAssignOp::get_numberOfTraversalSuccessors() {
18174 652 : return 2;
18175 : }
18176 : SgNode *
18177 1304 : SgRshiftAssignOp::get_traversalSuccessorByIndex(size_t idx) {
18178 1304 : switch (idx) {
18179 652 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18180 652 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18181 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18182 0 : ROSE_ASSERT(false);
18183 : return NULL;
18184 : }
18185 : }
18186 : size_t
18187 0 : SgRshiftAssignOp::get_childIndex(SgNode *child) {
18188 0 : if (child == p_lhs_operand_i) return 0;
18189 0 : else if (child == p_rhs_operand_i) return 1;
18190 0 : else return (size_t) -1;
18191 : }
18192 : vector<SgNode*>
18193 0 : SgIntegerDivideAssignOp::get_traversalSuccessorContainer() {
18194 0 : vector<SgNode*> traversalSuccessorContainer;
18195 0 : traversalSuccessorContainer.reserve(2);
18196 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18197 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18198 0 : return traversalSuccessorContainer;
18199 : }
18200 : vector<string>
18201 0 : SgIntegerDivideAssignOp::get_traversalSuccessorNamesContainer() {
18202 0 : vector<string> traversalSuccessorContainer;
18203 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18204 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18205 0 : return traversalSuccessorContainer;
18206 : }
18207 : size_t
18208 0 : SgIntegerDivideAssignOp::get_numberOfTraversalSuccessors() {
18209 0 : return 2;
18210 : }
18211 : SgNode *
18212 0 : SgIntegerDivideAssignOp::get_traversalSuccessorByIndex(size_t idx) {
18213 0 : switch (idx) {
18214 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18215 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18216 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18217 0 : ROSE_ASSERT(false);
18218 : return NULL;
18219 : }
18220 : }
18221 : size_t
18222 0 : SgIntegerDivideAssignOp::get_childIndex(SgNode *child) {
18223 0 : if (child == p_lhs_operand_i) return 0;
18224 0 : else if (child == p_rhs_operand_i) return 1;
18225 0 : else return (size_t) -1;
18226 : }
18227 : vector<SgNode*>
18228 0 : SgExponentiationAssignOp::get_traversalSuccessorContainer() {
18229 0 : vector<SgNode*> traversalSuccessorContainer;
18230 0 : traversalSuccessorContainer.reserve(2);
18231 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18232 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18233 0 : return traversalSuccessorContainer;
18234 : }
18235 : vector<string>
18236 0 : SgExponentiationAssignOp::get_traversalSuccessorNamesContainer() {
18237 0 : vector<string> traversalSuccessorContainer;
18238 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18239 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18240 0 : return traversalSuccessorContainer;
18241 : }
18242 : size_t
18243 0 : SgExponentiationAssignOp::get_numberOfTraversalSuccessors() {
18244 0 : return 2;
18245 : }
18246 : SgNode *
18247 0 : SgExponentiationAssignOp::get_traversalSuccessorByIndex(size_t idx) {
18248 0 : switch (idx) {
18249 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18250 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18251 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18252 0 : ROSE_ASSERT(false);
18253 : return NULL;
18254 : }
18255 : }
18256 : size_t
18257 0 : SgExponentiationAssignOp::get_childIndex(SgNode *child) {
18258 0 : if (child == p_lhs_operand_i) return 0;
18259 0 : else if (child == p_rhs_operand_i) return 1;
18260 0 : else return (size_t) -1;
18261 : }
18262 : vector<SgNode*>
18263 0 : SgMembershipOp::get_traversalSuccessorContainer() {
18264 0 : vector<SgNode*> traversalSuccessorContainer;
18265 0 : traversalSuccessorContainer.reserve(2);
18266 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18267 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18268 0 : return traversalSuccessorContainer;
18269 : }
18270 : vector<string>
18271 0 : SgMembershipOp::get_traversalSuccessorNamesContainer() {
18272 0 : vector<string> traversalSuccessorContainer;
18273 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18274 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18275 0 : return traversalSuccessorContainer;
18276 : }
18277 : size_t
18278 0 : SgMembershipOp::get_numberOfTraversalSuccessors() {
18279 0 : return 2;
18280 : }
18281 : SgNode *
18282 0 : SgMembershipOp::get_traversalSuccessorByIndex(size_t idx) {
18283 0 : switch (idx) {
18284 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18285 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18286 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18287 0 : ROSE_ASSERT(false);
18288 : return NULL;
18289 : }
18290 : }
18291 : size_t
18292 0 : SgMembershipOp::get_childIndex(SgNode *child) {
18293 0 : if (child == p_lhs_operand_i) return 0;
18294 0 : else if (child == p_rhs_operand_i) return 1;
18295 0 : else return (size_t) -1;
18296 : }
18297 : vector<SgNode*>
18298 0 : SgSpaceshipOp::get_traversalSuccessorContainer() {
18299 0 : vector<SgNode*> traversalSuccessorContainer;
18300 0 : traversalSuccessorContainer.reserve(2);
18301 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18302 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18303 0 : return traversalSuccessorContainer;
18304 : }
18305 : vector<string>
18306 0 : SgSpaceshipOp::get_traversalSuccessorNamesContainer() {
18307 0 : vector<string> traversalSuccessorContainer;
18308 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18309 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18310 0 : return traversalSuccessorContainer;
18311 : }
18312 : size_t
18313 0 : SgSpaceshipOp::get_numberOfTraversalSuccessors() {
18314 0 : return 2;
18315 : }
18316 : SgNode *
18317 0 : SgSpaceshipOp::get_traversalSuccessorByIndex(size_t idx) {
18318 0 : switch (idx) {
18319 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18320 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18321 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18322 0 : ROSE_ASSERT(false);
18323 : return NULL;
18324 : }
18325 : }
18326 : size_t
18327 0 : SgSpaceshipOp::get_childIndex(SgNode *child) {
18328 0 : if (child == p_lhs_operand_i) return 0;
18329 0 : else if (child == p_rhs_operand_i) return 1;
18330 0 : else return (size_t) -1;
18331 : }
18332 : vector<SgNode*>
18333 0 : SgNonMembershipOp::get_traversalSuccessorContainer() {
18334 0 : vector<SgNode*> traversalSuccessorContainer;
18335 0 : traversalSuccessorContainer.reserve(2);
18336 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18337 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18338 0 : return traversalSuccessorContainer;
18339 : }
18340 : vector<string>
18341 0 : SgNonMembershipOp::get_traversalSuccessorNamesContainer() {
18342 0 : vector<string> traversalSuccessorContainer;
18343 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18344 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18345 0 : return traversalSuccessorContainer;
18346 : }
18347 : size_t
18348 0 : SgNonMembershipOp::get_numberOfTraversalSuccessors() {
18349 0 : return 2;
18350 : }
18351 : SgNode *
18352 0 : SgNonMembershipOp::get_traversalSuccessorByIndex(size_t idx) {
18353 0 : switch (idx) {
18354 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18355 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18356 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18357 0 : ROSE_ASSERT(false);
18358 : return NULL;
18359 : }
18360 : }
18361 : size_t
18362 0 : SgNonMembershipOp::get_childIndex(SgNode *child) {
18363 0 : if (child == p_lhs_operand_i) return 0;
18364 0 : else if (child == p_rhs_operand_i) return 1;
18365 0 : else return (size_t) -1;
18366 : }
18367 : vector<SgNode*>
18368 0 : SgIsOp::get_traversalSuccessorContainer() {
18369 0 : vector<SgNode*> traversalSuccessorContainer;
18370 0 : traversalSuccessorContainer.reserve(2);
18371 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18372 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18373 0 : return traversalSuccessorContainer;
18374 : }
18375 : vector<string>
18376 0 : SgIsOp::get_traversalSuccessorNamesContainer() {
18377 0 : vector<string> traversalSuccessorContainer;
18378 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18379 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18380 0 : return traversalSuccessorContainer;
18381 : }
18382 : size_t
18383 0 : SgIsOp::get_numberOfTraversalSuccessors() {
18384 0 : return 2;
18385 : }
18386 : SgNode *
18387 0 : SgIsOp::get_traversalSuccessorByIndex(size_t idx) {
18388 0 : switch (idx) {
18389 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18390 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18391 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18392 0 : ROSE_ASSERT(false);
18393 : return NULL;
18394 : }
18395 : }
18396 : size_t
18397 0 : SgIsOp::get_childIndex(SgNode *child) {
18398 0 : if (child == p_lhs_operand_i) return 0;
18399 0 : else if (child == p_rhs_operand_i) return 1;
18400 0 : else return (size_t) -1;
18401 : }
18402 : vector<SgNode*>
18403 0 : SgIsNotOp::get_traversalSuccessorContainer() {
18404 0 : vector<SgNode*> traversalSuccessorContainer;
18405 0 : traversalSuccessorContainer.reserve(2);
18406 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18407 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18408 0 : return traversalSuccessorContainer;
18409 : }
18410 : vector<string>
18411 0 : SgIsNotOp::get_traversalSuccessorNamesContainer() {
18412 0 : vector<string> traversalSuccessorContainer;
18413 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18414 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18415 0 : return traversalSuccessorContainer;
18416 : }
18417 : size_t
18418 0 : SgIsNotOp::get_numberOfTraversalSuccessors() {
18419 0 : return 2;
18420 : }
18421 : SgNode *
18422 0 : SgIsNotOp::get_traversalSuccessorByIndex(size_t idx) {
18423 0 : switch (idx) {
18424 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18425 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18426 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18427 0 : ROSE_ASSERT(false);
18428 : return NULL;
18429 : }
18430 : }
18431 : size_t
18432 0 : SgIsNotOp::get_childIndex(SgNode *child) {
18433 0 : if (child == p_lhs_operand_i) return 0;
18434 0 : else if (child == p_rhs_operand_i) return 1;
18435 0 : else return (size_t) -1;
18436 : }
18437 : vector<SgNode*>
18438 0 : SgElementwiseOp::get_traversalSuccessorContainer() {
18439 0 : vector<SgNode*> traversalSuccessorContainer;
18440 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
18441 0 : << "static: SgElementwiseOp" << endl << "dynamic: " << this->sage_class_name() << endl;
18442 0 : cerr << "Aborting ..." << endl;
18443 0 : ROSE_ASSERT(false);
18444 : return traversalSuccessorContainer;
18445 : }
18446 :
18447 : vector<string>
18448 0 : SgElementwiseOp::get_traversalSuccessorNamesContainer() {
18449 0 : vector<string> traversalSuccessorContainer;
18450 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
18451 0 : << "static: SgElementwiseOp" << endl << "dynamic: " << this->sage_class_name() << endl;
18452 0 : cerr << "Aborting ..." << endl;
18453 0 : ROSE_ASSERT(false);
18454 : return traversalSuccessorContainer;
18455 : }
18456 :
18457 : size_t
18458 0 : SgElementwiseOp::get_numberOfTraversalSuccessors() {
18459 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
18460 0 : << "static: SgElementwiseOp" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
18461 0 : cerr << "Aborting ..." << endl;
18462 0 : ROSE_ASSERT(false);
18463 : return 42;
18464 : }
18465 :
18466 : SgNode*
18467 0 : SgElementwiseOp::get_traversalSuccessorByIndex(size_t) {
18468 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
18469 0 : << "static: SgElementwiseOp" << endl << "dynamic: " << this->sage_class_name() << endl;
18470 0 : cerr << "Aborting ..." << endl;
18471 0 : ROSE_ASSERT(false);
18472 : return NULL;
18473 : }
18474 :
18475 : size_t
18476 0 : SgElementwiseOp::get_childIndex(SgNode *) {
18477 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
18478 0 : << "static: SgElementwiseOp" << endl << "dynamic: " << this->sage_class_name() << endl;
18479 0 : cerr << "Aborting ..." << endl;
18480 0 : ROSE_ASSERT(false);
18481 : return 42;
18482 : }
18483 :
18484 : vector<SgNode*>
18485 0 : SgElementwiseMultiplyOp::get_traversalSuccessorContainer() {
18486 0 : vector<SgNode*> traversalSuccessorContainer;
18487 0 : traversalSuccessorContainer.reserve(2);
18488 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18489 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18490 0 : return traversalSuccessorContainer;
18491 : }
18492 : vector<string>
18493 0 : SgElementwiseMultiplyOp::get_traversalSuccessorNamesContainer() {
18494 0 : vector<string> traversalSuccessorContainer;
18495 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18496 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18497 0 : return traversalSuccessorContainer;
18498 : }
18499 : size_t
18500 0 : SgElementwiseMultiplyOp::get_numberOfTraversalSuccessors() {
18501 0 : return 2;
18502 : }
18503 : SgNode *
18504 0 : SgElementwiseMultiplyOp::get_traversalSuccessorByIndex(size_t idx) {
18505 0 : switch (idx) {
18506 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18507 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18508 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18509 0 : ROSE_ASSERT(false);
18510 : return NULL;
18511 : }
18512 : }
18513 : size_t
18514 0 : SgElementwiseMultiplyOp::get_childIndex(SgNode *child) {
18515 0 : if (child == p_lhs_operand_i) return 0;
18516 0 : else if (child == p_rhs_operand_i) return 1;
18517 0 : else return (size_t) -1;
18518 : }
18519 : vector<SgNode*>
18520 0 : SgElementwisePowerOp::get_traversalSuccessorContainer() {
18521 0 : vector<SgNode*> traversalSuccessorContainer;
18522 0 : traversalSuccessorContainer.reserve(2);
18523 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18524 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18525 0 : return traversalSuccessorContainer;
18526 : }
18527 : vector<string>
18528 0 : SgElementwisePowerOp::get_traversalSuccessorNamesContainer() {
18529 0 : vector<string> traversalSuccessorContainer;
18530 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18531 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18532 0 : return traversalSuccessorContainer;
18533 : }
18534 : size_t
18535 0 : SgElementwisePowerOp::get_numberOfTraversalSuccessors() {
18536 0 : return 2;
18537 : }
18538 : SgNode *
18539 0 : SgElementwisePowerOp::get_traversalSuccessorByIndex(size_t idx) {
18540 0 : switch (idx) {
18541 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18542 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18543 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18544 0 : ROSE_ASSERT(false);
18545 : return NULL;
18546 : }
18547 : }
18548 : size_t
18549 0 : SgElementwisePowerOp::get_childIndex(SgNode *child) {
18550 0 : if (child == p_lhs_operand_i) return 0;
18551 0 : else if (child == p_rhs_operand_i) return 1;
18552 0 : else return (size_t) -1;
18553 : }
18554 : vector<SgNode*>
18555 0 : SgElementwiseLeftDivideOp::get_traversalSuccessorContainer() {
18556 0 : vector<SgNode*> traversalSuccessorContainer;
18557 0 : traversalSuccessorContainer.reserve(2);
18558 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18559 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18560 0 : return traversalSuccessorContainer;
18561 : }
18562 : vector<string>
18563 0 : SgElementwiseLeftDivideOp::get_traversalSuccessorNamesContainer() {
18564 0 : vector<string> traversalSuccessorContainer;
18565 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18566 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18567 0 : return traversalSuccessorContainer;
18568 : }
18569 : size_t
18570 0 : SgElementwiseLeftDivideOp::get_numberOfTraversalSuccessors() {
18571 0 : return 2;
18572 : }
18573 : SgNode *
18574 0 : SgElementwiseLeftDivideOp::get_traversalSuccessorByIndex(size_t idx) {
18575 0 : switch (idx) {
18576 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18577 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18578 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18579 0 : ROSE_ASSERT(false);
18580 : return NULL;
18581 : }
18582 : }
18583 : size_t
18584 0 : SgElementwiseLeftDivideOp::get_childIndex(SgNode *child) {
18585 0 : if (child == p_lhs_operand_i) return 0;
18586 0 : else if (child == p_rhs_operand_i) return 1;
18587 0 : else return (size_t) -1;
18588 : }
18589 : vector<SgNode*>
18590 0 : SgElementwiseDivideOp::get_traversalSuccessorContainer() {
18591 0 : vector<SgNode*> traversalSuccessorContainer;
18592 0 : traversalSuccessorContainer.reserve(2);
18593 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18594 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18595 0 : return traversalSuccessorContainer;
18596 : }
18597 : vector<string>
18598 0 : SgElementwiseDivideOp::get_traversalSuccessorNamesContainer() {
18599 0 : vector<string> traversalSuccessorContainer;
18600 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18601 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18602 0 : return traversalSuccessorContainer;
18603 : }
18604 : size_t
18605 0 : SgElementwiseDivideOp::get_numberOfTraversalSuccessors() {
18606 0 : return 2;
18607 : }
18608 : SgNode *
18609 0 : SgElementwiseDivideOp::get_traversalSuccessorByIndex(size_t idx) {
18610 0 : switch (idx) {
18611 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18612 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18613 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18614 0 : ROSE_ASSERT(false);
18615 : return NULL;
18616 : }
18617 : }
18618 : size_t
18619 0 : SgElementwiseDivideOp::get_childIndex(SgNode *child) {
18620 0 : if (child == p_lhs_operand_i) return 0;
18621 0 : else if (child == p_rhs_operand_i) return 1;
18622 0 : else return (size_t) -1;
18623 : }
18624 : vector<SgNode*>
18625 0 : SgElementwiseAddOp::get_traversalSuccessorContainer() {
18626 0 : vector<SgNode*> traversalSuccessorContainer;
18627 0 : traversalSuccessorContainer.reserve(2);
18628 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18629 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18630 0 : return traversalSuccessorContainer;
18631 : }
18632 : vector<string>
18633 0 : SgElementwiseAddOp::get_traversalSuccessorNamesContainer() {
18634 0 : vector<string> traversalSuccessorContainer;
18635 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18636 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18637 0 : return traversalSuccessorContainer;
18638 : }
18639 : size_t
18640 0 : SgElementwiseAddOp::get_numberOfTraversalSuccessors() {
18641 0 : return 2;
18642 : }
18643 : SgNode *
18644 0 : SgElementwiseAddOp::get_traversalSuccessorByIndex(size_t idx) {
18645 0 : switch (idx) {
18646 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18647 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18648 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18649 0 : ROSE_ASSERT(false);
18650 : return NULL;
18651 : }
18652 : }
18653 : size_t
18654 0 : SgElementwiseAddOp::get_childIndex(SgNode *child) {
18655 0 : if (child == p_lhs_operand_i) return 0;
18656 0 : else if (child == p_rhs_operand_i) return 1;
18657 0 : else return (size_t) -1;
18658 : }
18659 : vector<SgNode*>
18660 0 : SgElementwiseSubtractOp::get_traversalSuccessorContainer() {
18661 0 : vector<SgNode*> traversalSuccessorContainer;
18662 0 : traversalSuccessorContainer.reserve(2);
18663 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18664 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18665 0 : return traversalSuccessorContainer;
18666 : }
18667 : vector<string>
18668 0 : SgElementwiseSubtractOp::get_traversalSuccessorNamesContainer() {
18669 0 : vector<string> traversalSuccessorContainer;
18670 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18671 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18672 0 : return traversalSuccessorContainer;
18673 : }
18674 : size_t
18675 0 : SgElementwiseSubtractOp::get_numberOfTraversalSuccessors() {
18676 0 : return 2;
18677 : }
18678 : SgNode *
18679 0 : SgElementwiseSubtractOp::get_traversalSuccessorByIndex(size_t idx) {
18680 0 : switch (idx) {
18681 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18682 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18683 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18684 0 : ROSE_ASSERT(false);
18685 : return NULL;
18686 : }
18687 : }
18688 : size_t
18689 0 : SgElementwiseSubtractOp::get_childIndex(SgNode *child) {
18690 0 : if (child == p_lhs_operand_i) return 0;
18691 0 : else if (child == p_rhs_operand_i) return 1;
18692 0 : else return (size_t) -1;
18693 : }
18694 : vector<SgNode*>
18695 0 : SgPowerOp::get_traversalSuccessorContainer() {
18696 0 : vector<SgNode*> traversalSuccessorContainer;
18697 0 : traversalSuccessorContainer.reserve(2);
18698 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18699 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18700 0 : return traversalSuccessorContainer;
18701 : }
18702 : vector<string>
18703 0 : SgPowerOp::get_traversalSuccessorNamesContainer() {
18704 0 : vector<string> traversalSuccessorContainer;
18705 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18706 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18707 0 : return traversalSuccessorContainer;
18708 : }
18709 : size_t
18710 0 : SgPowerOp::get_numberOfTraversalSuccessors() {
18711 0 : return 2;
18712 : }
18713 : SgNode *
18714 0 : SgPowerOp::get_traversalSuccessorByIndex(size_t idx) {
18715 0 : switch (idx) {
18716 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18717 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18718 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18719 0 : ROSE_ASSERT(false);
18720 : return NULL;
18721 : }
18722 : }
18723 : size_t
18724 0 : SgPowerOp::get_childIndex(SgNode *child) {
18725 0 : if (child == p_lhs_operand_i) return 0;
18726 0 : else if (child == p_rhs_operand_i) return 1;
18727 0 : else return (size_t) -1;
18728 : }
18729 : vector<SgNode*>
18730 0 : SgLeftDivideOp::get_traversalSuccessorContainer() {
18731 0 : vector<SgNode*> traversalSuccessorContainer;
18732 0 : traversalSuccessorContainer.reserve(2);
18733 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18734 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18735 0 : return traversalSuccessorContainer;
18736 : }
18737 : vector<string>
18738 0 : SgLeftDivideOp::get_traversalSuccessorNamesContainer() {
18739 0 : vector<string> traversalSuccessorContainer;
18740 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18741 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18742 0 : return traversalSuccessorContainer;
18743 : }
18744 : size_t
18745 0 : SgLeftDivideOp::get_numberOfTraversalSuccessors() {
18746 0 : return 2;
18747 : }
18748 : SgNode *
18749 0 : SgLeftDivideOp::get_traversalSuccessorByIndex(size_t idx) {
18750 0 : switch (idx) {
18751 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18752 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18753 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18754 0 : ROSE_ASSERT(false);
18755 : return NULL;
18756 : }
18757 : }
18758 : size_t
18759 0 : SgLeftDivideOp::get_childIndex(SgNode *child) {
18760 0 : if (child == p_lhs_operand_i) return 0;
18761 0 : else if (child == p_rhs_operand_i) return 1;
18762 0 : else return (size_t) -1;
18763 : }
18764 : vector<SgNode*>
18765 0 : SgSIMDBinaryOp::get_traversalSuccessorContainer() {
18766 0 : vector<SgNode*> traversalSuccessorContainer;
18767 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
18768 0 : << "static: SgSIMDBinaryOp" << endl << "dynamic: " << this->sage_class_name() << endl;
18769 0 : cerr << "Aborting ..." << endl;
18770 0 : ROSE_ASSERT(false);
18771 : return traversalSuccessorContainer;
18772 : }
18773 :
18774 : vector<string>
18775 0 : SgSIMDBinaryOp::get_traversalSuccessorNamesContainer() {
18776 0 : vector<string> traversalSuccessorContainer;
18777 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
18778 0 : << "static: SgSIMDBinaryOp" << endl << "dynamic: " << this->sage_class_name() << endl;
18779 0 : cerr << "Aborting ..." << endl;
18780 0 : ROSE_ASSERT(false);
18781 : return traversalSuccessorContainer;
18782 : }
18783 :
18784 : size_t
18785 0 : SgSIMDBinaryOp::get_numberOfTraversalSuccessors() {
18786 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
18787 0 : << "static: SgSIMDBinaryOp" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
18788 0 : cerr << "Aborting ..." << endl;
18789 0 : ROSE_ASSERT(false);
18790 : return 42;
18791 : }
18792 :
18793 : SgNode*
18794 0 : SgSIMDBinaryOp::get_traversalSuccessorByIndex(size_t) {
18795 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
18796 0 : << "static: SgSIMDBinaryOp" << endl << "dynamic: " << this->sage_class_name() << endl;
18797 0 : cerr << "Aborting ..." << endl;
18798 0 : ROSE_ASSERT(false);
18799 : return NULL;
18800 : }
18801 :
18802 : size_t
18803 0 : SgSIMDBinaryOp::get_childIndex(SgNode *) {
18804 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
18805 0 : << "static: SgSIMDBinaryOp" << endl << "dynamic: " << this->sage_class_name() << endl;
18806 0 : cerr << "Aborting ..." << endl;
18807 0 : ROSE_ASSERT(false);
18808 : return 42;
18809 : }
18810 :
18811 : vector<SgNode*>
18812 0 : SgSIMDAddOp::get_traversalSuccessorContainer() {
18813 0 : vector<SgNode*> traversalSuccessorContainer;
18814 0 : traversalSuccessorContainer.reserve(2);
18815 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18816 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18817 0 : return traversalSuccessorContainer;
18818 : }
18819 : vector<string>
18820 0 : SgSIMDAddOp::get_traversalSuccessorNamesContainer() {
18821 0 : vector<string> traversalSuccessorContainer;
18822 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18823 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18824 0 : return traversalSuccessorContainer;
18825 : }
18826 : size_t
18827 0 : SgSIMDAddOp::get_numberOfTraversalSuccessors() {
18828 0 : return 2;
18829 : }
18830 : SgNode *
18831 0 : SgSIMDAddOp::get_traversalSuccessorByIndex(size_t idx) {
18832 0 : switch (idx) {
18833 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18834 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18835 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18836 0 : ROSE_ASSERT(false);
18837 : return NULL;
18838 : }
18839 : }
18840 : size_t
18841 0 : SgSIMDAddOp::get_childIndex(SgNode *child) {
18842 0 : if (child == p_lhs_operand_i) return 0;
18843 0 : else if (child == p_rhs_operand_i) return 1;
18844 0 : else return (size_t) -1;
18845 : }
18846 : vector<SgNode*>
18847 0 : SgSIMDSubOp::get_traversalSuccessorContainer() {
18848 0 : vector<SgNode*> traversalSuccessorContainer;
18849 0 : traversalSuccessorContainer.reserve(2);
18850 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18851 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18852 0 : return traversalSuccessorContainer;
18853 : }
18854 : vector<string>
18855 0 : SgSIMDSubOp::get_traversalSuccessorNamesContainer() {
18856 0 : vector<string> traversalSuccessorContainer;
18857 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18858 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18859 0 : return traversalSuccessorContainer;
18860 : }
18861 : size_t
18862 0 : SgSIMDSubOp::get_numberOfTraversalSuccessors() {
18863 0 : return 2;
18864 : }
18865 : SgNode *
18866 0 : SgSIMDSubOp::get_traversalSuccessorByIndex(size_t idx) {
18867 0 : switch (idx) {
18868 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18869 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18870 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18871 0 : ROSE_ASSERT(false);
18872 : return NULL;
18873 : }
18874 : }
18875 : size_t
18876 0 : SgSIMDSubOp::get_childIndex(SgNode *child) {
18877 0 : if (child == p_lhs_operand_i) return 0;
18878 0 : else if (child == p_rhs_operand_i) return 1;
18879 0 : else return (size_t) -1;
18880 : }
18881 : vector<SgNode*>
18882 0 : SgSIMDMulOp::get_traversalSuccessorContainer() {
18883 0 : vector<SgNode*> traversalSuccessorContainer;
18884 0 : traversalSuccessorContainer.reserve(2);
18885 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18886 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18887 0 : return traversalSuccessorContainer;
18888 : }
18889 : vector<string>
18890 0 : SgSIMDMulOp::get_traversalSuccessorNamesContainer() {
18891 0 : vector<string> traversalSuccessorContainer;
18892 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18893 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18894 0 : return traversalSuccessorContainer;
18895 : }
18896 : size_t
18897 0 : SgSIMDMulOp::get_numberOfTraversalSuccessors() {
18898 0 : return 2;
18899 : }
18900 : SgNode *
18901 0 : SgSIMDMulOp::get_traversalSuccessorByIndex(size_t idx) {
18902 0 : switch (idx) {
18903 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18904 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18905 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18906 0 : ROSE_ASSERT(false);
18907 : return NULL;
18908 : }
18909 : }
18910 : size_t
18911 0 : SgSIMDMulOp::get_childIndex(SgNode *child) {
18912 0 : if (child == p_lhs_operand_i) return 0;
18913 0 : else if (child == p_rhs_operand_i) return 1;
18914 0 : else return (size_t) -1;
18915 : }
18916 : vector<SgNode*>
18917 0 : SgSIMDDivOp::get_traversalSuccessorContainer() {
18918 0 : vector<SgNode*> traversalSuccessorContainer;
18919 0 : traversalSuccessorContainer.reserve(2);
18920 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18921 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18922 0 : return traversalSuccessorContainer;
18923 : }
18924 : vector<string>
18925 0 : SgSIMDDivOp::get_traversalSuccessorNamesContainer() {
18926 0 : vector<string> traversalSuccessorContainer;
18927 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18928 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18929 0 : return traversalSuccessorContainer;
18930 : }
18931 : size_t
18932 0 : SgSIMDDivOp::get_numberOfTraversalSuccessors() {
18933 0 : return 2;
18934 : }
18935 : SgNode *
18936 0 : SgSIMDDivOp::get_traversalSuccessorByIndex(size_t idx) {
18937 0 : switch (idx) {
18938 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18939 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18940 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18941 0 : ROSE_ASSERT(false);
18942 : return NULL;
18943 : }
18944 : }
18945 : size_t
18946 0 : SgSIMDDivOp::get_childIndex(SgNode *child) {
18947 0 : if (child == p_lhs_operand_i) return 0;
18948 0 : else if (child == p_rhs_operand_i) return 1;
18949 0 : else return (size_t) -1;
18950 : }
18951 : vector<SgNode*>
18952 0 : SgSIMDFmaOp::get_traversalSuccessorContainer() {
18953 0 : vector<SgNode*> traversalSuccessorContainer;
18954 0 : traversalSuccessorContainer.reserve(2);
18955 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18956 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18957 0 : return traversalSuccessorContainer;
18958 : }
18959 : vector<string>
18960 0 : SgSIMDFmaOp::get_traversalSuccessorNamesContainer() {
18961 0 : vector<string> traversalSuccessorContainer;
18962 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18963 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18964 0 : return traversalSuccessorContainer;
18965 : }
18966 : size_t
18967 0 : SgSIMDFmaOp::get_numberOfTraversalSuccessors() {
18968 0 : return 2;
18969 : }
18970 : SgNode *
18971 0 : SgSIMDFmaOp::get_traversalSuccessorByIndex(size_t idx) {
18972 0 : switch (idx) {
18973 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
18974 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
18975 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
18976 0 : ROSE_ASSERT(false);
18977 : return NULL;
18978 : }
18979 : }
18980 : size_t
18981 0 : SgSIMDFmaOp::get_childIndex(SgNode *child) {
18982 0 : if (child == p_lhs_operand_i) return 0;
18983 0 : else if (child == p_rhs_operand_i) return 1;
18984 0 : else return (size_t) -1;
18985 : }
18986 : vector<SgNode*>
18987 0 : SgSIMDLoad::get_traversalSuccessorContainer() {
18988 0 : vector<SgNode*> traversalSuccessorContainer;
18989 0 : traversalSuccessorContainer.reserve(2);
18990 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
18991 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
18992 0 : return traversalSuccessorContainer;
18993 : }
18994 : vector<string>
18995 0 : SgSIMDLoad::get_traversalSuccessorNamesContainer() {
18996 0 : vector<string> traversalSuccessorContainer;
18997 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
18998 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
18999 0 : return traversalSuccessorContainer;
19000 : }
19001 : size_t
19002 0 : SgSIMDLoad::get_numberOfTraversalSuccessors() {
19003 0 : return 2;
19004 : }
19005 : SgNode *
19006 0 : SgSIMDLoad::get_traversalSuccessorByIndex(size_t idx) {
19007 0 : switch (idx) {
19008 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
19009 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
19010 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
19011 0 : ROSE_ASSERT(false);
19012 : return NULL;
19013 : }
19014 : }
19015 : size_t
19016 0 : SgSIMDLoad::get_childIndex(SgNode *child) {
19017 0 : if (child == p_lhs_operand_i) return 0;
19018 0 : else if (child == p_rhs_operand_i) return 1;
19019 0 : else return (size_t) -1;
19020 : }
19021 : vector<SgNode*>
19022 0 : SgSIMDBroadcast::get_traversalSuccessorContainer() {
19023 0 : vector<SgNode*> traversalSuccessorContainer;
19024 0 : traversalSuccessorContainer.reserve(2);
19025 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
19026 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
19027 0 : return traversalSuccessorContainer;
19028 : }
19029 : vector<string>
19030 0 : SgSIMDBroadcast::get_traversalSuccessorNamesContainer() {
19031 0 : vector<string> traversalSuccessorContainer;
19032 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
19033 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
19034 0 : return traversalSuccessorContainer;
19035 : }
19036 : size_t
19037 0 : SgSIMDBroadcast::get_numberOfTraversalSuccessors() {
19038 0 : return 2;
19039 : }
19040 : SgNode *
19041 0 : SgSIMDBroadcast::get_traversalSuccessorByIndex(size_t idx) {
19042 0 : switch (idx) {
19043 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
19044 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
19045 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
19046 0 : ROSE_ASSERT(false);
19047 : return NULL;
19048 : }
19049 : }
19050 : size_t
19051 0 : SgSIMDBroadcast::get_childIndex(SgNode *child) {
19052 0 : if (child == p_lhs_operand_i) return 0;
19053 0 : else if (child == p_rhs_operand_i) return 1;
19054 0 : else return (size_t) -1;
19055 : }
19056 : vector<SgNode*>
19057 0 : SgSIMDStore::get_traversalSuccessorContainer() {
19058 0 : vector<SgNode*> traversalSuccessorContainer;
19059 0 : traversalSuccessorContainer.reserve(2);
19060 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
19061 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
19062 0 : return traversalSuccessorContainer;
19063 : }
19064 : vector<string>
19065 0 : SgSIMDStore::get_traversalSuccessorNamesContainer() {
19066 0 : vector<string> traversalSuccessorContainer;
19067 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
19068 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
19069 0 : return traversalSuccessorContainer;
19070 : }
19071 : size_t
19072 0 : SgSIMDStore::get_numberOfTraversalSuccessors() {
19073 0 : return 2;
19074 : }
19075 : SgNode *
19076 0 : SgSIMDStore::get_traversalSuccessorByIndex(size_t idx) {
19077 0 : switch (idx) {
19078 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
19079 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
19080 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
19081 0 : ROSE_ASSERT(false);
19082 : return NULL;
19083 : }
19084 : }
19085 : size_t
19086 0 : SgSIMDStore::get_childIndex(SgNode *child) {
19087 0 : if (child == p_lhs_operand_i) return 0;
19088 0 : else if (child == p_rhs_operand_i) return 1;
19089 0 : else return (size_t) -1;
19090 : }
19091 : vector<SgNode*>
19092 0 : SgSIMDPartialStore::get_traversalSuccessorContainer() {
19093 0 : vector<SgNode*> traversalSuccessorContainer;
19094 0 : traversalSuccessorContainer.reserve(2);
19095 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
19096 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
19097 0 : return traversalSuccessorContainer;
19098 : }
19099 : vector<string>
19100 0 : SgSIMDPartialStore::get_traversalSuccessorNamesContainer() {
19101 0 : vector<string> traversalSuccessorContainer;
19102 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
19103 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
19104 0 : return traversalSuccessorContainer;
19105 : }
19106 : size_t
19107 0 : SgSIMDPartialStore::get_numberOfTraversalSuccessors() {
19108 0 : return 2;
19109 : }
19110 : SgNode *
19111 0 : SgSIMDPartialStore::get_traversalSuccessorByIndex(size_t idx) {
19112 0 : switch (idx) {
19113 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
19114 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
19115 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
19116 0 : ROSE_ASSERT(false);
19117 : return NULL;
19118 : }
19119 : }
19120 : size_t
19121 0 : SgSIMDPartialStore::get_childIndex(SgNode *child) {
19122 0 : if (child == p_lhs_operand_i) return 0;
19123 0 : else if (child == p_rhs_operand_i) return 1;
19124 0 : else return (size_t) -1;
19125 : }
19126 : vector<SgNode*>
19127 0 : SgSIMDScalarStore::get_traversalSuccessorContainer() {
19128 0 : vector<SgNode*> traversalSuccessorContainer;
19129 0 : traversalSuccessorContainer.reserve(2);
19130 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
19131 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
19132 0 : return traversalSuccessorContainer;
19133 : }
19134 : vector<string>
19135 0 : SgSIMDScalarStore::get_traversalSuccessorNamesContainer() {
19136 0 : vector<string> traversalSuccessorContainer;
19137 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
19138 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
19139 0 : return traversalSuccessorContainer;
19140 : }
19141 : size_t
19142 0 : SgSIMDScalarStore::get_numberOfTraversalSuccessors() {
19143 0 : return 2;
19144 : }
19145 : SgNode *
19146 0 : SgSIMDScalarStore::get_traversalSuccessorByIndex(size_t idx) {
19147 0 : switch (idx) {
19148 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
19149 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
19150 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
19151 0 : ROSE_ASSERT(false);
19152 : return NULL;
19153 : }
19154 : }
19155 : size_t
19156 0 : SgSIMDScalarStore::get_childIndex(SgNode *child) {
19157 0 : if (child == p_lhs_operand_i) return 0;
19158 0 : else if (child == p_rhs_operand_i) return 1;
19159 0 : else return (size_t) -1;
19160 : }
19161 : vector<SgNode*>
19162 0 : SgSIMDGather::get_traversalSuccessorContainer() {
19163 0 : vector<SgNode*> traversalSuccessorContainer;
19164 0 : traversalSuccessorContainer.reserve(2);
19165 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
19166 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
19167 0 : return traversalSuccessorContainer;
19168 : }
19169 : vector<string>
19170 0 : SgSIMDGather::get_traversalSuccessorNamesContainer() {
19171 0 : vector<string> traversalSuccessorContainer;
19172 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
19173 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
19174 0 : return traversalSuccessorContainer;
19175 : }
19176 : size_t
19177 0 : SgSIMDGather::get_numberOfTraversalSuccessors() {
19178 0 : return 2;
19179 : }
19180 : SgNode *
19181 0 : SgSIMDGather::get_traversalSuccessorByIndex(size_t idx) {
19182 0 : switch (idx) {
19183 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
19184 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
19185 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
19186 0 : ROSE_ASSERT(false);
19187 : return NULL;
19188 : }
19189 : }
19190 : size_t
19191 0 : SgSIMDGather::get_childIndex(SgNode *child) {
19192 0 : if (child == p_lhs_operand_i) return 0;
19193 0 : else if (child == p_rhs_operand_i) return 1;
19194 0 : else return (size_t) -1;
19195 : }
19196 : vector<SgNode*>
19197 0 : SgSIMDExplicitGather::get_traversalSuccessorContainer() {
19198 0 : vector<SgNode*> traversalSuccessorContainer;
19199 0 : traversalSuccessorContainer.reserve(2);
19200 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
19201 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
19202 0 : return traversalSuccessorContainer;
19203 : }
19204 : vector<string>
19205 0 : SgSIMDExplicitGather::get_traversalSuccessorNamesContainer() {
19206 0 : vector<string> traversalSuccessorContainer;
19207 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
19208 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
19209 0 : return traversalSuccessorContainer;
19210 : }
19211 : size_t
19212 0 : SgSIMDExplicitGather::get_numberOfTraversalSuccessors() {
19213 0 : return 2;
19214 : }
19215 : SgNode *
19216 0 : SgSIMDExplicitGather::get_traversalSuccessorByIndex(size_t idx) {
19217 0 : switch (idx) {
19218 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
19219 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
19220 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
19221 0 : ROSE_ASSERT(false);
19222 : return NULL;
19223 : }
19224 : }
19225 : size_t
19226 0 : SgSIMDExplicitGather::get_childIndex(SgNode *child) {
19227 0 : if (child == p_lhs_operand_i) return 0;
19228 0 : else if (child == p_rhs_operand_i) return 1;
19229 0 : else return (size_t) -1;
19230 : }
19231 : vector<SgNode*>
19232 0 : SgSIMDScatter::get_traversalSuccessorContainer() {
19233 0 : vector<SgNode*> traversalSuccessorContainer;
19234 0 : traversalSuccessorContainer.reserve(2);
19235 0 : traversalSuccessorContainer.push_back(p_lhs_operand_i);
19236 0 : traversalSuccessorContainer.push_back(p_rhs_operand_i);
19237 0 : return traversalSuccessorContainer;
19238 : }
19239 : vector<string>
19240 0 : SgSIMDScatter::get_traversalSuccessorNamesContainer() {
19241 0 : vector<string> traversalSuccessorContainer;
19242 0 : traversalSuccessorContainer.push_back("p_lhs_operand_i");
19243 0 : traversalSuccessorContainer.push_back("p_rhs_operand_i");
19244 0 : return traversalSuccessorContainer;
19245 : }
19246 : size_t
19247 0 : SgSIMDScatter::get_numberOfTraversalSuccessors() {
19248 0 : return 2;
19249 : }
19250 : SgNode *
19251 0 : SgSIMDScatter::get_traversalSuccessorByIndex(size_t idx) {
19252 0 : switch (idx) {
19253 0 : case 0: ROSE_ASSERT(p_lhs_operand_i == NULL || p_lhs_operand_i != NULL); return p_lhs_operand_i;
19254 0 : case 1: ROSE_ASSERT(p_rhs_operand_i == NULL || p_rhs_operand_i != NULL); return p_rhs_operand_i;
19255 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
19256 0 : ROSE_ASSERT(false);
19257 : return NULL;
19258 : }
19259 : }
19260 : size_t
19261 0 : SgSIMDScatter::get_childIndex(SgNode *child) {
19262 0 : if (child == p_lhs_operand_i) return 0;
19263 0 : else if (child == p_rhs_operand_i) return 1;
19264 0 : else return (size_t) -1;
19265 : }
19266 : vector<SgNode*>
19267 1258960 : SgExprListExp::get_traversalSuccessorContainer() {
19268 1258960 : vector<SgNode*> traversalSuccessorContainer;
19269 1258960 : traversalSuccessorContainer.reserve(p_expressions.size() + 0);
19270 1258960 : {
19271 1258960 : SgExpressionPtrList::iterator iter;
19272 2764310 : for (iter = p_expressions.begin(); iter != p_expressions.end(); iter++)
19273 1505350 : traversalSuccessorContainer.push_back(*iter);
19274 : }
19275 1258960 : return traversalSuccessorContainer;
19276 : }
19277 : vector<string>
19278 64860 : SgExprListExp::get_traversalSuccessorNamesContainer() {
19279 64860 : vector<string> traversalSuccessorContainer;
19280 64860 : int i = 0;
19281 64860 : {
19282 64860 : SgExpressionPtrList::iterator iter;
19283 150060 : for (iter = p_expressions.begin(); iter != p_expressions.end(); (iter++,i++)) {
19284 85200 : char buf[20];
19285 85200 : sprintf(buf,"*[%d]",i);
19286 170400 : traversalSuccessorContainer.push_back(buf);
19287 : }
19288 : }
19289 64860 : return traversalSuccessorContainer;
19290 : }
19291 : size_t
19292 2494490 : SgExprListExp::get_numberOfTraversalSuccessors() {
19293 2494490 : return p_expressions.size() + 0;
19294 : }
19295 : SgNode *
19296 2857560 : SgExprListExp::get_traversalSuccessorByIndex(size_t idx) {
19297 2857560 : ROSE_ASSERT(idx < p_expressions.size());
19298 2857560 : return p_expressions[idx];
19299 : }
19300 : size_t
19301 0 : SgExprListExp::get_childIndex(SgNode *child) {
19302 0 : SgExpressionPtrList::iterator itr = find(p_expressions.begin(), p_expressions.end(), child);
19303 0 : if (itr != p_expressions.end()) return itr - p_expressions.begin();
19304 : else return (size_t) -1;
19305 : }
19306 : vector<SgNode*>
19307 0 : SgListExp::get_traversalSuccessorContainer() {
19308 0 : vector<SgNode*> traversalSuccessorContainer;
19309 0 : traversalSuccessorContainer.reserve(p_expressions.size() + 0);
19310 0 : {
19311 0 : SgExpressionPtrList::iterator iter;
19312 0 : for (iter = p_expressions.begin(); iter != p_expressions.end(); iter++)
19313 0 : traversalSuccessorContainer.push_back(*iter);
19314 : }
19315 0 : return traversalSuccessorContainer;
19316 : }
19317 : vector<string>
19318 0 : SgListExp::get_traversalSuccessorNamesContainer() {
19319 0 : vector<string> traversalSuccessorContainer;
19320 0 : int i = 0;
19321 0 : {
19322 0 : SgExpressionPtrList::iterator iter;
19323 0 : for (iter = p_expressions.begin(); iter != p_expressions.end(); (iter++,i++)) {
19324 0 : char buf[20];
19325 0 : sprintf(buf,"*[%d]",i);
19326 0 : traversalSuccessorContainer.push_back(buf);
19327 : }
19328 : }
19329 0 : return traversalSuccessorContainer;
19330 : }
19331 : size_t
19332 0 : SgListExp::get_numberOfTraversalSuccessors() {
19333 0 : return p_expressions.size() + 0;
19334 : }
19335 : SgNode *
19336 0 : SgListExp::get_traversalSuccessorByIndex(size_t idx) {
19337 0 : ROSE_ASSERT(idx < p_expressions.size());
19338 0 : return p_expressions[idx];
19339 : }
19340 : size_t
19341 0 : SgListExp::get_childIndex(SgNode *child) {
19342 0 : SgExpressionPtrList::iterator itr = find(p_expressions.begin(), p_expressions.end(), child);
19343 0 : if (itr != p_expressions.end()) return itr - p_expressions.begin();
19344 : else return (size_t) -1;
19345 : }
19346 : vector<SgNode*>
19347 0 : SgTupleExp::get_traversalSuccessorContainer() {
19348 0 : vector<SgNode*> traversalSuccessorContainer;
19349 0 : traversalSuccessorContainer.reserve(p_expressions.size() + 0);
19350 0 : {
19351 0 : SgExpressionPtrList::iterator iter;
19352 0 : for (iter = p_expressions.begin(); iter != p_expressions.end(); iter++)
19353 0 : traversalSuccessorContainer.push_back(*iter);
19354 : }
19355 0 : return traversalSuccessorContainer;
19356 : }
19357 : vector<string>
19358 0 : SgTupleExp::get_traversalSuccessorNamesContainer() {
19359 0 : vector<string> traversalSuccessorContainer;
19360 0 : int i = 0;
19361 0 : {
19362 0 : SgExpressionPtrList::iterator iter;
19363 0 : for (iter = p_expressions.begin(); iter != p_expressions.end(); (iter++,i++)) {
19364 0 : char buf[20];
19365 0 : sprintf(buf,"*[%d]",i);
19366 0 : traversalSuccessorContainer.push_back(buf);
19367 : }
19368 : }
19369 0 : return traversalSuccessorContainer;
19370 : }
19371 : size_t
19372 0 : SgTupleExp::get_numberOfTraversalSuccessors() {
19373 0 : return p_expressions.size() + 0;
19374 : }
19375 : SgNode *
19376 0 : SgTupleExp::get_traversalSuccessorByIndex(size_t idx) {
19377 0 : ROSE_ASSERT(idx < p_expressions.size());
19378 0 : return p_expressions[idx];
19379 : }
19380 : size_t
19381 0 : SgTupleExp::get_childIndex(SgNode *child) {
19382 0 : SgExpressionPtrList::iterator itr = find(p_expressions.begin(), p_expressions.end(), child);
19383 0 : if (itr != p_expressions.end()) return itr - p_expressions.begin();
19384 : else return (size_t) -1;
19385 : }
19386 : vector<SgNode*>
19387 0 : SgMatrixExp::get_traversalSuccessorContainer() {
19388 0 : vector<SgNode*> traversalSuccessorContainer;
19389 0 : traversalSuccessorContainer.reserve(p_expressions.size() + 0);
19390 0 : {
19391 0 : SgExpressionPtrList::iterator iter;
19392 0 : for (iter = p_expressions.begin(); iter != p_expressions.end(); iter++)
19393 0 : traversalSuccessorContainer.push_back(*iter);
19394 : }
19395 0 : return traversalSuccessorContainer;
19396 : }
19397 : vector<string>
19398 0 : SgMatrixExp::get_traversalSuccessorNamesContainer() {
19399 0 : vector<string> traversalSuccessorContainer;
19400 0 : int i = 0;
19401 0 : {
19402 0 : SgExpressionPtrList::iterator iter;
19403 0 : for (iter = p_expressions.begin(); iter != p_expressions.end(); (iter++,i++)) {
19404 0 : char buf[20];
19405 0 : sprintf(buf,"*[%d]",i);
19406 0 : traversalSuccessorContainer.push_back(buf);
19407 : }
19408 : }
19409 0 : return traversalSuccessorContainer;
19410 : }
19411 : size_t
19412 0 : SgMatrixExp::get_numberOfTraversalSuccessors() {
19413 0 : return p_expressions.size() + 0;
19414 : }
19415 : SgNode *
19416 0 : SgMatrixExp::get_traversalSuccessorByIndex(size_t idx) {
19417 0 : ROSE_ASSERT(idx < p_expressions.size());
19418 0 : return p_expressions[idx];
19419 : }
19420 : size_t
19421 0 : SgMatrixExp::get_childIndex(SgNode *child) {
19422 0 : SgExpressionPtrList::iterator itr = find(p_expressions.begin(), p_expressions.end(), child);
19423 0 : if (itr != p_expressions.end()) return itr - p_expressions.begin();
19424 : else return (size_t) -1;
19425 : }
19426 : vector<SgNode*>
19427 1979480 : SgVarRefExp::get_traversalSuccessorContainer() {
19428 1979480 : vector<SgNode*> traversalSuccessorContainer;
19429 1979480 : return traversalSuccessorContainer;
19430 : }
19431 : vector<string>
19432 94638 : SgVarRefExp::get_traversalSuccessorNamesContainer() {
19433 94638 : vector<string> traversalSuccessorContainer;
19434 94638 : return traversalSuccessorContainer;
19435 : }
19436 : size_t
19437 4413720 : SgVarRefExp::get_numberOfTraversalSuccessors() {
19438 4413720 : return 0;
19439 : }
19440 : SgNode *
19441 0 : SgVarRefExp::get_traversalSuccessorByIndex(size_t idx) {
19442 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgVarRefExp" << " that has no successors!" << endl;
19443 0 : ROSE_ASSERT(false);
19444 : return NULL;
19445 : }
19446 : size_t
19447 0 : SgVarRefExp::get_childIndex(SgNode *child) {
19448 0 : cout << "error: get_childIndex called on node of type " << "SgVarRefExp" << " that has no successors!" << endl;
19449 0 : ROSE_ASSERT(false);
19450 : return 0;
19451 : }
19452 : vector<SgNode*>
19453 0 : SgClassNameRefExp::get_traversalSuccessorContainer() {
19454 0 : vector<SgNode*> traversalSuccessorContainer;
19455 0 : return traversalSuccessorContainer;
19456 : }
19457 : vector<string>
19458 0 : SgClassNameRefExp::get_traversalSuccessorNamesContainer() {
19459 0 : vector<string> traversalSuccessorContainer;
19460 0 : return traversalSuccessorContainer;
19461 : }
19462 : size_t
19463 0 : SgClassNameRefExp::get_numberOfTraversalSuccessors() {
19464 0 : return 0;
19465 : }
19466 : SgNode *
19467 0 : SgClassNameRefExp::get_traversalSuccessorByIndex(size_t idx) {
19468 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgClassNameRefExp" << " that has no successors!" << endl;
19469 0 : ROSE_ASSERT(false);
19470 : return NULL;
19471 : }
19472 : size_t
19473 0 : SgClassNameRefExp::get_childIndex(SgNode *child) {
19474 0 : cout << "error: get_childIndex called on node of type " << "SgClassNameRefExp" << " that has no successors!" << endl;
19475 0 : ROSE_ASSERT(false);
19476 : return 0;
19477 : }
19478 : vector<SgNode*>
19479 246420 : SgFunctionRefExp::get_traversalSuccessorContainer() {
19480 246420 : vector<SgNode*> traversalSuccessorContainer;
19481 246420 : return traversalSuccessorContainer;
19482 : }
19483 : vector<string>
19484 10838 : SgFunctionRefExp::get_traversalSuccessorNamesContainer() {
19485 10838 : vector<string> traversalSuccessorContainer;
19486 10838 : return traversalSuccessorContainer;
19487 : }
19488 : size_t
19489 503387 : SgFunctionRefExp::get_numberOfTraversalSuccessors() {
19490 503387 : return 0;
19491 : }
19492 : SgNode *
19493 0 : SgFunctionRefExp::get_traversalSuccessorByIndex(size_t idx) {
19494 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgFunctionRefExp" << " that has no successors!" << endl;
19495 0 : ROSE_ASSERT(false);
19496 : return NULL;
19497 : }
19498 : size_t
19499 0 : SgFunctionRefExp::get_childIndex(SgNode *child) {
19500 0 : cout << "error: get_childIndex called on node of type " << "SgFunctionRefExp" << " that has no successors!" << endl;
19501 0 : ROSE_ASSERT(false);
19502 : return 0;
19503 : }
19504 : vector<SgNode*>
19505 78064 : SgMemberFunctionRefExp::get_traversalSuccessorContainer() {
19506 78064 : vector<SgNode*> traversalSuccessorContainer;
19507 78064 : return traversalSuccessorContainer;
19508 : }
19509 : vector<string>
19510 6706 : SgMemberFunctionRefExp::get_traversalSuccessorNamesContainer() {
19511 6706 : vector<string> traversalSuccessorContainer;
19512 6706 : return traversalSuccessorContainer;
19513 : }
19514 : size_t
19515 254760 : SgMemberFunctionRefExp::get_numberOfTraversalSuccessors() {
19516 254760 : return 0;
19517 : }
19518 : SgNode *
19519 0 : SgMemberFunctionRefExp::get_traversalSuccessorByIndex(size_t idx) {
19520 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgMemberFunctionRefExp" << " that has no successors!" << endl;
19521 0 : ROSE_ASSERT(false);
19522 : return NULL;
19523 : }
19524 : size_t
19525 0 : SgMemberFunctionRefExp::get_childIndex(SgNode *child) {
19526 0 : cout << "error: get_childIndex called on node of type " << "SgMemberFunctionRefExp" << " that has no successors!" << endl;
19527 0 : ROSE_ASSERT(false);
19528 : return 0;
19529 : }
19530 : vector<SgNode*>
19531 0 : SgValueExp::get_traversalSuccessorContainer() {
19532 0 : vector<SgNode*> traversalSuccessorContainer;
19533 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
19534 0 : << "static: SgValueExp" << endl << "dynamic: " << this->sage_class_name() << endl;
19535 0 : cerr << "Aborting ..." << endl;
19536 0 : ROSE_ASSERT(false);
19537 : return traversalSuccessorContainer;
19538 : }
19539 :
19540 : vector<string>
19541 0 : SgValueExp::get_traversalSuccessorNamesContainer() {
19542 0 : vector<string> traversalSuccessorContainer;
19543 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
19544 0 : << "static: SgValueExp" << endl << "dynamic: " << this->sage_class_name() << endl;
19545 0 : cerr << "Aborting ..." << endl;
19546 0 : ROSE_ASSERT(false);
19547 : return traversalSuccessorContainer;
19548 : }
19549 :
19550 : size_t
19551 0 : SgValueExp::get_numberOfTraversalSuccessors() {
19552 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
19553 0 : << "static: SgValueExp" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
19554 0 : cerr << "Aborting ..." << endl;
19555 0 : ROSE_ASSERT(false);
19556 : return 42;
19557 : }
19558 :
19559 : SgNode*
19560 0 : SgValueExp::get_traversalSuccessorByIndex(size_t) {
19561 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
19562 0 : << "static: SgValueExp" << endl << "dynamic: " << this->sage_class_name() << endl;
19563 0 : cerr << "Aborting ..." << endl;
19564 0 : ROSE_ASSERT(false);
19565 : return NULL;
19566 : }
19567 :
19568 : size_t
19569 0 : SgValueExp::get_childIndex(SgNode *) {
19570 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
19571 0 : << "static: SgValueExp" << endl << "dynamic: " << this->sage_class_name() << endl;
19572 0 : cerr << "Aborting ..." << endl;
19573 0 : ROSE_ASSERT(false);
19574 : return 42;
19575 : }
19576 :
19577 : vector<SgNode*>
19578 34736 : SgBoolValExp::get_traversalSuccessorContainer() {
19579 34736 : vector<SgNode*> traversalSuccessorContainer;
19580 34736 : return traversalSuccessorContainer;
19581 : }
19582 : vector<string>
19583 2020 : SgBoolValExp::get_traversalSuccessorNamesContainer() {
19584 2020 : vector<string> traversalSuccessorContainer;
19585 2020 : return traversalSuccessorContainer;
19586 : }
19587 : size_t
19588 93743 : SgBoolValExp::get_numberOfTraversalSuccessors() {
19589 93743 : return 0;
19590 : }
19591 : SgNode *
19592 0 : SgBoolValExp::get_traversalSuccessorByIndex(size_t idx) {
19593 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgBoolValExp" << " that has no successors!" << endl;
19594 0 : ROSE_ASSERT(false);
19595 : return NULL;
19596 : }
19597 : size_t
19598 0 : SgBoolValExp::get_childIndex(SgNode *child) {
19599 0 : cout << "error: get_childIndex called on node of type " << "SgBoolValExp" << " that has no successors!" << endl;
19600 0 : ROSE_ASSERT(false);
19601 : return 0;
19602 : }
19603 : vector<SgNode*>
19604 15072 : SgStringVal::get_traversalSuccessorContainer() {
19605 15072 : vector<SgNode*> traversalSuccessorContainer;
19606 15072 : return traversalSuccessorContainer;
19607 : }
19608 : vector<string>
19609 2336 : SgStringVal::get_traversalSuccessorNamesContainer() {
19610 2336 : vector<string> traversalSuccessorContainer;
19611 2336 : return traversalSuccessorContainer;
19612 : }
19613 : size_t
19614 66303 : SgStringVal::get_numberOfTraversalSuccessors() {
19615 66303 : return 0;
19616 : }
19617 : SgNode *
19618 0 : SgStringVal::get_traversalSuccessorByIndex(size_t idx) {
19619 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgStringVal" << " that has no successors!" << endl;
19620 0 : ROSE_ASSERT(false);
19621 : return NULL;
19622 : }
19623 : size_t
19624 0 : SgStringVal::get_childIndex(SgNode *child) {
19625 0 : cout << "error: get_childIndex called on node of type " << "SgStringVal" << " that has no successors!" << endl;
19626 0 : ROSE_ASSERT(false);
19627 : return 0;
19628 : }
19629 : vector<SgNode*>
19630 37 : SgShortVal::get_traversalSuccessorContainer() {
19631 37 : vector<SgNode*> traversalSuccessorContainer;
19632 37 : return traversalSuccessorContainer;
19633 : }
19634 : vector<string>
19635 4 : SgShortVal::get_traversalSuccessorNamesContainer() {
19636 4 : vector<string> traversalSuccessorContainer;
19637 4 : return traversalSuccessorContainer;
19638 : }
19639 : size_t
19640 402 : SgShortVal::get_numberOfTraversalSuccessors() {
19641 402 : return 0;
19642 : }
19643 : SgNode *
19644 0 : SgShortVal::get_traversalSuccessorByIndex(size_t idx) {
19645 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgShortVal" << " that has no successors!" << endl;
19646 0 : ROSE_ASSERT(false);
19647 : return NULL;
19648 : }
19649 : size_t
19650 0 : SgShortVal::get_childIndex(SgNode *child) {
19651 0 : cout << "error: get_childIndex called on node of type " << "SgShortVal" << " that has no successors!" << endl;
19652 0 : ROSE_ASSERT(false);
19653 : return 0;
19654 : }
19655 : vector<SgNode*>
19656 2216 : SgCharVal::get_traversalSuccessorContainer() {
19657 2216 : vector<SgNode*> traversalSuccessorContainer;
19658 2216 : return traversalSuccessorContainer;
19659 : }
19660 : vector<string>
19661 564 : SgCharVal::get_traversalSuccessorNamesContainer() {
19662 564 : vector<string> traversalSuccessorContainer;
19663 564 : return traversalSuccessorContainer;
19664 : }
19665 : size_t
19666 16500 : SgCharVal::get_numberOfTraversalSuccessors() {
19667 16500 : return 0;
19668 : }
19669 : SgNode *
19670 0 : SgCharVal::get_traversalSuccessorByIndex(size_t idx) {
19671 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgCharVal" << " that has no successors!" << endl;
19672 0 : ROSE_ASSERT(false);
19673 : return NULL;
19674 : }
19675 : size_t
19676 0 : SgCharVal::get_childIndex(SgNode *child) {
19677 0 : cout << "error: get_childIndex called on node of type " << "SgCharVal" << " that has no successors!" << endl;
19678 0 : ROSE_ASSERT(false);
19679 : return 0;
19680 : }
19681 : vector<SgNode*>
19682 4 : SgUnsignedCharVal::get_traversalSuccessorContainer() {
19683 4 : vector<SgNode*> traversalSuccessorContainer;
19684 4 : return traversalSuccessorContainer;
19685 : }
19686 : vector<string>
19687 4 : SgUnsignedCharVal::get_traversalSuccessorNamesContainer() {
19688 4 : vector<string> traversalSuccessorContainer;
19689 4 : return traversalSuccessorContainer;
19690 : }
19691 : size_t
19692 40 : SgUnsignedCharVal::get_numberOfTraversalSuccessors() {
19693 40 : return 0;
19694 : }
19695 : SgNode *
19696 0 : SgUnsignedCharVal::get_traversalSuccessorByIndex(size_t idx) {
19697 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUnsignedCharVal" << " that has no successors!" << endl;
19698 0 : ROSE_ASSERT(false);
19699 : return NULL;
19700 : }
19701 : size_t
19702 0 : SgUnsignedCharVal::get_childIndex(SgNode *child) {
19703 0 : cout << "error: get_childIndex called on node of type " << "SgUnsignedCharVal" << " that has no successors!" << endl;
19704 0 : ROSE_ASSERT(false);
19705 : return 0;
19706 : }
19707 : vector<SgNode*>
19708 10 : SgWcharVal::get_traversalSuccessorContainer() {
19709 10 : vector<SgNode*> traversalSuccessorContainer;
19710 10 : return traversalSuccessorContainer;
19711 : }
19712 : vector<string>
19713 2 : SgWcharVal::get_traversalSuccessorNamesContainer() {
19714 2 : vector<string> traversalSuccessorContainer;
19715 2 : return traversalSuccessorContainer;
19716 : }
19717 : size_t
19718 108 : SgWcharVal::get_numberOfTraversalSuccessors() {
19719 108 : return 0;
19720 : }
19721 : SgNode *
19722 0 : SgWcharVal::get_traversalSuccessorByIndex(size_t idx) {
19723 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgWcharVal" << " that has no successors!" << endl;
19724 0 : ROSE_ASSERT(false);
19725 : return NULL;
19726 : }
19727 : size_t
19728 0 : SgWcharVal::get_childIndex(SgNode *child) {
19729 0 : cout << "error: get_childIndex called on node of type " << "SgWcharVal" << " that has no successors!" << endl;
19730 0 : ROSE_ASSERT(false);
19731 : return 0;
19732 : }
19733 : vector<SgNode*>
19734 221 : SgUnsignedShortVal::get_traversalSuccessorContainer() {
19735 221 : vector<SgNode*> traversalSuccessorContainer;
19736 221 : return traversalSuccessorContainer;
19737 : }
19738 : vector<string>
19739 4 : SgUnsignedShortVal::get_traversalSuccessorNamesContainer() {
19740 4 : vector<string> traversalSuccessorContainer;
19741 4 : return traversalSuccessorContainer;
19742 : }
19743 : size_t
19744 1522 : SgUnsignedShortVal::get_numberOfTraversalSuccessors() {
19745 1522 : return 0;
19746 : }
19747 : SgNode *
19748 0 : SgUnsignedShortVal::get_traversalSuccessorByIndex(size_t idx) {
19749 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUnsignedShortVal" << " that has no successors!" << endl;
19750 0 : ROSE_ASSERT(false);
19751 : return NULL;
19752 : }
19753 : size_t
19754 0 : SgUnsignedShortVal::get_childIndex(SgNode *child) {
19755 0 : cout << "error: get_childIndex called on node of type " << "SgUnsignedShortVal" << " that has no successors!" << endl;
19756 0 : ROSE_ASSERT(false);
19757 : return 0;
19758 : }
19759 : vector<SgNode*>
19760 180937 : SgIntVal::get_traversalSuccessorContainer() {
19761 180937 : vector<SgNode*> traversalSuccessorContainer;
19762 180937 : return traversalSuccessorContainer;
19763 : }
19764 : vector<string>
19765 14174 : SgIntVal::get_traversalSuccessorNamesContainer() {
19766 14174 : vector<string> traversalSuccessorContainer;
19767 14174 : return traversalSuccessorContainer;
19768 : }
19769 : size_t
19770 519619 : SgIntVal::get_numberOfTraversalSuccessors() {
19771 519619 : return 0;
19772 : }
19773 : SgNode *
19774 0 : SgIntVal::get_traversalSuccessorByIndex(size_t idx) {
19775 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgIntVal" << " that has no successors!" << endl;
19776 0 : ROSE_ASSERT(false);
19777 : return NULL;
19778 : }
19779 : size_t
19780 0 : SgIntVal::get_childIndex(SgNode *child) {
19781 0 : cout << "error: get_childIndex called on node of type " << "SgIntVal" << " that has no successors!" << endl;
19782 0 : ROSE_ASSERT(false);
19783 : return 0;
19784 : }
19785 : vector<SgNode*>
19786 69927 : SgEnumVal::get_traversalSuccessorContainer() {
19787 69927 : vector<SgNode*> traversalSuccessorContainer;
19788 69927 : return traversalSuccessorContainer;
19789 : }
19790 : vector<string>
19791 15880 : SgEnumVal::get_traversalSuccessorNamesContainer() {
19792 15880 : vector<string> traversalSuccessorContainer;
19793 15880 : return traversalSuccessorContainer;
19794 : }
19795 : size_t
19796 389122 : SgEnumVal::get_numberOfTraversalSuccessors() {
19797 389122 : return 0;
19798 : }
19799 : SgNode *
19800 0 : SgEnumVal::get_traversalSuccessorByIndex(size_t idx) {
19801 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgEnumVal" << " that has no successors!" << endl;
19802 0 : ROSE_ASSERT(false);
19803 : return NULL;
19804 : }
19805 : size_t
19806 0 : SgEnumVal::get_childIndex(SgNode *child) {
19807 0 : cout << "error: get_childIndex called on node of type " << "SgEnumVal" << " that has no successors!" << endl;
19808 0 : ROSE_ASSERT(false);
19809 : return 0;
19810 : }
19811 : vector<SgNode*>
19812 206 : SgUnsignedIntVal::get_traversalSuccessorContainer() {
19813 206 : vector<SgNode*> traversalSuccessorContainer;
19814 206 : return traversalSuccessorContainer;
19815 : }
19816 : vector<string>
19817 16 : SgUnsignedIntVal::get_traversalSuccessorNamesContainer() {
19818 16 : vector<string> traversalSuccessorContainer;
19819 16 : return traversalSuccessorContainer;
19820 : }
19821 : size_t
19822 2163 : SgUnsignedIntVal::get_numberOfTraversalSuccessors() {
19823 2163 : return 0;
19824 : }
19825 : SgNode *
19826 0 : SgUnsignedIntVal::get_traversalSuccessorByIndex(size_t idx) {
19827 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUnsignedIntVal" << " that has no successors!" << endl;
19828 0 : ROSE_ASSERT(false);
19829 : return NULL;
19830 : }
19831 : size_t
19832 0 : SgUnsignedIntVal::get_childIndex(SgNode *child) {
19833 0 : cout << "error: get_childIndex called on node of type " << "SgUnsignedIntVal" << " that has no successors!" << endl;
19834 0 : ROSE_ASSERT(false);
19835 : return 0;
19836 : }
19837 : vector<SgNode*>
19838 3831 : SgLongIntVal::get_traversalSuccessorContainer() {
19839 3831 : vector<SgNode*> traversalSuccessorContainer;
19840 3831 : return traversalSuccessorContainer;
19841 : }
19842 : vector<string>
19843 160 : SgLongIntVal::get_traversalSuccessorNamesContainer() {
19844 160 : vector<string> traversalSuccessorContainer;
19845 160 : return traversalSuccessorContainer;
19846 : }
19847 : size_t
19848 14695 : SgLongIntVal::get_numberOfTraversalSuccessors() {
19849 14695 : return 0;
19850 : }
19851 : SgNode *
19852 0 : SgLongIntVal::get_traversalSuccessorByIndex(size_t idx) {
19853 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgLongIntVal" << " that has no successors!" << endl;
19854 0 : ROSE_ASSERT(false);
19855 : return NULL;
19856 : }
19857 : size_t
19858 0 : SgLongIntVal::get_childIndex(SgNode *child) {
19859 0 : cout << "error: get_childIndex called on node of type " << "SgLongIntVal" << " that has no successors!" << endl;
19860 0 : ROSE_ASSERT(false);
19861 : return 0;
19862 : }
19863 : vector<SgNode*>
19864 48 : SgLongLongIntVal::get_traversalSuccessorContainer() {
19865 48 : vector<SgNode*> traversalSuccessorContainer;
19866 48 : return traversalSuccessorContainer;
19867 : }
19868 : vector<string>
19869 2 : SgLongLongIntVal::get_traversalSuccessorNamesContainer() {
19870 2 : vector<string> traversalSuccessorContainer;
19871 2 : return traversalSuccessorContainer;
19872 : }
19873 : size_t
19874 608 : SgLongLongIntVal::get_numberOfTraversalSuccessors() {
19875 608 : return 0;
19876 : }
19877 : SgNode *
19878 0 : SgLongLongIntVal::get_traversalSuccessorByIndex(size_t idx) {
19879 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgLongLongIntVal" << " that has no successors!" << endl;
19880 0 : ROSE_ASSERT(false);
19881 : return NULL;
19882 : }
19883 : size_t
19884 0 : SgLongLongIntVal::get_childIndex(SgNode *child) {
19885 0 : cout << "error: get_childIndex called on node of type " << "SgLongLongIntVal" << " that has no successors!" << endl;
19886 0 : ROSE_ASSERT(false);
19887 : return 0;
19888 : }
19889 : vector<SgNode*>
19890 37 : SgUnsignedLongLongIntVal::get_traversalSuccessorContainer() {
19891 37 : vector<SgNode*> traversalSuccessorContainer;
19892 37 : return traversalSuccessorContainer;
19893 : }
19894 : vector<string>
19895 4 : SgUnsignedLongLongIntVal::get_traversalSuccessorNamesContainer() {
19896 4 : vector<string> traversalSuccessorContainer;
19897 4 : return traversalSuccessorContainer;
19898 : }
19899 : size_t
19900 498 : SgUnsignedLongLongIntVal::get_numberOfTraversalSuccessors() {
19901 498 : return 0;
19902 : }
19903 : SgNode *
19904 0 : SgUnsignedLongLongIntVal::get_traversalSuccessorByIndex(size_t idx) {
19905 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUnsignedLongLongIntVal" << " that has no successors!" << endl;
19906 0 : ROSE_ASSERT(false);
19907 : return NULL;
19908 : }
19909 : size_t
19910 0 : SgUnsignedLongLongIntVal::get_childIndex(SgNode *child) {
19911 0 : cout << "error: get_childIndex called on node of type " << "SgUnsignedLongLongIntVal" << " that has no successors!" << endl;
19912 0 : ROSE_ASSERT(false);
19913 : return 0;
19914 : }
19915 : vector<SgNode*>
19916 13819 : SgUnsignedLongVal::get_traversalSuccessorContainer() {
19917 13819 : vector<SgNode*> traversalSuccessorContainer;
19918 13819 : return traversalSuccessorContainer;
19919 : }
19920 : vector<string>
19921 142 : SgUnsignedLongVal::get_traversalSuccessorNamesContainer() {
19922 142 : vector<string> traversalSuccessorContainer;
19923 142 : return traversalSuccessorContainer;
19924 : }
19925 : size_t
19926 34503 : SgUnsignedLongVal::get_numberOfTraversalSuccessors() {
19927 34503 : return 0;
19928 : }
19929 : SgNode *
19930 0 : SgUnsignedLongVal::get_traversalSuccessorByIndex(size_t idx) {
19931 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUnsignedLongVal" << " that has no successors!" << endl;
19932 0 : ROSE_ASSERT(false);
19933 : return NULL;
19934 : }
19935 : size_t
19936 0 : SgUnsignedLongVal::get_childIndex(SgNode *child) {
19937 0 : cout << "error: get_childIndex called on node of type " << "SgUnsignedLongVal" << " that has no successors!" << endl;
19938 0 : ROSE_ASSERT(false);
19939 : return 0;
19940 : }
19941 : vector<SgNode*>
19942 738 : SgFloatVal::get_traversalSuccessorContainer() {
19943 738 : vector<SgNode*> traversalSuccessorContainer;
19944 738 : return traversalSuccessorContainer;
19945 : }
19946 : vector<string>
19947 30 : SgFloatVal::get_traversalSuccessorNamesContainer() {
19948 30 : vector<string> traversalSuccessorContainer;
19949 30 : return traversalSuccessorContainer;
19950 : }
19951 : size_t
19952 2407 : SgFloatVal::get_numberOfTraversalSuccessors() {
19953 2407 : return 0;
19954 : }
19955 : SgNode *
19956 0 : SgFloatVal::get_traversalSuccessorByIndex(size_t idx) {
19957 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgFloatVal" << " that has no successors!" << endl;
19958 0 : ROSE_ASSERT(false);
19959 : return NULL;
19960 : }
19961 : size_t
19962 0 : SgFloatVal::get_childIndex(SgNode *child) {
19963 0 : cout << "error: get_childIndex called on node of type " << "SgFloatVal" << " that has no successors!" << endl;
19964 0 : ROSE_ASSERT(false);
19965 : return 0;
19966 : }
19967 : vector<SgNode*>
19968 20564 : SgDoubleVal::get_traversalSuccessorContainer() {
19969 20564 : vector<SgNode*> traversalSuccessorContainer;
19970 20564 : return traversalSuccessorContainer;
19971 : }
19972 : vector<string>
19973 672 : SgDoubleVal::get_traversalSuccessorNamesContainer() {
19974 672 : vector<string> traversalSuccessorContainer;
19975 672 : return traversalSuccessorContainer;
19976 : }
19977 : size_t
19978 36085 : SgDoubleVal::get_numberOfTraversalSuccessors() {
19979 36085 : return 0;
19980 : }
19981 : SgNode *
19982 0 : SgDoubleVal::get_traversalSuccessorByIndex(size_t idx) {
19983 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgDoubleVal" << " that has no successors!" << endl;
19984 0 : ROSE_ASSERT(false);
19985 : return NULL;
19986 : }
19987 : size_t
19988 0 : SgDoubleVal::get_childIndex(SgNode *child) {
19989 0 : cout << "error: get_childIndex called on node of type " << "SgDoubleVal" << " that has no successors!" << endl;
19990 0 : ROSE_ASSERT(false);
19991 : return 0;
19992 : }
19993 : vector<SgNode*>
19994 34 : SgLongDoubleVal::get_traversalSuccessorContainer() {
19995 34 : vector<SgNode*> traversalSuccessorContainer;
19996 34 : return traversalSuccessorContainer;
19997 : }
19998 : vector<string>
19999 2 : SgLongDoubleVal::get_traversalSuccessorNamesContainer() {
20000 2 : vector<string> traversalSuccessorContainer;
20001 2 : return traversalSuccessorContainer;
20002 : }
20003 : size_t
20004 468 : SgLongDoubleVal::get_numberOfTraversalSuccessors() {
20005 468 : return 0;
20006 : }
20007 : SgNode *
20008 0 : SgLongDoubleVal::get_traversalSuccessorByIndex(size_t idx) {
20009 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgLongDoubleVal" << " that has no successors!" << endl;
20010 0 : ROSE_ASSERT(false);
20011 : return NULL;
20012 : }
20013 : size_t
20014 0 : SgLongDoubleVal::get_childIndex(SgNode *child) {
20015 0 : cout << "error: get_childIndex called on node of type " << "SgLongDoubleVal" << " that has no successors!" << endl;
20016 0 : ROSE_ASSERT(false);
20017 : return 0;
20018 : }
20019 : vector<SgNode*>
20020 8 : SgComplexVal::get_traversalSuccessorContainer() {
20021 8 : vector<SgNode*> traversalSuccessorContainer;
20022 8 : traversalSuccessorContainer.reserve(2);
20023 8 : traversalSuccessorContainer.push_back(p_real_value);
20024 8 : traversalSuccessorContainer.push_back(p_imaginary_value);
20025 8 : return traversalSuccessorContainer;
20026 : }
20027 : vector<string>
20028 8 : SgComplexVal::get_traversalSuccessorNamesContainer() {
20029 8 : vector<string> traversalSuccessorContainer;
20030 16 : traversalSuccessorContainer.push_back("p_real_value");
20031 16 : traversalSuccessorContainer.push_back("p_imaginary_value");
20032 8 : return traversalSuccessorContainer;
20033 : }
20034 : size_t
20035 80 : SgComplexVal::get_numberOfTraversalSuccessors() {
20036 80 : return 2;
20037 : }
20038 : SgNode *
20039 160 : SgComplexVal::get_traversalSuccessorByIndex(size_t idx) {
20040 160 : switch (idx) {
20041 80 : case 0: ROSE_ASSERT(p_real_value == NULL || p_real_value != NULL); return p_real_value;
20042 80 : case 1: ROSE_ASSERT(p_imaginary_value == NULL || p_imaginary_value != NULL); return p_imaginary_value;
20043 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20044 0 : ROSE_ASSERT(false);
20045 : return NULL;
20046 : }
20047 : }
20048 : size_t
20049 0 : SgComplexVal::get_childIndex(SgNode *child) {
20050 0 : if (child == p_real_value) return 0;
20051 0 : else if (child == p_imaginary_value) return 1;
20052 0 : else return (size_t) -1;
20053 : }
20054 : vector<SgNode*>
20055 0 : SgUpcThreads::get_traversalSuccessorContainer() {
20056 0 : vector<SgNode*> traversalSuccessorContainer;
20057 0 : return traversalSuccessorContainer;
20058 : }
20059 : vector<string>
20060 0 : SgUpcThreads::get_traversalSuccessorNamesContainer() {
20061 0 : vector<string> traversalSuccessorContainer;
20062 0 : return traversalSuccessorContainer;
20063 : }
20064 : size_t
20065 0 : SgUpcThreads::get_numberOfTraversalSuccessors() {
20066 0 : return 0;
20067 : }
20068 : SgNode *
20069 0 : SgUpcThreads::get_traversalSuccessorByIndex(size_t idx) {
20070 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUpcThreads" << " that has no successors!" << endl;
20071 0 : ROSE_ASSERT(false);
20072 : return NULL;
20073 : }
20074 : size_t
20075 0 : SgUpcThreads::get_childIndex(SgNode *child) {
20076 0 : cout << "error: get_childIndex called on node of type " << "SgUpcThreads" << " that has no successors!" << endl;
20077 0 : ROSE_ASSERT(false);
20078 : return 0;
20079 : }
20080 : vector<SgNode*>
20081 0 : SgUpcMythread::get_traversalSuccessorContainer() {
20082 0 : vector<SgNode*> traversalSuccessorContainer;
20083 0 : return traversalSuccessorContainer;
20084 : }
20085 : vector<string>
20086 0 : SgUpcMythread::get_traversalSuccessorNamesContainer() {
20087 0 : vector<string> traversalSuccessorContainer;
20088 0 : return traversalSuccessorContainer;
20089 : }
20090 : size_t
20091 0 : SgUpcMythread::get_numberOfTraversalSuccessors() {
20092 0 : return 0;
20093 : }
20094 : SgNode *
20095 0 : SgUpcMythread::get_traversalSuccessorByIndex(size_t idx) {
20096 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgUpcMythread" << " that has no successors!" << endl;
20097 0 : ROSE_ASSERT(false);
20098 : return NULL;
20099 : }
20100 : size_t
20101 0 : SgUpcMythread::get_childIndex(SgNode *child) {
20102 0 : cout << "error: get_childIndex called on node of type " << "SgUpcMythread" << " that has no successors!" << endl;
20103 0 : ROSE_ASSERT(false);
20104 : return 0;
20105 : }
20106 : vector<SgNode*>
20107 0 : SgTemplateParameterVal::get_traversalSuccessorContainer() {
20108 0 : vector<SgNode*> traversalSuccessorContainer;
20109 0 : return traversalSuccessorContainer;
20110 : }
20111 : vector<string>
20112 0 : SgTemplateParameterVal::get_traversalSuccessorNamesContainer() {
20113 0 : vector<string> traversalSuccessorContainer;
20114 0 : return traversalSuccessorContainer;
20115 : }
20116 : size_t
20117 0 : SgTemplateParameterVal::get_numberOfTraversalSuccessors() {
20118 0 : return 0;
20119 : }
20120 : SgNode *
20121 0 : SgTemplateParameterVal::get_traversalSuccessorByIndex(size_t idx) {
20122 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgTemplateParameterVal" << " that has no successors!" << endl;
20123 0 : ROSE_ASSERT(false);
20124 : return NULL;
20125 : }
20126 : size_t
20127 0 : SgTemplateParameterVal::get_childIndex(SgNode *child) {
20128 0 : cout << "error: get_childIndex called on node of type " << "SgTemplateParameterVal" << " that has no successors!" << endl;
20129 0 : ROSE_ASSERT(false);
20130 : return 0;
20131 : }
20132 : vector<SgNode*>
20133 2450 : SgNullptrValExp::get_traversalSuccessorContainer() {
20134 2450 : vector<SgNode*> traversalSuccessorContainer;
20135 2450 : return traversalSuccessorContainer;
20136 : }
20137 : vector<string>
20138 44 : SgNullptrValExp::get_traversalSuccessorNamesContainer() {
20139 44 : vector<string> traversalSuccessorContainer;
20140 44 : return traversalSuccessorContainer;
20141 : }
20142 : size_t
20143 3853 : SgNullptrValExp::get_numberOfTraversalSuccessors() {
20144 3853 : return 0;
20145 : }
20146 : SgNode *
20147 0 : SgNullptrValExp::get_traversalSuccessorByIndex(size_t idx) {
20148 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgNullptrValExp" << " that has no successors!" << endl;
20149 0 : ROSE_ASSERT(false);
20150 : return NULL;
20151 : }
20152 : size_t
20153 0 : SgNullptrValExp::get_childIndex(SgNode *child) {
20154 0 : cout << "error: get_childIndex called on node of type " << "SgNullptrValExp" << " that has no successors!" << endl;
20155 0 : ROSE_ASSERT(false);
20156 : return 0;
20157 : }
20158 : vector<SgNode*>
20159 0 : SgChar16Val::get_traversalSuccessorContainer() {
20160 0 : vector<SgNode*> traversalSuccessorContainer;
20161 0 : return traversalSuccessorContainer;
20162 : }
20163 : vector<string>
20164 0 : SgChar16Val::get_traversalSuccessorNamesContainer() {
20165 0 : vector<string> traversalSuccessorContainer;
20166 0 : return traversalSuccessorContainer;
20167 : }
20168 : size_t
20169 0 : SgChar16Val::get_numberOfTraversalSuccessors() {
20170 0 : return 0;
20171 : }
20172 : SgNode *
20173 0 : SgChar16Val::get_traversalSuccessorByIndex(size_t idx) {
20174 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgChar16Val" << " that has no successors!" << endl;
20175 0 : ROSE_ASSERT(false);
20176 : return NULL;
20177 : }
20178 : size_t
20179 0 : SgChar16Val::get_childIndex(SgNode *child) {
20180 0 : cout << "error: get_childIndex called on node of type " << "SgChar16Val" << " that has no successors!" << endl;
20181 0 : ROSE_ASSERT(false);
20182 : return 0;
20183 : }
20184 : vector<SgNode*>
20185 0 : SgChar32Val::get_traversalSuccessorContainer() {
20186 0 : vector<SgNode*> traversalSuccessorContainer;
20187 0 : return traversalSuccessorContainer;
20188 : }
20189 : vector<string>
20190 0 : SgChar32Val::get_traversalSuccessorNamesContainer() {
20191 0 : vector<string> traversalSuccessorContainer;
20192 0 : return traversalSuccessorContainer;
20193 : }
20194 : size_t
20195 0 : SgChar32Val::get_numberOfTraversalSuccessors() {
20196 0 : return 0;
20197 : }
20198 : SgNode *
20199 0 : SgChar32Val::get_traversalSuccessorByIndex(size_t idx) {
20200 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgChar32Val" << " that has no successors!" << endl;
20201 0 : ROSE_ASSERT(false);
20202 : return NULL;
20203 : }
20204 : size_t
20205 0 : SgChar32Val::get_childIndex(SgNode *child) {
20206 0 : cout << "error: get_childIndex called on node of type " << "SgChar32Val" << " that has no successors!" << endl;
20207 0 : ROSE_ASSERT(false);
20208 : return 0;
20209 : }
20210 : vector<SgNode*>
20211 0 : SgFloat80Val::get_traversalSuccessorContainer() {
20212 0 : vector<SgNode*> traversalSuccessorContainer;
20213 0 : return traversalSuccessorContainer;
20214 : }
20215 : vector<string>
20216 0 : SgFloat80Val::get_traversalSuccessorNamesContainer() {
20217 0 : vector<string> traversalSuccessorContainer;
20218 0 : return traversalSuccessorContainer;
20219 : }
20220 : size_t
20221 0 : SgFloat80Val::get_numberOfTraversalSuccessors() {
20222 0 : return 0;
20223 : }
20224 : SgNode *
20225 0 : SgFloat80Val::get_traversalSuccessorByIndex(size_t idx) {
20226 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgFloat80Val" << " that has no successors!" << endl;
20227 0 : ROSE_ASSERT(false);
20228 : return NULL;
20229 : }
20230 : size_t
20231 0 : SgFloat80Val::get_childIndex(SgNode *child) {
20232 0 : cout << "error: get_childIndex called on node of type " << "SgFloat80Val" << " that has no successors!" << endl;
20233 0 : ROSE_ASSERT(false);
20234 : return 0;
20235 : }
20236 : vector<SgNode*>
20237 0 : SgFloat128Val::get_traversalSuccessorContainer() {
20238 0 : vector<SgNode*> traversalSuccessorContainer;
20239 0 : return traversalSuccessorContainer;
20240 : }
20241 : vector<string>
20242 0 : SgFloat128Val::get_traversalSuccessorNamesContainer() {
20243 0 : vector<string> traversalSuccessorContainer;
20244 0 : return traversalSuccessorContainer;
20245 : }
20246 : size_t
20247 0 : SgFloat128Val::get_numberOfTraversalSuccessors() {
20248 0 : return 0;
20249 : }
20250 : SgNode *
20251 0 : SgFloat128Val::get_traversalSuccessorByIndex(size_t idx) {
20252 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgFloat128Val" << " that has no successors!" << endl;
20253 0 : ROSE_ASSERT(false);
20254 : return NULL;
20255 : }
20256 : size_t
20257 0 : SgFloat128Val::get_childIndex(SgNode *child) {
20258 0 : cout << "error: get_childIndex called on node of type " << "SgFloat128Val" << " that has no successors!" << endl;
20259 0 : ROSE_ASSERT(false);
20260 : return 0;
20261 : }
20262 : vector<SgNode*>
20263 0 : SgVoidVal::get_traversalSuccessorContainer() {
20264 0 : vector<SgNode*> traversalSuccessorContainer;
20265 0 : return traversalSuccessorContainer;
20266 : }
20267 : vector<string>
20268 0 : SgVoidVal::get_traversalSuccessorNamesContainer() {
20269 0 : vector<string> traversalSuccessorContainer;
20270 0 : return traversalSuccessorContainer;
20271 : }
20272 : size_t
20273 0 : SgVoidVal::get_numberOfTraversalSuccessors() {
20274 0 : return 0;
20275 : }
20276 : SgNode *
20277 0 : SgVoidVal::get_traversalSuccessorByIndex(size_t idx) {
20278 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgVoidVal" << " that has no successors!" << endl;
20279 0 : ROSE_ASSERT(false);
20280 : return NULL;
20281 : }
20282 : size_t
20283 0 : SgVoidVal::get_childIndex(SgNode *child) {
20284 0 : cout << "error: get_childIndex called on node of type " << "SgVoidVal" << " that has no successors!" << endl;
20285 0 : ROSE_ASSERT(false);
20286 : return 0;
20287 : }
20288 : vector<SgNode*>
20289 0 : SgCallExpression::get_traversalSuccessorContainer() {
20290 0 : vector<SgNode*> traversalSuccessorContainer;
20291 0 : traversalSuccessorContainer.reserve(2);
20292 0 : traversalSuccessorContainer.push_back(p_function);
20293 0 : traversalSuccessorContainer.push_back(p_args);
20294 0 : return traversalSuccessorContainer;
20295 : }
20296 : vector<string>
20297 0 : SgCallExpression::get_traversalSuccessorNamesContainer() {
20298 0 : vector<string> traversalSuccessorContainer;
20299 0 : traversalSuccessorContainer.push_back("p_function");
20300 0 : traversalSuccessorContainer.push_back("p_args");
20301 0 : return traversalSuccessorContainer;
20302 : }
20303 : size_t
20304 0 : SgCallExpression::get_numberOfTraversalSuccessors() {
20305 0 : return 2;
20306 : }
20307 : SgNode *
20308 0 : SgCallExpression::get_traversalSuccessorByIndex(size_t idx) {
20309 0 : switch (idx) {
20310 0 : case 0: ROSE_ASSERT(p_function == NULL || p_function != NULL); return p_function;
20311 0 : case 1: ROSE_ASSERT(p_args == NULL || p_args != NULL); return p_args;
20312 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20313 0 : ROSE_ASSERT(false);
20314 : return NULL;
20315 : }
20316 : }
20317 : size_t
20318 0 : SgCallExpression::get_childIndex(SgNode *child) {
20319 0 : if (child == p_function) return 0;
20320 0 : else if (child == p_args) return 1;
20321 0 : else return (size_t) -1;
20322 : }
20323 : vector<SgNode*>
20324 1102300 : SgFunctionCallExp::get_traversalSuccessorContainer() {
20325 1102300 : vector<SgNode*> traversalSuccessorContainer;
20326 1102300 : traversalSuccessorContainer.reserve(2);
20327 1102300 : traversalSuccessorContainer.push_back(p_function);
20328 1102300 : traversalSuccessorContainer.push_back(p_args);
20329 1102300 : return traversalSuccessorContainer;
20330 : }
20331 : vector<string>
20332 41864 : SgFunctionCallExp::get_traversalSuccessorNamesContainer() {
20333 41864 : vector<string> traversalSuccessorContainer;
20334 83728 : traversalSuccessorContainer.push_back("p_function");
20335 83728 : traversalSuccessorContainer.push_back("p_args");
20336 41864 : return traversalSuccessorContainer;
20337 : }
20338 : size_t
20339 2117400 : SgFunctionCallExp::get_numberOfTraversalSuccessors() {
20340 2117400 : return 2;
20341 : }
20342 : SgNode *
20343 4222340 : SgFunctionCallExp::get_traversalSuccessorByIndex(size_t idx) {
20344 4222340 : switch (idx) {
20345 2111170 : case 0: ROSE_ASSERT(p_function == NULL || p_function != NULL); return p_function;
20346 2111170 : case 1: ROSE_ASSERT(p_args == NULL || p_args != NULL); return p_args;
20347 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20348 0 : ROSE_ASSERT(false);
20349 : return NULL;
20350 : }
20351 : }
20352 : size_t
20353 0 : SgFunctionCallExp::get_childIndex(SgNode *child) {
20354 0 : if (child == p_function) return 0;
20355 0 : else if (child == p_args) return 1;
20356 0 : else return (size_t) -1;
20357 : }
20358 : vector<SgNode*>
20359 0 : SgCudaKernelCallExp::get_traversalSuccessorContainer() {
20360 0 : vector<SgNode*> traversalSuccessorContainer;
20361 0 : traversalSuccessorContainer.reserve(3);
20362 0 : traversalSuccessorContainer.push_back(p_function);
20363 0 : traversalSuccessorContainer.push_back(p_args);
20364 0 : traversalSuccessorContainer.push_back(p_exec_config);
20365 0 : return traversalSuccessorContainer;
20366 : }
20367 : vector<string>
20368 0 : SgCudaKernelCallExp::get_traversalSuccessorNamesContainer() {
20369 0 : vector<string> traversalSuccessorContainer;
20370 0 : traversalSuccessorContainer.push_back("p_function");
20371 0 : traversalSuccessorContainer.push_back("p_args");
20372 0 : traversalSuccessorContainer.push_back("p_exec_config");
20373 0 : return traversalSuccessorContainer;
20374 : }
20375 : size_t
20376 0 : SgCudaKernelCallExp::get_numberOfTraversalSuccessors() {
20377 0 : return 3;
20378 : }
20379 : SgNode *
20380 0 : SgCudaKernelCallExp::get_traversalSuccessorByIndex(size_t idx) {
20381 0 : switch (idx) {
20382 0 : case 0: ROSE_ASSERT(p_function == NULL || p_function != NULL); return p_function;
20383 0 : case 1: ROSE_ASSERT(p_args == NULL || p_args != NULL); return p_args;
20384 0 : case 2: ROSE_ASSERT(p_exec_config == NULL || p_exec_config != NULL); return p_exec_config;
20385 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20386 0 : ROSE_ASSERT(false);
20387 : return NULL;
20388 : }
20389 : }
20390 : size_t
20391 0 : SgCudaKernelCallExp::get_childIndex(SgNode *child) {
20392 0 : if (child == p_function) return 0;
20393 0 : else if (child == p_args) return 1;
20394 0 : else if (child == p_exec_config) return 2;
20395 0 : else return (size_t) -1;
20396 : }
20397 : vector<SgNode*>
20398 21979 : SgSizeOfOp::get_traversalSuccessorContainer() {
20399 21979 : vector<SgNode*> traversalSuccessorContainer;
20400 21979 : traversalSuccessorContainer.reserve(1);
20401 21979 : traversalSuccessorContainer.push_back(p_operand_expr);
20402 21979 : return traversalSuccessorContainer;
20403 : }
20404 : vector<string>
20405 1268 : SgSizeOfOp::get_traversalSuccessorNamesContainer() {
20406 1268 : vector<string> traversalSuccessorContainer;
20407 2536 : traversalSuccessorContainer.push_back("p_operand_expr");
20408 1268 : return traversalSuccessorContainer;
20409 : }
20410 : size_t
20411 49084 : SgSizeOfOp::get_numberOfTraversalSuccessors() {
20412 49084 : return 1;
20413 : }
20414 : SgNode *
20415 49052 : SgSizeOfOp::get_traversalSuccessorByIndex(size_t idx) {
20416 49052 : switch (idx) {
20417 49052 : case 0: ROSE_ASSERT(p_operand_expr == NULL || p_operand_expr != NULL); return p_operand_expr;
20418 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20419 0 : ROSE_ASSERT(false);
20420 : return NULL;
20421 : }
20422 : }
20423 : size_t
20424 0 : SgSizeOfOp::get_childIndex(SgNode *child) {
20425 0 : if (child == p_operand_expr) return 0;
20426 0 : else return (size_t) -1;
20427 : }
20428 : vector<SgNode*>
20429 0 : SgUpcLocalsizeofExpression::get_traversalSuccessorContainer() {
20430 0 : vector<SgNode*> traversalSuccessorContainer;
20431 0 : traversalSuccessorContainer.reserve(1);
20432 0 : traversalSuccessorContainer.push_back(p_expression);
20433 0 : return traversalSuccessorContainer;
20434 : }
20435 : vector<string>
20436 0 : SgUpcLocalsizeofExpression::get_traversalSuccessorNamesContainer() {
20437 0 : vector<string> traversalSuccessorContainer;
20438 0 : traversalSuccessorContainer.push_back("p_expression");
20439 0 : return traversalSuccessorContainer;
20440 : }
20441 : size_t
20442 0 : SgUpcLocalsizeofExpression::get_numberOfTraversalSuccessors() {
20443 0 : return 1;
20444 : }
20445 : SgNode *
20446 0 : SgUpcLocalsizeofExpression::get_traversalSuccessorByIndex(size_t idx) {
20447 0 : switch (idx) {
20448 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
20449 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20450 0 : ROSE_ASSERT(false);
20451 : return NULL;
20452 : }
20453 : }
20454 : size_t
20455 0 : SgUpcLocalsizeofExpression::get_childIndex(SgNode *child) {
20456 0 : if (child == p_expression) return 0;
20457 0 : else return (size_t) -1;
20458 : }
20459 : vector<SgNode*>
20460 0 : SgUpcBlocksizeofExpression::get_traversalSuccessorContainer() {
20461 0 : vector<SgNode*> traversalSuccessorContainer;
20462 0 : traversalSuccessorContainer.reserve(1);
20463 0 : traversalSuccessorContainer.push_back(p_expression);
20464 0 : return traversalSuccessorContainer;
20465 : }
20466 : vector<string>
20467 0 : SgUpcBlocksizeofExpression::get_traversalSuccessorNamesContainer() {
20468 0 : vector<string> traversalSuccessorContainer;
20469 0 : traversalSuccessorContainer.push_back("p_expression");
20470 0 : return traversalSuccessorContainer;
20471 : }
20472 : size_t
20473 0 : SgUpcBlocksizeofExpression::get_numberOfTraversalSuccessors() {
20474 0 : return 1;
20475 : }
20476 : SgNode *
20477 0 : SgUpcBlocksizeofExpression::get_traversalSuccessorByIndex(size_t idx) {
20478 0 : switch (idx) {
20479 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
20480 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20481 0 : ROSE_ASSERT(false);
20482 : return NULL;
20483 : }
20484 : }
20485 : size_t
20486 0 : SgUpcBlocksizeofExpression::get_childIndex(SgNode *child) {
20487 0 : if (child == p_expression) return 0;
20488 0 : else return (size_t) -1;
20489 : }
20490 : vector<SgNode*>
20491 0 : SgUpcElemsizeofExpression::get_traversalSuccessorContainer() {
20492 0 : vector<SgNode*> traversalSuccessorContainer;
20493 0 : traversalSuccessorContainer.reserve(1);
20494 0 : traversalSuccessorContainer.push_back(p_expression);
20495 0 : return traversalSuccessorContainer;
20496 : }
20497 : vector<string>
20498 0 : SgUpcElemsizeofExpression::get_traversalSuccessorNamesContainer() {
20499 0 : vector<string> traversalSuccessorContainer;
20500 0 : traversalSuccessorContainer.push_back("p_expression");
20501 0 : return traversalSuccessorContainer;
20502 : }
20503 : size_t
20504 0 : SgUpcElemsizeofExpression::get_numberOfTraversalSuccessors() {
20505 0 : return 1;
20506 : }
20507 : SgNode *
20508 0 : SgUpcElemsizeofExpression::get_traversalSuccessorByIndex(size_t idx) {
20509 0 : switch (idx) {
20510 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
20511 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20512 0 : ROSE_ASSERT(false);
20513 : return NULL;
20514 : }
20515 : }
20516 : size_t
20517 0 : SgUpcElemsizeofExpression::get_childIndex(SgNode *child) {
20518 0 : if (child == p_expression) return 0;
20519 0 : else return (size_t) -1;
20520 : }
20521 : vector<SgNode*>
20522 0 : SgSuperExp::get_traversalSuccessorContainer() {
20523 0 : vector<SgNode*> traversalSuccessorContainer;
20524 0 : return traversalSuccessorContainer;
20525 : }
20526 : vector<string>
20527 0 : SgSuperExp::get_traversalSuccessorNamesContainer() {
20528 0 : vector<string> traversalSuccessorContainer;
20529 0 : return traversalSuccessorContainer;
20530 : }
20531 : size_t
20532 0 : SgSuperExp::get_numberOfTraversalSuccessors() {
20533 0 : return 0;
20534 : }
20535 : SgNode *
20536 0 : SgSuperExp::get_traversalSuccessorByIndex(size_t idx) {
20537 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgSuperExp" << " that has no successors!" << endl;
20538 0 : ROSE_ASSERT(false);
20539 : return NULL;
20540 : }
20541 : size_t
20542 0 : SgSuperExp::get_childIndex(SgNode *child) {
20543 0 : cout << "error: get_childIndex called on node of type " << "SgSuperExp" << " that has no successors!" << endl;
20544 0 : ROSE_ASSERT(false);
20545 : return 0;
20546 : }
20547 : vector<SgNode*>
20548 596 : SgTypeIdOp::get_traversalSuccessorContainer() {
20549 596 : vector<SgNode*> traversalSuccessorContainer;
20550 596 : traversalSuccessorContainer.reserve(1);
20551 596 : traversalSuccessorContainer.push_back(p_operand_expr);
20552 596 : return traversalSuccessorContainer;
20553 : }
20554 : vector<string>
20555 14 : SgTypeIdOp::get_traversalSuccessorNamesContainer() {
20556 14 : vector<string> traversalSuccessorContainer;
20557 28 : traversalSuccessorContainer.push_back("p_operand_expr");
20558 14 : return traversalSuccessorContainer;
20559 : }
20560 : size_t
20561 985 : SgTypeIdOp::get_numberOfTraversalSuccessors() {
20562 985 : return 1;
20563 : }
20564 : SgNode *
20565 984 : SgTypeIdOp::get_traversalSuccessorByIndex(size_t idx) {
20566 984 : switch (idx) {
20567 984 : case 0: ROSE_ASSERT(p_operand_expr == NULL || p_operand_expr != NULL); return p_operand_expr;
20568 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20569 0 : ROSE_ASSERT(false);
20570 : return NULL;
20571 : }
20572 : }
20573 : size_t
20574 0 : SgTypeIdOp::get_childIndex(SgNode *child) {
20575 0 : if (child == p_operand_expr) return 0;
20576 0 : else return (size_t) -1;
20577 : }
20578 : vector<SgNode*>
20579 25024 : SgConditionalExp::get_traversalSuccessorContainer() {
20580 25024 : vector<SgNode*> traversalSuccessorContainer;
20581 25024 : traversalSuccessorContainer.reserve(3);
20582 25024 : traversalSuccessorContainer.push_back(p_conditional_exp);
20583 25024 : traversalSuccessorContainer.push_back(p_true_exp);
20584 25024 : traversalSuccessorContainer.push_back(p_false_exp);
20585 25024 : return traversalSuccessorContainer;
20586 : }
20587 : vector<string>
20588 1024 : SgConditionalExp::get_traversalSuccessorNamesContainer() {
20589 1024 : vector<string> traversalSuccessorContainer;
20590 2048 : traversalSuccessorContainer.push_back("p_conditional_exp");
20591 2048 : traversalSuccessorContainer.push_back("p_true_exp");
20592 2048 : traversalSuccessorContainer.push_back("p_false_exp");
20593 1024 : return traversalSuccessorContainer;
20594 : }
20595 : size_t
20596 42673 : SgConditionalExp::get_numberOfTraversalSuccessors() {
20597 42673 : return 3;
20598 : }
20599 : SgNode *
20600 127431 : SgConditionalExp::get_traversalSuccessorByIndex(size_t idx) {
20601 127431 : switch (idx) {
20602 42477 : case 0: ROSE_ASSERT(p_conditional_exp == NULL || p_conditional_exp != NULL); return p_conditional_exp;
20603 42477 : case 1: ROSE_ASSERT(p_true_exp == NULL || p_true_exp != NULL); return p_true_exp;
20604 42477 : case 2: ROSE_ASSERT(p_false_exp == NULL || p_false_exp != NULL); return p_false_exp;
20605 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20606 0 : ROSE_ASSERT(false);
20607 : return NULL;
20608 : }
20609 : }
20610 : size_t
20611 0 : SgConditionalExp::get_childIndex(SgNode *child) {
20612 0 : if (child == p_conditional_exp) return 0;
20613 0 : else if (child == p_true_exp) return 1;
20614 0 : else if (child == p_false_exp) return 2;
20615 0 : else return (size_t) -1;
20616 : }
20617 : vector<SgNode*>
20618 3987 : SgNewExp::get_traversalSuccessorContainer() {
20619 3987 : vector<SgNode*> traversalSuccessorContainer;
20620 3987 : traversalSuccessorContainer.reserve(3);
20621 3987 : traversalSuccessorContainer.push_back(p_placement_args);
20622 3987 : traversalSuccessorContainer.push_back(p_constructor_args);
20623 3987 : traversalSuccessorContainer.push_back(p_builtin_args);
20624 3987 : return traversalSuccessorContainer;
20625 : }
20626 : vector<string>
20627 188 : SgNewExp::get_traversalSuccessorNamesContainer() {
20628 188 : vector<string> traversalSuccessorContainer;
20629 376 : traversalSuccessorContainer.push_back("p_placement_args");
20630 376 : traversalSuccessorContainer.push_back("p_constructor_args");
20631 376 : traversalSuccessorContainer.push_back("p_builtin_args");
20632 188 : return traversalSuccessorContainer;
20633 : }
20634 : size_t
20635 8528 : SgNewExp::get_numberOfTraversalSuccessors() {
20636 8528 : return 3;
20637 : }
20638 : SgNode *
20639 25482 : SgNewExp::get_traversalSuccessorByIndex(size_t idx) {
20640 25482 : switch (idx) {
20641 8498 : case 0: ROSE_ASSERT(p_placement_args == NULL || p_placement_args != NULL); return p_placement_args;
20642 8498 : case 1: ROSE_ASSERT(p_constructor_args == NULL || p_constructor_args != NULL); return p_constructor_args;
20643 8486 : case 2: ROSE_ASSERT(p_builtin_args == NULL || p_builtin_args != NULL); return p_builtin_args;
20644 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20645 0 : ROSE_ASSERT(false);
20646 : return NULL;
20647 : }
20648 : }
20649 : size_t
20650 0 : SgNewExp::get_childIndex(SgNode *child) {
20651 0 : if (child == p_placement_args) return 0;
20652 0 : else if (child == p_constructor_args) return 1;
20653 0 : else if (child == p_builtin_args) return 2;
20654 0 : else return (size_t) -1;
20655 : }
20656 : vector<SgNode*>
20657 497 : SgDeleteExp::get_traversalSuccessorContainer() {
20658 497 : vector<SgNode*> traversalSuccessorContainer;
20659 497 : traversalSuccessorContainer.reserve(1);
20660 497 : traversalSuccessorContainer.push_back(p_variable);
20661 497 : return traversalSuccessorContainer;
20662 : }
20663 : vector<string>
20664 168 : SgDeleteExp::get_traversalSuccessorNamesContainer() {
20665 168 : vector<string> traversalSuccessorContainer;
20666 336 : traversalSuccessorContainer.push_back("p_variable");
20667 168 : return traversalSuccessorContainer;
20668 : }
20669 : size_t
20670 4409 : SgDeleteExp::get_numberOfTraversalSuccessors() {
20671 4409 : return 1;
20672 : }
20673 : SgNode *
20674 4409 : SgDeleteExp::get_traversalSuccessorByIndex(size_t idx) {
20675 4409 : switch (idx) {
20676 4409 : case 0: ROSE_ASSERT(p_variable == NULL || p_variable != NULL); return p_variable;
20677 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20678 0 : ROSE_ASSERT(false);
20679 : return NULL;
20680 : }
20681 : }
20682 : size_t
20683 0 : SgDeleteExp::get_childIndex(SgNode *child) {
20684 0 : if (child == p_variable) return 0;
20685 0 : else return (size_t) -1;
20686 : }
20687 : vector<SgNode*>
20688 406393 : SgThisExp::get_traversalSuccessorContainer() {
20689 406393 : vector<SgNode*> traversalSuccessorContainer;
20690 406393 : return traversalSuccessorContainer;
20691 : }
20692 : vector<string>
20693 16052 : SgThisExp::get_traversalSuccessorNamesContainer() {
20694 16052 : vector<string> traversalSuccessorContainer;
20695 16052 : return traversalSuccessorContainer;
20696 : }
20697 : size_t
20698 843455 : SgThisExp::get_numberOfTraversalSuccessors() {
20699 843455 : return 0;
20700 : }
20701 : SgNode *
20702 0 : SgThisExp::get_traversalSuccessorByIndex(size_t idx) {
20703 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgThisExp" << " that has no successors!" << endl;
20704 0 : ROSE_ASSERT(false);
20705 : return NULL;
20706 : }
20707 : size_t
20708 0 : SgThisExp::get_childIndex(SgNode *child) {
20709 0 : cout << "error: get_childIndex called on node of type " << "SgThisExp" << " that has no successors!" << endl;
20710 0 : ROSE_ASSERT(false);
20711 : return 0;
20712 : }
20713 : vector<SgNode*>
20714 0 : SgRefExp::get_traversalSuccessorContainer() {
20715 0 : vector<SgNode*> traversalSuccessorContainer;
20716 0 : return traversalSuccessorContainer;
20717 : }
20718 : vector<string>
20719 0 : SgRefExp::get_traversalSuccessorNamesContainer() {
20720 0 : vector<string> traversalSuccessorContainer;
20721 0 : return traversalSuccessorContainer;
20722 : }
20723 : size_t
20724 0 : SgRefExp::get_numberOfTraversalSuccessors() {
20725 0 : return 0;
20726 : }
20727 : SgNode *
20728 0 : SgRefExp::get_traversalSuccessorByIndex(size_t idx) {
20729 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgRefExp" << " that has no successors!" << endl;
20730 0 : ROSE_ASSERT(false);
20731 : return NULL;
20732 : }
20733 : size_t
20734 0 : SgRefExp::get_childIndex(SgNode *child) {
20735 0 : cout << "error: get_childIndex called on node of type " << "SgRefExp" << " that has no successors!" << endl;
20736 0 : ROSE_ASSERT(false);
20737 : return 0;
20738 : }
20739 : vector<SgNode*>
20740 0 : SgInitializer::get_traversalSuccessorContainer() {
20741 0 : vector<SgNode*> traversalSuccessorContainer;
20742 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
20743 0 : << "static: SgInitializer" << endl << "dynamic: " << this->sage_class_name() << endl;
20744 0 : cerr << "Aborting ..." << endl;
20745 0 : ROSE_ASSERT(false);
20746 : return traversalSuccessorContainer;
20747 : }
20748 :
20749 : vector<string>
20750 0 : SgInitializer::get_traversalSuccessorNamesContainer() {
20751 0 : vector<string> traversalSuccessorContainer;
20752 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
20753 0 : << "static: SgInitializer" << endl << "dynamic: " << this->sage_class_name() << endl;
20754 0 : cerr << "Aborting ..." << endl;
20755 0 : ROSE_ASSERT(false);
20756 : return traversalSuccessorContainer;
20757 : }
20758 :
20759 : size_t
20760 0 : SgInitializer::get_numberOfTraversalSuccessors() {
20761 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
20762 0 : << "static: SgInitializer" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
20763 0 : cerr << "Aborting ..." << endl;
20764 0 : ROSE_ASSERT(false);
20765 : return 42;
20766 : }
20767 :
20768 : SgNode*
20769 0 : SgInitializer::get_traversalSuccessorByIndex(size_t) {
20770 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
20771 0 : << "static: SgInitializer" << endl << "dynamic: " << this->sage_class_name() << endl;
20772 0 : cerr << "Aborting ..." << endl;
20773 0 : ROSE_ASSERT(false);
20774 : return NULL;
20775 : }
20776 :
20777 : size_t
20778 0 : SgInitializer::get_childIndex(SgNode *) {
20779 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
20780 0 : << "static: SgInitializer" << endl << "dynamic: " << this->sage_class_name() << endl;
20781 0 : cerr << "Aborting ..." << endl;
20782 0 : ROSE_ASSERT(false);
20783 : return 42;
20784 : }
20785 :
20786 : vector<SgNode*>
20787 1229 : SgAggregateInitializer::get_traversalSuccessorContainer() {
20788 1229 : vector<SgNode*> traversalSuccessorContainer;
20789 1229 : traversalSuccessorContainer.reserve(1);
20790 1229 : traversalSuccessorContainer.push_back(p_initializers);
20791 1229 : return traversalSuccessorContainer;
20792 : }
20793 : vector<string>
20794 120 : SgAggregateInitializer::get_traversalSuccessorNamesContainer() {
20795 120 : vector<string> traversalSuccessorContainer;
20796 240 : traversalSuccessorContainer.push_back("p_initializers");
20797 120 : return traversalSuccessorContainer;
20798 : }
20799 : size_t
20800 5322 : SgAggregateInitializer::get_numberOfTraversalSuccessors() {
20801 5322 : return 1;
20802 : }
20803 : SgNode *
20804 5321 : SgAggregateInitializer::get_traversalSuccessorByIndex(size_t idx) {
20805 5321 : switch (idx) {
20806 5321 : case 0: ROSE_ASSERT(p_initializers == NULL || p_initializers != NULL); return p_initializers;
20807 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20808 0 : ROSE_ASSERT(false);
20809 : return NULL;
20810 : }
20811 : }
20812 : size_t
20813 0 : SgAggregateInitializer::get_childIndex(SgNode *child) {
20814 0 : if (child == p_initializers) return 0;
20815 0 : else return (size_t) -1;
20816 : }
20817 : vector<SgNode*>
20818 0 : SgCompoundInitializer::get_traversalSuccessorContainer() {
20819 0 : vector<SgNode*> traversalSuccessorContainer;
20820 0 : traversalSuccessorContainer.reserve(1);
20821 0 : traversalSuccessorContainer.push_back(p_initializers);
20822 0 : return traversalSuccessorContainer;
20823 : }
20824 : vector<string>
20825 0 : SgCompoundInitializer::get_traversalSuccessorNamesContainer() {
20826 0 : vector<string> traversalSuccessorContainer;
20827 0 : traversalSuccessorContainer.push_back("p_initializers");
20828 0 : return traversalSuccessorContainer;
20829 : }
20830 : size_t
20831 0 : SgCompoundInitializer::get_numberOfTraversalSuccessors() {
20832 0 : return 1;
20833 : }
20834 : SgNode *
20835 0 : SgCompoundInitializer::get_traversalSuccessorByIndex(size_t idx) {
20836 0 : switch (idx) {
20837 0 : case 0: ROSE_ASSERT(p_initializers == NULL || p_initializers != NULL); return p_initializers;
20838 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20839 0 : ROSE_ASSERT(false);
20840 : return NULL;
20841 : }
20842 : }
20843 : size_t
20844 0 : SgCompoundInitializer::get_childIndex(SgNode *child) {
20845 0 : if (child == p_initializers) return 0;
20846 0 : else return (size_t) -1;
20847 : }
20848 : vector<SgNode*>
20849 179083 : SgConstructorInitializer::get_traversalSuccessorContainer() {
20850 179083 : vector<SgNode*> traversalSuccessorContainer;
20851 179083 : traversalSuccessorContainer.reserve(1);
20852 179083 : traversalSuccessorContainer.push_back(p_args);
20853 179083 : return traversalSuccessorContainer;
20854 : }
20855 : vector<string>
20856 5864 : SgConstructorInitializer::get_traversalSuccessorNamesContainer() {
20857 5864 : vector<string> traversalSuccessorContainer;
20858 11728 : traversalSuccessorContainer.push_back("p_args");
20859 5864 : return traversalSuccessorContainer;
20860 : }
20861 : size_t
20862 329400 : SgConstructorInitializer::get_numberOfTraversalSuccessors() {
20863 329400 : return 1;
20864 : }
20865 : SgNode *
20866 329118 : SgConstructorInitializer::get_traversalSuccessorByIndex(size_t idx) {
20867 329118 : switch (idx) {
20868 329118 : case 0: ROSE_ASSERT(p_args == NULL || p_args != NULL); return p_args;
20869 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20870 0 : ROSE_ASSERT(false);
20871 : return NULL;
20872 : }
20873 : }
20874 : size_t
20875 0 : SgConstructorInitializer::get_childIndex(SgNode *child) {
20876 0 : if (child == p_args) return 0;
20877 0 : else return (size_t) -1;
20878 : }
20879 : vector<SgNode*>
20880 227357 : SgAssignInitializer::get_traversalSuccessorContainer() {
20881 227357 : vector<SgNode*> traversalSuccessorContainer;
20882 227357 : traversalSuccessorContainer.reserve(1);
20883 227357 : traversalSuccessorContainer.push_back(p_operand_i);
20884 227357 : return traversalSuccessorContainer;
20885 : }
20886 : vector<string>
20887 24071 : SgAssignInitializer::get_traversalSuccessorNamesContainer() {
20888 24071 : vector<string> traversalSuccessorContainer;
20889 48142 : traversalSuccessorContainer.push_back("p_operand_i");
20890 24071 : return traversalSuccessorContainer;
20891 : }
20892 : size_t
20893 755125 : SgAssignInitializer::get_numberOfTraversalSuccessors() {
20894 755125 : return 1;
20895 : }
20896 : SgNode *
20897 754838 : SgAssignInitializer::get_traversalSuccessorByIndex(size_t idx) {
20898 754838 : switch (idx) {
20899 754838 : case 0: ROSE_ASSERT(p_operand_i == NULL || p_operand_i != NULL); return p_operand_i;
20900 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20901 0 : ROSE_ASSERT(false);
20902 : return NULL;
20903 : }
20904 : }
20905 : size_t
20906 25 : SgAssignInitializer::get_childIndex(SgNode *child) {
20907 25 : if (child == p_operand_i) return 0;
20908 0 : else return (size_t) -1;
20909 : }
20910 : vector<SgNode*>
20911 0 : SgDesignatedInitializer::get_traversalSuccessorContainer() {
20912 0 : vector<SgNode*> traversalSuccessorContainer;
20913 0 : traversalSuccessorContainer.reserve(2);
20914 0 : traversalSuccessorContainer.push_back(p_designatorList);
20915 0 : traversalSuccessorContainer.push_back(p_memberInit);
20916 0 : return traversalSuccessorContainer;
20917 : }
20918 : vector<string>
20919 0 : SgDesignatedInitializer::get_traversalSuccessorNamesContainer() {
20920 0 : vector<string> traversalSuccessorContainer;
20921 0 : traversalSuccessorContainer.push_back("p_designatorList");
20922 0 : traversalSuccessorContainer.push_back("p_memberInit");
20923 0 : return traversalSuccessorContainer;
20924 : }
20925 : size_t
20926 0 : SgDesignatedInitializer::get_numberOfTraversalSuccessors() {
20927 0 : return 2;
20928 : }
20929 : SgNode *
20930 0 : SgDesignatedInitializer::get_traversalSuccessorByIndex(size_t idx) {
20931 0 : switch (idx) {
20932 0 : case 0: ROSE_ASSERT(p_designatorList == NULL || p_designatorList != NULL); return p_designatorList;
20933 0 : case 1: ROSE_ASSERT(p_memberInit == NULL || p_memberInit != NULL); return p_memberInit;
20934 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20935 0 : ROSE_ASSERT(false);
20936 : return NULL;
20937 : }
20938 : }
20939 : size_t
20940 0 : SgDesignatedInitializer::get_childIndex(SgNode *child) {
20941 0 : if (child == p_designatorList) return 0;
20942 0 : else if (child == p_memberInit) return 1;
20943 0 : else return (size_t) -1;
20944 : }
20945 : vector<SgNode*>
20946 10 : SgBracedInitializer::get_traversalSuccessorContainer() {
20947 10 : vector<SgNode*> traversalSuccessorContainer;
20948 10 : traversalSuccessorContainer.reserve(1);
20949 10 : traversalSuccessorContainer.push_back(p_initializers);
20950 10 : return traversalSuccessorContainer;
20951 : }
20952 : vector<string>
20953 0 : SgBracedInitializer::get_traversalSuccessorNamesContainer() {
20954 0 : vector<string> traversalSuccessorContainer;
20955 0 : traversalSuccessorContainer.push_back("p_initializers");
20956 0 : return traversalSuccessorContainer;
20957 : }
20958 : size_t
20959 21 : SgBracedInitializer::get_numberOfTraversalSuccessors() {
20960 21 : return 1;
20961 : }
20962 : SgNode *
20963 21 : SgBracedInitializer::get_traversalSuccessorByIndex(size_t idx) {
20964 21 : switch (idx) {
20965 21 : case 0: ROSE_ASSERT(p_initializers == NULL || p_initializers != NULL); return p_initializers;
20966 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
20967 0 : ROSE_ASSERT(false);
20968 : return NULL;
20969 : }
20970 : }
20971 : size_t
20972 0 : SgBracedInitializer::get_childIndex(SgNode *child) {
20973 0 : if (child == p_initializers) return 0;
20974 0 : else return (size_t) -1;
20975 : }
20976 : vector<SgNode*>
20977 0 : SgVarArgStartOp::get_traversalSuccessorContainer() {
20978 0 : vector<SgNode*> traversalSuccessorContainer;
20979 0 : traversalSuccessorContainer.reserve(2);
20980 0 : traversalSuccessorContainer.push_back(p_lhs_operand);
20981 0 : traversalSuccessorContainer.push_back(p_rhs_operand);
20982 0 : return traversalSuccessorContainer;
20983 : }
20984 : vector<string>
20985 0 : SgVarArgStartOp::get_traversalSuccessorNamesContainer() {
20986 0 : vector<string> traversalSuccessorContainer;
20987 0 : traversalSuccessorContainer.push_back("p_lhs_operand");
20988 0 : traversalSuccessorContainer.push_back("p_rhs_operand");
20989 0 : return traversalSuccessorContainer;
20990 : }
20991 : size_t
20992 0 : SgVarArgStartOp::get_numberOfTraversalSuccessors() {
20993 0 : return 2;
20994 : }
20995 : SgNode *
20996 0 : SgVarArgStartOp::get_traversalSuccessorByIndex(size_t idx) {
20997 0 : switch (idx) {
20998 0 : case 0: ROSE_ASSERT(p_lhs_operand == NULL || p_lhs_operand != NULL); return p_lhs_operand;
20999 0 : case 1: ROSE_ASSERT(p_rhs_operand == NULL || p_rhs_operand != NULL); return p_rhs_operand;
21000 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21001 0 : ROSE_ASSERT(false);
21002 : return NULL;
21003 : }
21004 : }
21005 : size_t
21006 0 : SgVarArgStartOp::get_childIndex(SgNode *child) {
21007 0 : if (child == p_lhs_operand) return 0;
21008 0 : else if (child == p_rhs_operand) return 1;
21009 0 : else return (size_t) -1;
21010 : }
21011 : vector<SgNode*>
21012 0 : SgVarArgOp::get_traversalSuccessorContainer() {
21013 0 : vector<SgNode*> traversalSuccessorContainer;
21014 0 : traversalSuccessorContainer.reserve(1);
21015 0 : traversalSuccessorContainer.push_back(p_operand_expr);
21016 0 : return traversalSuccessorContainer;
21017 : }
21018 : vector<string>
21019 0 : SgVarArgOp::get_traversalSuccessorNamesContainer() {
21020 0 : vector<string> traversalSuccessorContainer;
21021 0 : traversalSuccessorContainer.push_back("p_operand_expr");
21022 0 : return traversalSuccessorContainer;
21023 : }
21024 : size_t
21025 0 : SgVarArgOp::get_numberOfTraversalSuccessors() {
21026 0 : return 1;
21027 : }
21028 : SgNode *
21029 0 : SgVarArgOp::get_traversalSuccessorByIndex(size_t idx) {
21030 0 : switch (idx) {
21031 0 : case 0: ROSE_ASSERT(p_operand_expr == NULL || p_operand_expr != NULL); return p_operand_expr;
21032 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21033 0 : ROSE_ASSERT(false);
21034 : return NULL;
21035 : }
21036 : }
21037 : size_t
21038 0 : SgVarArgOp::get_childIndex(SgNode *child) {
21039 0 : if (child == p_operand_expr) return 0;
21040 0 : else return (size_t) -1;
21041 : }
21042 : vector<SgNode*>
21043 0 : SgVarArgEndOp::get_traversalSuccessorContainer() {
21044 0 : vector<SgNode*> traversalSuccessorContainer;
21045 0 : traversalSuccessorContainer.reserve(1);
21046 0 : traversalSuccessorContainer.push_back(p_operand_expr);
21047 0 : return traversalSuccessorContainer;
21048 : }
21049 : vector<string>
21050 0 : SgVarArgEndOp::get_traversalSuccessorNamesContainer() {
21051 0 : vector<string> traversalSuccessorContainer;
21052 0 : traversalSuccessorContainer.push_back("p_operand_expr");
21053 0 : return traversalSuccessorContainer;
21054 : }
21055 : size_t
21056 0 : SgVarArgEndOp::get_numberOfTraversalSuccessors() {
21057 0 : return 1;
21058 : }
21059 : SgNode *
21060 0 : SgVarArgEndOp::get_traversalSuccessorByIndex(size_t idx) {
21061 0 : switch (idx) {
21062 0 : case 0: ROSE_ASSERT(p_operand_expr == NULL || p_operand_expr != NULL); return p_operand_expr;
21063 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21064 0 : ROSE_ASSERT(false);
21065 : return NULL;
21066 : }
21067 : }
21068 : size_t
21069 0 : SgVarArgEndOp::get_childIndex(SgNode *child) {
21070 0 : if (child == p_operand_expr) return 0;
21071 0 : else return (size_t) -1;
21072 : }
21073 : vector<SgNode*>
21074 0 : SgVarArgCopyOp::get_traversalSuccessorContainer() {
21075 0 : vector<SgNode*> traversalSuccessorContainer;
21076 0 : traversalSuccessorContainer.reserve(2);
21077 0 : traversalSuccessorContainer.push_back(p_lhs_operand);
21078 0 : traversalSuccessorContainer.push_back(p_rhs_operand);
21079 0 : return traversalSuccessorContainer;
21080 : }
21081 : vector<string>
21082 0 : SgVarArgCopyOp::get_traversalSuccessorNamesContainer() {
21083 0 : vector<string> traversalSuccessorContainer;
21084 0 : traversalSuccessorContainer.push_back("p_lhs_operand");
21085 0 : traversalSuccessorContainer.push_back("p_rhs_operand");
21086 0 : return traversalSuccessorContainer;
21087 : }
21088 : size_t
21089 0 : SgVarArgCopyOp::get_numberOfTraversalSuccessors() {
21090 0 : return 2;
21091 : }
21092 : SgNode *
21093 0 : SgVarArgCopyOp::get_traversalSuccessorByIndex(size_t idx) {
21094 0 : switch (idx) {
21095 0 : case 0: ROSE_ASSERT(p_lhs_operand == NULL || p_lhs_operand != NULL); return p_lhs_operand;
21096 0 : case 1: ROSE_ASSERT(p_rhs_operand == NULL || p_rhs_operand != NULL); return p_rhs_operand;
21097 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21098 0 : ROSE_ASSERT(false);
21099 : return NULL;
21100 : }
21101 : }
21102 : size_t
21103 0 : SgVarArgCopyOp::get_childIndex(SgNode *child) {
21104 0 : if (child == p_lhs_operand) return 0;
21105 0 : else if (child == p_rhs_operand) return 1;
21106 0 : else return (size_t) -1;
21107 : }
21108 : vector<SgNode*>
21109 0 : SgVarArgStartOneOperandOp::get_traversalSuccessorContainer() {
21110 0 : vector<SgNode*> traversalSuccessorContainer;
21111 0 : traversalSuccessorContainer.reserve(1);
21112 0 : traversalSuccessorContainer.push_back(p_operand_expr);
21113 0 : return traversalSuccessorContainer;
21114 : }
21115 : vector<string>
21116 0 : SgVarArgStartOneOperandOp::get_traversalSuccessorNamesContainer() {
21117 0 : vector<string> traversalSuccessorContainer;
21118 0 : traversalSuccessorContainer.push_back("p_operand_expr");
21119 0 : return traversalSuccessorContainer;
21120 : }
21121 : size_t
21122 0 : SgVarArgStartOneOperandOp::get_numberOfTraversalSuccessors() {
21123 0 : return 1;
21124 : }
21125 : SgNode *
21126 0 : SgVarArgStartOneOperandOp::get_traversalSuccessorByIndex(size_t idx) {
21127 0 : switch (idx) {
21128 0 : case 0: ROSE_ASSERT(p_operand_expr == NULL || p_operand_expr != NULL); return p_operand_expr;
21129 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21130 0 : ROSE_ASSERT(false);
21131 : return NULL;
21132 : }
21133 : }
21134 : size_t
21135 0 : SgVarArgStartOneOperandOp::get_childIndex(SgNode *child) {
21136 0 : if (child == p_operand_expr) return 0;
21137 0 : else return (size_t) -1;
21138 : }
21139 : vector<SgNode*>
21140 47775 : SgNullExpression::get_traversalSuccessorContainer() {
21141 47775 : vector<SgNode*> traversalSuccessorContainer;
21142 47775 : return traversalSuccessorContainer;
21143 : }
21144 : vector<string>
21145 1496 : SgNullExpression::get_traversalSuccessorNamesContainer() {
21146 1496 : vector<string> traversalSuccessorContainer;
21147 1496 : return traversalSuccessorContainer;
21148 : }
21149 : size_t
21150 85092 : SgNullExpression::get_numberOfTraversalSuccessors() {
21151 85092 : return 0;
21152 : }
21153 : SgNode *
21154 0 : SgNullExpression::get_traversalSuccessorByIndex(size_t idx) {
21155 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgNullExpression" << " that has no successors!" << endl;
21156 0 : ROSE_ASSERT(false);
21157 : return NULL;
21158 : }
21159 : size_t
21160 0 : SgNullExpression::get_childIndex(SgNode *child) {
21161 0 : cout << "error: get_childIndex called on node of type " << "SgNullExpression" << " that has no successors!" << endl;
21162 0 : ROSE_ASSERT(false);
21163 : return 0;
21164 : }
21165 : vector<SgNode*>
21166 1 : SgVariantExpression::get_traversalSuccessorContainer() {
21167 1 : vector<SgNode*> traversalSuccessorContainer;
21168 1 : return traversalSuccessorContainer;
21169 : }
21170 : vector<string>
21171 0 : SgVariantExpression::get_traversalSuccessorNamesContainer() {
21172 0 : vector<string> traversalSuccessorContainer;
21173 0 : return traversalSuccessorContainer;
21174 : }
21175 : size_t
21176 2 : SgVariantExpression::get_numberOfTraversalSuccessors() {
21177 2 : return 0;
21178 : }
21179 : SgNode *
21180 0 : SgVariantExpression::get_traversalSuccessorByIndex(size_t idx) {
21181 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgVariantExpression" << " that has no successors!" << endl;
21182 0 : ROSE_ASSERT(false);
21183 : return NULL;
21184 : }
21185 : size_t
21186 0 : SgVariantExpression::get_childIndex(SgNode *child) {
21187 0 : cout << "error: get_childIndex called on node of type " << "SgVariantExpression" << " that has no successors!" << endl;
21188 0 : ROSE_ASSERT(false);
21189 : return 0;
21190 : }
21191 : vector<SgNode*>
21192 0 : SgSubscriptExpression::get_traversalSuccessorContainer() {
21193 0 : vector<SgNode*> traversalSuccessorContainer;
21194 0 : traversalSuccessorContainer.reserve(3);
21195 0 : traversalSuccessorContainer.push_back(p_lowerBound);
21196 0 : traversalSuccessorContainer.push_back(p_upperBound);
21197 0 : traversalSuccessorContainer.push_back(p_stride);
21198 0 : return traversalSuccessorContainer;
21199 : }
21200 : vector<string>
21201 0 : SgSubscriptExpression::get_traversalSuccessorNamesContainer() {
21202 0 : vector<string> traversalSuccessorContainer;
21203 0 : traversalSuccessorContainer.push_back("p_lowerBound");
21204 0 : traversalSuccessorContainer.push_back("p_upperBound");
21205 0 : traversalSuccessorContainer.push_back("p_stride");
21206 0 : return traversalSuccessorContainer;
21207 : }
21208 : size_t
21209 0 : SgSubscriptExpression::get_numberOfTraversalSuccessors() {
21210 0 : return 3;
21211 : }
21212 : SgNode *
21213 0 : SgSubscriptExpression::get_traversalSuccessorByIndex(size_t idx) {
21214 0 : switch (idx) {
21215 0 : case 0: ROSE_ASSERT(p_lowerBound == NULL || p_lowerBound != NULL); return p_lowerBound;
21216 0 : case 1: ROSE_ASSERT(p_upperBound == NULL || p_upperBound != NULL); return p_upperBound;
21217 0 : case 2: ROSE_ASSERT(p_stride == NULL || p_stride != NULL); return p_stride;
21218 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21219 0 : ROSE_ASSERT(false);
21220 : return NULL;
21221 : }
21222 : }
21223 : size_t
21224 0 : SgSubscriptExpression::get_childIndex(SgNode *child) {
21225 0 : if (child == p_lowerBound) return 0;
21226 0 : else if (child == p_upperBound) return 1;
21227 0 : else if (child == p_stride) return 2;
21228 0 : else return (size_t) -1;
21229 : }
21230 : vector<SgNode*>
21231 0 : SgColonShapeExp::get_traversalSuccessorContainer() {
21232 0 : vector<SgNode*> traversalSuccessorContainer;
21233 0 : return traversalSuccessorContainer;
21234 : }
21235 : vector<string>
21236 0 : SgColonShapeExp::get_traversalSuccessorNamesContainer() {
21237 0 : vector<string> traversalSuccessorContainer;
21238 0 : return traversalSuccessorContainer;
21239 : }
21240 : size_t
21241 0 : SgColonShapeExp::get_numberOfTraversalSuccessors() {
21242 0 : return 0;
21243 : }
21244 : SgNode *
21245 0 : SgColonShapeExp::get_traversalSuccessorByIndex(size_t idx) {
21246 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgColonShapeExp" << " that has no successors!" << endl;
21247 0 : ROSE_ASSERT(false);
21248 : return NULL;
21249 : }
21250 : size_t
21251 0 : SgColonShapeExp::get_childIndex(SgNode *child) {
21252 0 : cout << "error: get_childIndex called on node of type " << "SgColonShapeExp" << " that has no successors!" << endl;
21253 0 : ROSE_ASSERT(false);
21254 : return 0;
21255 : }
21256 : vector<SgNode*>
21257 277 : SgAsteriskShapeExp::get_traversalSuccessorContainer() {
21258 277 : vector<SgNode*> traversalSuccessorContainer;
21259 277 : return traversalSuccessorContainer;
21260 : }
21261 : vector<string>
21262 136 : SgAsteriskShapeExp::get_traversalSuccessorNamesContainer() {
21263 136 : vector<string> traversalSuccessorContainer;
21264 136 : return traversalSuccessorContainer;
21265 : }
21266 : size_t
21267 2872 : SgAsteriskShapeExp::get_numberOfTraversalSuccessors() {
21268 2872 : return 0;
21269 : }
21270 : SgNode *
21271 0 : SgAsteriskShapeExp::get_traversalSuccessorByIndex(size_t idx) {
21272 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgAsteriskShapeExp" << " that has no successors!" << endl;
21273 0 : ROSE_ASSERT(false);
21274 : return NULL;
21275 : }
21276 : size_t
21277 0 : SgAsteriskShapeExp::get_childIndex(SgNode *child) {
21278 0 : cout << "error: get_childIndex called on node of type " << "SgAsteriskShapeExp" << " that has no successors!" << endl;
21279 0 : ROSE_ASSERT(false);
21280 : return 0;
21281 : }
21282 : vector<SgNode*>
21283 0 : SgImpliedDo::get_traversalSuccessorContainer() {
21284 0 : vector<SgNode*> traversalSuccessorContainer;
21285 0 : traversalSuccessorContainer.reserve(4);
21286 0 : traversalSuccessorContainer.push_back(p_do_var_initialization);
21287 0 : traversalSuccessorContainer.push_back(p_last_val);
21288 0 : traversalSuccessorContainer.push_back(p_increment);
21289 0 : traversalSuccessorContainer.push_back(p_object_list);
21290 0 : return traversalSuccessorContainer;
21291 : }
21292 : vector<string>
21293 0 : SgImpliedDo::get_traversalSuccessorNamesContainer() {
21294 0 : vector<string> traversalSuccessorContainer;
21295 0 : traversalSuccessorContainer.push_back("p_do_var_initialization");
21296 0 : traversalSuccessorContainer.push_back("p_last_val");
21297 0 : traversalSuccessorContainer.push_back("p_increment");
21298 0 : traversalSuccessorContainer.push_back("p_object_list");
21299 0 : return traversalSuccessorContainer;
21300 : }
21301 : size_t
21302 0 : SgImpliedDo::get_numberOfTraversalSuccessors() {
21303 0 : return 4;
21304 : }
21305 : SgNode *
21306 0 : SgImpliedDo::get_traversalSuccessorByIndex(size_t idx) {
21307 0 : switch (idx) {
21308 0 : case 0: ROSE_ASSERT(p_do_var_initialization == NULL || p_do_var_initialization != NULL); return p_do_var_initialization;
21309 0 : case 1: ROSE_ASSERT(p_last_val == NULL || p_last_val != NULL); return p_last_val;
21310 0 : case 2: ROSE_ASSERT(p_increment == NULL || p_increment != NULL); return p_increment;
21311 0 : case 3: ROSE_ASSERT(p_object_list == NULL || p_object_list != NULL); return p_object_list;
21312 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21313 0 : ROSE_ASSERT(false);
21314 : return NULL;
21315 : }
21316 : }
21317 : size_t
21318 0 : SgImpliedDo::get_childIndex(SgNode *child) {
21319 0 : if (child == p_do_var_initialization) return 0;
21320 0 : else if (child == p_last_val) return 1;
21321 0 : else if (child == p_increment) return 2;
21322 0 : else if (child == p_object_list) return 3;
21323 0 : else return (size_t) -1;
21324 : }
21325 : vector<SgNode*>
21326 0 : SgIOItemExpression::get_traversalSuccessorContainer() {
21327 0 : vector<SgNode*> traversalSuccessorContainer;
21328 0 : traversalSuccessorContainer.reserve(1);
21329 0 : traversalSuccessorContainer.push_back(p_io_item);
21330 0 : return traversalSuccessorContainer;
21331 : }
21332 : vector<string>
21333 0 : SgIOItemExpression::get_traversalSuccessorNamesContainer() {
21334 0 : vector<string> traversalSuccessorContainer;
21335 0 : traversalSuccessorContainer.push_back("p_io_item");
21336 0 : return traversalSuccessorContainer;
21337 : }
21338 : size_t
21339 0 : SgIOItemExpression::get_numberOfTraversalSuccessors() {
21340 0 : return 1;
21341 : }
21342 : SgNode *
21343 0 : SgIOItemExpression::get_traversalSuccessorByIndex(size_t idx) {
21344 0 : switch (idx) {
21345 0 : case 0: ROSE_ASSERT(p_io_item == NULL || p_io_item != NULL); return p_io_item;
21346 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21347 0 : ROSE_ASSERT(false);
21348 : return NULL;
21349 : }
21350 : }
21351 : size_t
21352 0 : SgIOItemExpression::get_childIndex(SgNode *child) {
21353 0 : if (child == p_io_item) return 0;
21354 0 : else return (size_t) -1;
21355 : }
21356 : vector<SgNode*>
21357 177 : SgStatementExpression::get_traversalSuccessorContainer() {
21358 177 : vector<SgNode*> traversalSuccessorContainer;
21359 177 : traversalSuccessorContainer.reserve(1);
21360 177 : traversalSuccessorContainer.push_back(p_statement);
21361 177 : return traversalSuccessorContainer;
21362 : }
21363 : vector<string>
21364 118 : SgStatementExpression::get_traversalSuccessorNamesContainer() {
21365 118 : vector<string> traversalSuccessorContainer;
21366 236 : traversalSuccessorContainer.push_back("p_statement");
21367 118 : return traversalSuccessorContainer;
21368 : }
21369 : size_t
21370 2281 : SgStatementExpression::get_numberOfTraversalSuccessors() {
21371 2281 : return 1;
21372 : }
21373 : SgNode *
21374 2281 : SgStatementExpression::get_traversalSuccessorByIndex(size_t idx) {
21375 2281 : switch (idx) {
21376 2281 : case 0: ROSE_ASSERT(p_statement == NULL || p_statement != NULL); return p_statement;
21377 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21378 0 : ROSE_ASSERT(false);
21379 : return NULL;
21380 : }
21381 : }
21382 : size_t
21383 0 : SgStatementExpression::get_childIndex(SgNode *child) {
21384 0 : if (child == p_statement) return 0;
21385 0 : else return (size_t) -1;
21386 : }
21387 : vector<SgNode*>
21388 0 : SgAsmOp::get_traversalSuccessorContainer() {
21389 0 : vector<SgNode*> traversalSuccessorContainer;
21390 0 : traversalSuccessorContainer.reserve(1);
21391 0 : traversalSuccessorContainer.push_back(p_expression);
21392 0 : return traversalSuccessorContainer;
21393 : }
21394 : vector<string>
21395 0 : SgAsmOp::get_traversalSuccessorNamesContainer() {
21396 0 : vector<string> traversalSuccessorContainer;
21397 0 : traversalSuccessorContainer.push_back("p_expression");
21398 0 : return traversalSuccessorContainer;
21399 : }
21400 : size_t
21401 0 : SgAsmOp::get_numberOfTraversalSuccessors() {
21402 0 : return 1;
21403 : }
21404 : SgNode *
21405 0 : SgAsmOp::get_traversalSuccessorByIndex(size_t idx) {
21406 0 : switch (idx) {
21407 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
21408 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21409 0 : ROSE_ASSERT(false);
21410 : return NULL;
21411 : }
21412 : }
21413 : size_t
21414 0 : SgAsmOp::get_childIndex(SgNode *child) {
21415 0 : if (child == p_expression) return 0;
21416 0 : else return (size_t) -1;
21417 : }
21418 : vector<SgNode*>
21419 0 : SgLabelRefExp::get_traversalSuccessorContainer() {
21420 0 : vector<SgNode*> traversalSuccessorContainer;
21421 0 : return traversalSuccessorContainer;
21422 : }
21423 : vector<string>
21424 0 : SgLabelRefExp::get_traversalSuccessorNamesContainer() {
21425 0 : vector<string> traversalSuccessorContainer;
21426 0 : return traversalSuccessorContainer;
21427 : }
21428 : size_t
21429 0 : SgLabelRefExp::get_numberOfTraversalSuccessors() {
21430 0 : return 0;
21431 : }
21432 : SgNode *
21433 0 : SgLabelRefExp::get_traversalSuccessorByIndex(size_t idx) {
21434 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgLabelRefExp" << " that has no successors!" << endl;
21435 0 : ROSE_ASSERT(false);
21436 : return NULL;
21437 : }
21438 : size_t
21439 0 : SgLabelRefExp::get_childIndex(SgNode *child) {
21440 0 : cout << "error: get_childIndex called on node of type " << "SgLabelRefExp" << " that has no successors!" << endl;
21441 0 : ROSE_ASSERT(false);
21442 : return 0;
21443 : }
21444 : vector<SgNode*>
21445 0 : SgActualArgumentExpression::get_traversalSuccessorContainer() {
21446 0 : vector<SgNode*> traversalSuccessorContainer;
21447 0 : traversalSuccessorContainer.reserve(1);
21448 0 : traversalSuccessorContainer.push_back(p_expression);
21449 0 : return traversalSuccessorContainer;
21450 : }
21451 : vector<string>
21452 0 : SgActualArgumentExpression::get_traversalSuccessorNamesContainer() {
21453 0 : vector<string> traversalSuccessorContainer;
21454 0 : traversalSuccessorContainer.push_back("p_expression");
21455 0 : return traversalSuccessorContainer;
21456 : }
21457 : size_t
21458 0 : SgActualArgumentExpression::get_numberOfTraversalSuccessors() {
21459 0 : return 1;
21460 : }
21461 : SgNode *
21462 0 : SgActualArgumentExpression::get_traversalSuccessorByIndex(size_t idx) {
21463 0 : switch (idx) {
21464 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
21465 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21466 0 : ROSE_ASSERT(false);
21467 : return NULL;
21468 : }
21469 : }
21470 : size_t
21471 0 : SgActualArgumentExpression::get_childIndex(SgNode *child) {
21472 0 : if (child == p_expression) return 0;
21473 0 : else return (size_t) -1;
21474 : }
21475 : vector<SgNode*>
21476 0 : SgUnknownArrayOrFunctionReference::get_traversalSuccessorContainer() {
21477 0 : vector<SgNode*> traversalSuccessorContainer;
21478 0 : traversalSuccessorContainer.reserve(2);
21479 0 : traversalSuccessorContainer.push_back(p_named_reference);
21480 0 : traversalSuccessorContainer.push_back(p_expression_list);
21481 0 : return traversalSuccessorContainer;
21482 : }
21483 : vector<string>
21484 0 : SgUnknownArrayOrFunctionReference::get_traversalSuccessorNamesContainer() {
21485 0 : vector<string> traversalSuccessorContainer;
21486 0 : traversalSuccessorContainer.push_back("p_named_reference");
21487 0 : traversalSuccessorContainer.push_back("p_expression_list");
21488 0 : return traversalSuccessorContainer;
21489 : }
21490 : size_t
21491 0 : SgUnknownArrayOrFunctionReference::get_numberOfTraversalSuccessors() {
21492 0 : return 2;
21493 : }
21494 : SgNode *
21495 0 : SgUnknownArrayOrFunctionReference::get_traversalSuccessorByIndex(size_t idx) {
21496 0 : switch (idx) {
21497 0 : case 0: ROSE_ASSERT(p_named_reference == NULL || p_named_reference != NULL); return p_named_reference;
21498 0 : case 1: ROSE_ASSERT(p_expression_list == NULL || p_expression_list != NULL); return p_expression_list;
21499 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21500 0 : ROSE_ASSERT(false);
21501 : return NULL;
21502 : }
21503 : }
21504 : size_t
21505 0 : SgUnknownArrayOrFunctionReference::get_childIndex(SgNode *child) {
21506 0 : if (child == p_named_reference) return 0;
21507 0 : else if (child == p_expression_list) return 1;
21508 0 : else return (size_t) -1;
21509 : }
21510 : vector<SgNode*>
21511 0 : SgPseudoDestructorRefExp::get_traversalSuccessorContainer() {
21512 0 : vector<SgNode*> traversalSuccessorContainer;
21513 0 : return traversalSuccessorContainer;
21514 : }
21515 : vector<string>
21516 0 : SgPseudoDestructorRefExp::get_traversalSuccessorNamesContainer() {
21517 0 : vector<string> traversalSuccessorContainer;
21518 0 : return traversalSuccessorContainer;
21519 : }
21520 : size_t
21521 0 : SgPseudoDestructorRefExp::get_numberOfTraversalSuccessors() {
21522 0 : return 0;
21523 : }
21524 : SgNode *
21525 0 : SgPseudoDestructorRefExp::get_traversalSuccessorByIndex(size_t idx) {
21526 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgPseudoDestructorRefExp" << " that has no successors!" << endl;
21527 0 : ROSE_ASSERT(false);
21528 : return NULL;
21529 : }
21530 : size_t
21531 0 : SgPseudoDestructorRefExp::get_childIndex(SgNode *child) {
21532 0 : cout << "error: get_childIndex called on node of type " << "SgPseudoDestructorRefExp" << " that has no successors!" << endl;
21533 0 : ROSE_ASSERT(false);
21534 : return 0;
21535 : }
21536 : vector<SgNode*>
21537 0 : SgCAFCoExpression::get_traversalSuccessorContainer() {
21538 0 : vector<SgNode*> traversalSuccessorContainer;
21539 0 : traversalSuccessorContainer.reserve(1);
21540 0 : traversalSuccessorContainer.push_back(p_referData);
21541 0 : return traversalSuccessorContainer;
21542 : }
21543 : vector<string>
21544 0 : SgCAFCoExpression::get_traversalSuccessorNamesContainer() {
21545 0 : vector<string> traversalSuccessorContainer;
21546 0 : traversalSuccessorContainer.push_back("p_referData");
21547 0 : return traversalSuccessorContainer;
21548 : }
21549 : size_t
21550 0 : SgCAFCoExpression::get_numberOfTraversalSuccessors() {
21551 0 : return 1;
21552 : }
21553 : SgNode *
21554 0 : SgCAFCoExpression::get_traversalSuccessorByIndex(size_t idx) {
21555 0 : switch (idx) {
21556 0 : case 0: ROSE_ASSERT(p_referData == NULL || p_referData != NULL); return p_referData;
21557 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21558 0 : ROSE_ASSERT(false);
21559 : return NULL;
21560 : }
21561 : }
21562 : size_t
21563 0 : SgCAFCoExpression::get_childIndex(SgNode *child) {
21564 0 : if (child == p_referData) return 0;
21565 0 : else return (size_t) -1;
21566 : }
21567 : vector<SgNode*>
21568 0 : SgCudaKernelExecConfig::get_traversalSuccessorContainer() {
21569 0 : vector<SgNode*> traversalSuccessorContainer;
21570 0 : traversalSuccessorContainer.reserve(4);
21571 0 : traversalSuccessorContainer.push_back(p_grid);
21572 0 : traversalSuccessorContainer.push_back(p_blocks);
21573 0 : traversalSuccessorContainer.push_back(p_shared);
21574 0 : traversalSuccessorContainer.push_back(p_stream);
21575 0 : return traversalSuccessorContainer;
21576 : }
21577 : vector<string>
21578 0 : SgCudaKernelExecConfig::get_traversalSuccessorNamesContainer() {
21579 0 : vector<string> traversalSuccessorContainer;
21580 0 : traversalSuccessorContainer.push_back("p_grid");
21581 0 : traversalSuccessorContainer.push_back("p_blocks");
21582 0 : traversalSuccessorContainer.push_back("p_shared");
21583 0 : traversalSuccessorContainer.push_back("p_stream");
21584 0 : return traversalSuccessorContainer;
21585 : }
21586 : size_t
21587 0 : SgCudaKernelExecConfig::get_numberOfTraversalSuccessors() {
21588 0 : return 4;
21589 : }
21590 : SgNode *
21591 0 : SgCudaKernelExecConfig::get_traversalSuccessorByIndex(size_t idx) {
21592 0 : switch (idx) {
21593 0 : case 0: ROSE_ASSERT(p_grid == NULL || p_grid != NULL); return p_grid;
21594 0 : case 1: ROSE_ASSERT(p_blocks == NULL || p_blocks != NULL); return p_blocks;
21595 0 : case 2: ROSE_ASSERT(p_shared == NULL || p_shared != NULL); return p_shared;
21596 0 : case 3: ROSE_ASSERT(p_stream == NULL || p_stream != NULL); return p_stream;
21597 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21598 0 : ROSE_ASSERT(false);
21599 : return NULL;
21600 : }
21601 : }
21602 : size_t
21603 0 : SgCudaKernelExecConfig::get_childIndex(SgNode *child) {
21604 0 : if (child == p_grid) return 0;
21605 0 : else if (child == p_blocks) return 1;
21606 0 : else if (child == p_shared) return 2;
21607 0 : else if (child == p_stream) return 3;
21608 0 : else return (size_t) -1;
21609 : }
21610 : vector<SgNode*>
21611 0 : SgLambdaRefExp::get_traversalSuccessorContainer() {
21612 0 : vector<SgNode*> traversalSuccessorContainer;
21613 0 : traversalSuccessorContainer.reserve(1);
21614 0 : traversalSuccessorContainer.push_back(p_functionDeclaration);
21615 0 : return traversalSuccessorContainer;
21616 : }
21617 : vector<string>
21618 0 : SgLambdaRefExp::get_traversalSuccessorNamesContainer() {
21619 0 : vector<string> traversalSuccessorContainer;
21620 0 : traversalSuccessorContainer.push_back("p_functionDeclaration");
21621 0 : return traversalSuccessorContainer;
21622 : }
21623 : size_t
21624 0 : SgLambdaRefExp::get_numberOfTraversalSuccessors() {
21625 0 : return 1;
21626 : }
21627 : SgNode *
21628 0 : SgLambdaRefExp::get_traversalSuccessorByIndex(size_t idx) {
21629 0 : switch (idx) {
21630 0 : case 0: ROSE_ASSERT(p_functionDeclaration == NULL || p_functionDeclaration != NULL); return p_functionDeclaration;
21631 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21632 0 : ROSE_ASSERT(false);
21633 : return NULL;
21634 : }
21635 : }
21636 : size_t
21637 0 : SgLambdaRefExp::get_childIndex(SgNode *child) {
21638 0 : if (child == p_functionDeclaration) return 0;
21639 0 : else return (size_t) -1;
21640 : }
21641 : vector<SgNode*>
21642 0 : SgDictionaryExp::get_traversalSuccessorContainer() {
21643 0 : vector<SgNode*> traversalSuccessorContainer;
21644 0 : traversalSuccessorContainer.reserve(p_key_datum_pairs.size() + 0);
21645 0 : {
21646 0 : SgKeyDatumPairPtrList::iterator iter;
21647 0 : for (iter = p_key_datum_pairs.begin(); iter != p_key_datum_pairs.end(); iter++)
21648 0 : traversalSuccessorContainer.push_back(*iter);
21649 : }
21650 0 : return traversalSuccessorContainer;
21651 : }
21652 : vector<string>
21653 0 : SgDictionaryExp::get_traversalSuccessorNamesContainer() {
21654 0 : vector<string> traversalSuccessorContainer;
21655 0 : int i = 0;
21656 0 : {
21657 0 : SgKeyDatumPairPtrList::iterator iter;
21658 0 : for (iter = p_key_datum_pairs.begin(); iter != p_key_datum_pairs.end(); (iter++,i++)) {
21659 0 : char buf[20];
21660 0 : sprintf(buf,"*[%d]",i);
21661 0 : traversalSuccessorContainer.push_back(buf);
21662 : }
21663 : }
21664 0 : return traversalSuccessorContainer;
21665 : }
21666 : size_t
21667 0 : SgDictionaryExp::get_numberOfTraversalSuccessors() {
21668 0 : return p_key_datum_pairs.size() + 0;
21669 : }
21670 : SgNode *
21671 0 : SgDictionaryExp::get_traversalSuccessorByIndex(size_t idx) {
21672 0 : ROSE_ASSERT(idx < p_key_datum_pairs.size());
21673 0 : return p_key_datum_pairs[idx];
21674 : }
21675 : size_t
21676 0 : SgDictionaryExp::get_childIndex(SgNode *child) {
21677 0 : SgKeyDatumPairPtrList::iterator itr = find(p_key_datum_pairs.begin(), p_key_datum_pairs.end(), child);
21678 0 : if (itr != p_key_datum_pairs.end()) return itr - p_key_datum_pairs.begin();
21679 : else return (size_t) -1;
21680 : }
21681 : vector<SgNode*>
21682 0 : SgKeyDatumPair::get_traversalSuccessorContainer() {
21683 0 : vector<SgNode*> traversalSuccessorContainer;
21684 0 : traversalSuccessorContainer.reserve(2);
21685 0 : traversalSuccessorContainer.push_back(p_key);
21686 0 : traversalSuccessorContainer.push_back(p_datum);
21687 0 : return traversalSuccessorContainer;
21688 : }
21689 : vector<string>
21690 0 : SgKeyDatumPair::get_traversalSuccessorNamesContainer() {
21691 0 : vector<string> traversalSuccessorContainer;
21692 0 : traversalSuccessorContainer.push_back("p_key");
21693 0 : traversalSuccessorContainer.push_back("p_datum");
21694 0 : return traversalSuccessorContainer;
21695 : }
21696 : size_t
21697 0 : SgKeyDatumPair::get_numberOfTraversalSuccessors() {
21698 0 : return 2;
21699 : }
21700 : SgNode *
21701 0 : SgKeyDatumPair::get_traversalSuccessorByIndex(size_t idx) {
21702 0 : switch (idx) {
21703 0 : case 0: ROSE_ASSERT(p_key == NULL || p_key != NULL); return p_key;
21704 0 : case 1: ROSE_ASSERT(p_datum == NULL || p_datum != NULL); return p_datum;
21705 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21706 0 : ROSE_ASSERT(false);
21707 : return NULL;
21708 : }
21709 : }
21710 : size_t
21711 0 : SgKeyDatumPair::get_childIndex(SgNode *child) {
21712 0 : if (child == p_key) return 0;
21713 0 : else if (child == p_datum) return 1;
21714 0 : else return (size_t) -1;
21715 : }
21716 : vector<SgNode*>
21717 0 : SgComprehension::get_traversalSuccessorContainer() {
21718 0 : vector<SgNode*> traversalSuccessorContainer;
21719 0 : traversalSuccessorContainer.reserve(3);
21720 0 : traversalSuccessorContainer.push_back(p_target);
21721 0 : traversalSuccessorContainer.push_back(p_iter);
21722 0 : traversalSuccessorContainer.push_back(p_filters);
21723 0 : return traversalSuccessorContainer;
21724 : }
21725 : vector<string>
21726 0 : SgComprehension::get_traversalSuccessorNamesContainer() {
21727 0 : vector<string> traversalSuccessorContainer;
21728 0 : traversalSuccessorContainer.push_back("p_target");
21729 0 : traversalSuccessorContainer.push_back("p_iter");
21730 0 : traversalSuccessorContainer.push_back("p_filters");
21731 0 : return traversalSuccessorContainer;
21732 : }
21733 : size_t
21734 0 : SgComprehension::get_numberOfTraversalSuccessors() {
21735 0 : return 3;
21736 : }
21737 : SgNode *
21738 0 : SgComprehension::get_traversalSuccessorByIndex(size_t idx) {
21739 0 : switch (idx) {
21740 0 : case 0: ROSE_ASSERT(p_target == NULL || p_target != NULL); return p_target;
21741 0 : case 1: ROSE_ASSERT(p_iter == NULL || p_iter != NULL); return p_iter;
21742 0 : case 2: ROSE_ASSERT(p_filters == NULL || p_filters != NULL); return p_filters;
21743 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21744 0 : ROSE_ASSERT(false);
21745 : return NULL;
21746 : }
21747 : }
21748 : size_t
21749 0 : SgComprehension::get_childIndex(SgNode *child) {
21750 0 : if (child == p_target) return 0;
21751 0 : else if (child == p_iter) return 1;
21752 0 : else if (child == p_filters) return 2;
21753 0 : else return (size_t) -1;
21754 : }
21755 : vector<SgNode*>
21756 0 : SgListComprehension::get_traversalSuccessorContainer() {
21757 0 : vector<SgNode*> traversalSuccessorContainer;
21758 0 : traversalSuccessorContainer.reserve(2);
21759 0 : traversalSuccessorContainer.push_back(p_element);
21760 0 : traversalSuccessorContainer.push_back(p_generators);
21761 0 : return traversalSuccessorContainer;
21762 : }
21763 : vector<string>
21764 0 : SgListComprehension::get_traversalSuccessorNamesContainer() {
21765 0 : vector<string> traversalSuccessorContainer;
21766 0 : traversalSuccessorContainer.push_back("p_element");
21767 0 : traversalSuccessorContainer.push_back("p_generators");
21768 0 : return traversalSuccessorContainer;
21769 : }
21770 : size_t
21771 0 : SgListComprehension::get_numberOfTraversalSuccessors() {
21772 0 : return 2;
21773 : }
21774 : SgNode *
21775 0 : SgListComprehension::get_traversalSuccessorByIndex(size_t idx) {
21776 0 : switch (idx) {
21777 0 : case 0: ROSE_ASSERT(p_element == NULL || p_element != NULL); return p_element;
21778 0 : case 1: ROSE_ASSERT(p_generators == NULL || p_generators != NULL); return p_generators;
21779 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21780 0 : ROSE_ASSERT(false);
21781 : return NULL;
21782 : }
21783 : }
21784 : size_t
21785 0 : SgListComprehension::get_childIndex(SgNode *child) {
21786 0 : if (child == p_element) return 0;
21787 0 : else if (child == p_generators) return 1;
21788 0 : else return (size_t) -1;
21789 : }
21790 : vector<SgNode*>
21791 0 : SgSetComprehension::get_traversalSuccessorContainer() {
21792 0 : vector<SgNode*> traversalSuccessorContainer;
21793 0 : traversalSuccessorContainer.reserve(2);
21794 0 : traversalSuccessorContainer.push_back(p_element);
21795 0 : traversalSuccessorContainer.push_back(p_generators);
21796 0 : return traversalSuccessorContainer;
21797 : }
21798 : vector<string>
21799 0 : SgSetComprehension::get_traversalSuccessorNamesContainer() {
21800 0 : vector<string> traversalSuccessorContainer;
21801 0 : traversalSuccessorContainer.push_back("p_element");
21802 0 : traversalSuccessorContainer.push_back("p_generators");
21803 0 : return traversalSuccessorContainer;
21804 : }
21805 : size_t
21806 0 : SgSetComprehension::get_numberOfTraversalSuccessors() {
21807 0 : return 2;
21808 : }
21809 : SgNode *
21810 0 : SgSetComprehension::get_traversalSuccessorByIndex(size_t idx) {
21811 0 : switch (idx) {
21812 0 : case 0: ROSE_ASSERT(p_element == NULL || p_element != NULL); return p_element;
21813 0 : case 1: ROSE_ASSERT(p_generators == NULL || p_generators != NULL); return p_generators;
21814 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21815 0 : ROSE_ASSERT(false);
21816 : return NULL;
21817 : }
21818 : }
21819 : size_t
21820 0 : SgSetComprehension::get_childIndex(SgNode *child) {
21821 0 : if (child == p_element) return 0;
21822 0 : else if (child == p_generators) return 1;
21823 0 : else return (size_t) -1;
21824 : }
21825 : vector<SgNode*>
21826 0 : SgDictionaryComprehension::get_traversalSuccessorContainer() {
21827 0 : vector<SgNode*> traversalSuccessorContainer;
21828 0 : traversalSuccessorContainer.reserve(2);
21829 0 : traversalSuccessorContainer.push_back(p_element);
21830 0 : traversalSuccessorContainer.push_back(p_generators);
21831 0 : return traversalSuccessorContainer;
21832 : }
21833 : vector<string>
21834 0 : SgDictionaryComprehension::get_traversalSuccessorNamesContainer() {
21835 0 : vector<string> traversalSuccessorContainer;
21836 0 : traversalSuccessorContainer.push_back("p_element");
21837 0 : traversalSuccessorContainer.push_back("p_generators");
21838 0 : return traversalSuccessorContainer;
21839 : }
21840 : size_t
21841 0 : SgDictionaryComprehension::get_numberOfTraversalSuccessors() {
21842 0 : return 2;
21843 : }
21844 : SgNode *
21845 0 : SgDictionaryComprehension::get_traversalSuccessorByIndex(size_t idx) {
21846 0 : switch (idx) {
21847 0 : case 0: ROSE_ASSERT(p_element == NULL || p_element != NULL); return p_element;
21848 0 : case 1: ROSE_ASSERT(p_generators == NULL || p_generators != NULL); return p_generators;
21849 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
21850 0 : ROSE_ASSERT(false);
21851 : return NULL;
21852 : }
21853 : }
21854 : size_t
21855 0 : SgDictionaryComprehension::get_childIndex(SgNode *child) {
21856 0 : if (child == p_element) return 0;
21857 0 : else if (child == p_generators) return 1;
21858 0 : else return (size_t) -1;
21859 : }
21860 : vector<SgNode*>
21861 0 : SgNaryOp::get_traversalSuccessorContainer() {
21862 0 : vector<SgNode*> traversalSuccessorContainer;
21863 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
21864 0 : << "static: SgNaryOp" << endl << "dynamic: " << this->sage_class_name() << endl;
21865 0 : cerr << "Aborting ..." << endl;
21866 0 : ROSE_ASSERT(false);
21867 : return traversalSuccessorContainer;
21868 : }
21869 :
21870 : vector<string>
21871 0 : SgNaryOp::get_traversalSuccessorNamesContainer() {
21872 0 : vector<string> traversalSuccessorContainer;
21873 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
21874 0 : << "static: SgNaryOp" << endl << "dynamic: " << this->sage_class_name() << endl;
21875 0 : cerr << "Aborting ..." << endl;
21876 0 : ROSE_ASSERT(false);
21877 : return traversalSuccessorContainer;
21878 : }
21879 :
21880 : size_t
21881 0 : SgNaryOp::get_numberOfTraversalSuccessors() {
21882 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
21883 0 : << "static: SgNaryOp" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
21884 0 : cerr << "Aborting ..." << endl;
21885 0 : ROSE_ASSERT(false);
21886 : return 42;
21887 : }
21888 :
21889 : SgNode*
21890 0 : SgNaryOp::get_traversalSuccessorByIndex(size_t) {
21891 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
21892 0 : << "static: SgNaryOp" << endl << "dynamic: " << this->sage_class_name() << endl;
21893 0 : cerr << "Aborting ..." << endl;
21894 0 : ROSE_ASSERT(false);
21895 : return NULL;
21896 : }
21897 :
21898 : size_t
21899 0 : SgNaryOp::get_childIndex(SgNode *) {
21900 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
21901 0 : << "static: SgNaryOp" << endl << "dynamic: " << this->sage_class_name() << endl;
21902 0 : cerr << "Aborting ..." << endl;
21903 0 : ROSE_ASSERT(false);
21904 : return 42;
21905 : }
21906 :
21907 : vector<SgNode*>
21908 0 : SgNaryBooleanOp::get_traversalSuccessorContainer() {
21909 0 : vector<SgNode*> traversalSuccessorContainer;
21910 0 : traversalSuccessorContainer.reserve(p_operands.size() + 0);
21911 0 : {
21912 0 : SgExpressionPtrList::iterator iter;
21913 0 : for (iter = p_operands.begin(); iter != p_operands.end(); iter++)
21914 0 : traversalSuccessorContainer.push_back(*iter);
21915 : }
21916 0 : return traversalSuccessorContainer;
21917 : }
21918 : vector<string>
21919 0 : SgNaryBooleanOp::get_traversalSuccessorNamesContainer() {
21920 0 : vector<string> traversalSuccessorContainer;
21921 0 : int i = 0;
21922 0 : {
21923 0 : SgExpressionPtrList::iterator iter;
21924 0 : for (iter = p_operands.begin(); iter != p_operands.end(); (iter++,i++)) {
21925 0 : char buf[20];
21926 0 : sprintf(buf,"*[%d]",i);
21927 0 : traversalSuccessorContainer.push_back(buf);
21928 : }
21929 : }
21930 0 : return traversalSuccessorContainer;
21931 : }
21932 : size_t
21933 0 : SgNaryBooleanOp::get_numberOfTraversalSuccessors() {
21934 0 : return p_operands.size() + 0;
21935 : }
21936 : SgNode *
21937 0 : SgNaryBooleanOp::get_traversalSuccessorByIndex(size_t idx) {
21938 0 : ROSE_ASSERT(idx < p_operands.size());
21939 0 : return p_operands[idx];
21940 : }
21941 : size_t
21942 0 : SgNaryBooleanOp::get_childIndex(SgNode *child) {
21943 0 : SgExpressionPtrList::iterator itr = find(p_operands.begin(), p_operands.end(), child);
21944 0 : if (itr != p_operands.end()) return itr - p_operands.begin();
21945 : else return (size_t) -1;
21946 : }
21947 : vector<SgNode*>
21948 0 : SgNaryComparisonOp::get_traversalSuccessorContainer() {
21949 0 : vector<SgNode*> traversalSuccessorContainer;
21950 0 : traversalSuccessorContainer.reserve(p_operands.size() + 0);
21951 0 : {
21952 0 : SgExpressionPtrList::iterator iter;
21953 0 : for (iter = p_operands.begin(); iter != p_operands.end(); iter++)
21954 0 : traversalSuccessorContainer.push_back(*iter);
21955 : }
21956 0 : return traversalSuccessorContainer;
21957 : }
21958 : vector<string>
21959 0 : SgNaryComparisonOp::get_traversalSuccessorNamesContainer() {
21960 0 : vector<string> traversalSuccessorContainer;
21961 0 : int i = 0;
21962 0 : {
21963 0 : SgExpressionPtrList::iterator iter;
21964 0 : for (iter = p_operands.begin(); iter != p_operands.end(); (iter++,i++)) {
21965 0 : char buf[20];
21966 0 : sprintf(buf,"*[%d]",i);
21967 0 : traversalSuccessorContainer.push_back(buf);
21968 : }
21969 : }
21970 0 : return traversalSuccessorContainer;
21971 : }
21972 : size_t
21973 0 : SgNaryComparisonOp::get_numberOfTraversalSuccessors() {
21974 0 : return p_operands.size() + 0;
21975 : }
21976 : SgNode *
21977 0 : SgNaryComparisonOp::get_traversalSuccessorByIndex(size_t idx) {
21978 0 : ROSE_ASSERT(idx < p_operands.size());
21979 0 : return p_operands[idx];
21980 : }
21981 : size_t
21982 0 : SgNaryComparisonOp::get_childIndex(SgNode *child) {
21983 0 : SgExpressionPtrList::iterator itr = find(p_operands.begin(), p_operands.end(), child);
21984 0 : if (itr != p_operands.end()) return itr - p_operands.begin();
21985 : else return (size_t) -1;
21986 : }
21987 : vector<SgNode*>
21988 0 : SgStringConversion::get_traversalSuccessorContainer() {
21989 0 : vector<SgNode*> traversalSuccessorContainer;
21990 0 : traversalSuccessorContainer.reserve(1);
21991 0 : traversalSuccessorContainer.push_back(p_expression);
21992 0 : return traversalSuccessorContainer;
21993 : }
21994 : vector<string>
21995 0 : SgStringConversion::get_traversalSuccessorNamesContainer() {
21996 0 : vector<string> traversalSuccessorContainer;
21997 0 : traversalSuccessorContainer.push_back("p_expression");
21998 0 : return traversalSuccessorContainer;
21999 : }
22000 : size_t
22001 0 : SgStringConversion::get_numberOfTraversalSuccessors() {
22002 0 : return 1;
22003 : }
22004 : SgNode *
22005 0 : SgStringConversion::get_traversalSuccessorByIndex(size_t idx) {
22006 0 : switch (idx) {
22007 0 : case 0: ROSE_ASSERT(p_expression == NULL || p_expression != NULL); return p_expression;
22008 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22009 0 : ROSE_ASSERT(false);
22010 : return NULL;
22011 : }
22012 : }
22013 : size_t
22014 0 : SgStringConversion::get_childIndex(SgNode *child) {
22015 0 : if (child == p_expression) return 0;
22016 0 : else return (size_t) -1;
22017 : }
22018 : vector<SgNode*>
22019 0 : SgYieldExpression::get_traversalSuccessorContainer() {
22020 0 : vector<SgNode*> traversalSuccessorContainer;
22021 0 : traversalSuccessorContainer.reserve(1);
22022 0 : traversalSuccessorContainer.push_back(p_value);
22023 0 : return traversalSuccessorContainer;
22024 : }
22025 : vector<string>
22026 0 : SgYieldExpression::get_traversalSuccessorNamesContainer() {
22027 0 : vector<string> traversalSuccessorContainer;
22028 0 : traversalSuccessorContainer.push_back("p_value");
22029 0 : return traversalSuccessorContainer;
22030 : }
22031 : size_t
22032 0 : SgYieldExpression::get_numberOfTraversalSuccessors() {
22033 0 : return 1;
22034 : }
22035 : SgNode *
22036 0 : SgYieldExpression::get_traversalSuccessorByIndex(size_t idx) {
22037 0 : switch (idx) {
22038 0 : case 0: ROSE_ASSERT(p_value == NULL || p_value != NULL); return p_value;
22039 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22040 0 : ROSE_ASSERT(false);
22041 : return NULL;
22042 : }
22043 : }
22044 : size_t
22045 0 : SgYieldExpression::get_childIndex(SgNode *child) {
22046 0 : if (child == p_value) return 0;
22047 0 : else return (size_t) -1;
22048 : }
22049 : vector<SgNode*>
22050 214687 : SgTemplateFunctionRefExp::get_traversalSuccessorContainer() {
22051 214687 : vector<SgNode*> traversalSuccessorContainer;
22052 214687 : return traversalSuccessorContainer;
22053 : }
22054 : vector<string>
22055 3068 : SgTemplateFunctionRefExp::get_traversalSuccessorNamesContainer() {
22056 3068 : vector<string> traversalSuccessorContainer;
22057 3068 : return traversalSuccessorContainer;
22058 : }
22059 : size_t
22060 301101 : SgTemplateFunctionRefExp::get_numberOfTraversalSuccessors() {
22061 301101 : return 0;
22062 : }
22063 : SgNode *
22064 0 : SgTemplateFunctionRefExp::get_traversalSuccessorByIndex(size_t idx) {
22065 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgTemplateFunctionRefExp" << " that has no successors!" << endl;
22066 0 : ROSE_ASSERT(false);
22067 : return NULL;
22068 : }
22069 : size_t
22070 0 : SgTemplateFunctionRefExp::get_childIndex(SgNode *child) {
22071 0 : cout << "error: get_childIndex called on node of type " << "SgTemplateFunctionRefExp" << " that has no successors!" << endl;
22072 0 : ROSE_ASSERT(false);
22073 : return 0;
22074 : }
22075 : vector<SgNode*>
22076 232704 : SgTemplateMemberFunctionRefExp::get_traversalSuccessorContainer() {
22077 232704 : vector<SgNode*> traversalSuccessorContainer;
22078 232704 : return traversalSuccessorContainer;
22079 : }
22080 : vector<string>
22081 9482 : SgTemplateMemberFunctionRefExp::get_traversalSuccessorNamesContainer() {
22082 9482 : vector<string> traversalSuccessorContainer;
22083 9482 : return traversalSuccessorContainer;
22084 : }
22085 : size_t
22086 484815 : SgTemplateMemberFunctionRefExp::get_numberOfTraversalSuccessors() {
22087 484815 : return 0;
22088 : }
22089 : SgNode *
22090 0 : SgTemplateMemberFunctionRefExp::get_traversalSuccessorByIndex(size_t idx) {
22091 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgTemplateMemberFunctionRefExp" << " that has no successors!" << endl;
22092 0 : ROSE_ASSERT(false);
22093 : return NULL;
22094 : }
22095 : size_t
22096 0 : SgTemplateMemberFunctionRefExp::get_childIndex(SgNode *child) {
22097 0 : cout << "error: get_childIndex called on node of type " << "SgTemplateMemberFunctionRefExp" << " that has no successors!" << endl;
22098 0 : ROSE_ASSERT(false);
22099 : return 0;
22100 : }
22101 : vector<SgNode*>
22102 1174 : SgAlignOfOp::get_traversalSuccessorContainer() {
22103 1174 : vector<SgNode*> traversalSuccessorContainer;
22104 1174 : traversalSuccessorContainer.reserve(1);
22105 1174 : traversalSuccessorContainer.push_back(p_operand_expr);
22106 1174 : return traversalSuccessorContainer;
22107 : }
22108 : vector<string>
22109 28 : SgAlignOfOp::get_traversalSuccessorNamesContainer() {
22110 28 : vector<string> traversalSuccessorContainer;
22111 56 : traversalSuccessorContainer.push_back("p_operand_expr");
22112 28 : return traversalSuccessorContainer;
22113 : }
22114 : size_t
22115 1952 : SgAlignOfOp::get_numberOfTraversalSuccessors() {
22116 1952 : return 1;
22117 : }
22118 : SgNode *
22119 1950 : SgAlignOfOp::get_traversalSuccessorByIndex(size_t idx) {
22120 1950 : switch (idx) {
22121 1950 : case 0: ROSE_ASSERT(p_operand_expr == NULL || p_operand_expr != NULL); return p_operand_expr;
22122 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22123 0 : ROSE_ASSERT(false);
22124 : return NULL;
22125 : }
22126 : }
22127 : size_t
22128 0 : SgAlignOfOp::get_childIndex(SgNode *child) {
22129 0 : if (child == p_operand_expr) return 0;
22130 0 : else return (size_t) -1;
22131 : }
22132 : vector<SgNode*>
22133 0 : SgRangeExp::get_traversalSuccessorContainer() {
22134 0 : vector<SgNode*> traversalSuccessorContainer;
22135 0 : traversalSuccessorContainer.reserve(3);
22136 0 : traversalSuccessorContainer.push_back(p_start);
22137 0 : traversalSuccessorContainer.push_back(p_end);
22138 0 : traversalSuccessorContainer.push_back(p_stride);
22139 0 : return traversalSuccessorContainer;
22140 : }
22141 : vector<string>
22142 0 : SgRangeExp::get_traversalSuccessorNamesContainer() {
22143 0 : vector<string> traversalSuccessorContainer;
22144 0 : traversalSuccessorContainer.push_back("p_start");
22145 0 : traversalSuccessorContainer.push_back("p_end");
22146 0 : traversalSuccessorContainer.push_back("p_stride");
22147 0 : return traversalSuccessorContainer;
22148 : }
22149 : size_t
22150 0 : SgRangeExp::get_numberOfTraversalSuccessors() {
22151 0 : return 3;
22152 : }
22153 : SgNode *
22154 0 : SgRangeExp::get_traversalSuccessorByIndex(size_t idx) {
22155 0 : switch (idx) {
22156 0 : case 0: ROSE_ASSERT(p_start == NULL || p_start != NULL); return p_start;
22157 0 : case 1: ROSE_ASSERT(p_end == NULL || p_end != NULL); return p_end;
22158 0 : case 2: ROSE_ASSERT(p_stride == NULL || p_stride != NULL); return p_stride;
22159 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22160 0 : ROSE_ASSERT(false);
22161 : return NULL;
22162 : }
22163 : }
22164 : size_t
22165 0 : SgRangeExp::get_childIndex(SgNode *child) {
22166 0 : if (child == p_start) return 0;
22167 0 : else if (child == p_end) return 1;
22168 0 : else if (child == p_stride) return 2;
22169 0 : else return (size_t) -1;
22170 : }
22171 : vector<SgNode*>
22172 0 : SgMagicColonExp::get_traversalSuccessorContainer() {
22173 0 : vector<SgNode*> traversalSuccessorContainer;
22174 0 : return traversalSuccessorContainer;
22175 : }
22176 : vector<string>
22177 0 : SgMagicColonExp::get_traversalSuccessorNamesContainer() {
22178 0 : vector<string> traversalSuccessorContainer;
22179 0 : return traversalSuccessorContainer;
22180 : }
22181 : size_t
22182 0 : SgMagicColonExp::get_numberOfTraversalSuccessors() {
22183 0 : return 0;
22184 : }
22185 : SgNode *
22186 0 : SgMagicColonExp::get_traversalSuccessorByIndex(size_t idx) {
22187 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgMagicColonExp" << " that has no successors!" << endl;
22188 0 : ROSE_ASSERT(false);
22189 : return NULL;
22190 : }
22191 : size_t
22192 0 : SgMagicColonExp::get_childIndex(SgNode *child) {
22193 0 : cout << "error: get_childIndex called on node of type " << "SgMagicColonExp" << " that has no successors!" << endl;
22194 0 : ROSE_ASSERT(false);
22195 : return 0;
22196 : }
22197 : vector<SgNode*>
22198 2129 : SgTypeTraitBuiltinOperator::get_traversalSuccessorContainer() {
22199 2129 : vector<SgNode*> traversalSuccessorContainer;
22200 2129 : return traversalSuccessorContainer;
22201 : }
22202 : vector<string>
22203 138 : SgTypeTraitBuiltinOperator::get_traversalSuccessorNamesContainer() {
22204 138 : vector<string> traversalSuccessorContainer;
22205 138 : return traversalSuccessorContainer;
22206 : }
22207 : size_t
22208 5757 : SgTypeTraitBuiltinOperator::get_numberOfTraversalSuccessors() {
22209 5757 : return 0;
22210 : }
22211 : SgNode *
22212 0 : SgTypeTraitBuiltinOperator::get_traversalSuccessorByIndex(size_t idx) {
22213 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgTypeTraitBuiltinOperator" << " that has no successors!" << endl;
22214 0 : ROSE_ASSERT(false);
22215 : return NULL;
22216 : }
22217 : size_t
22218 0 : SgTypeTraitBuiltinOperator::get_childIndex(SgNode *child) {
22219 0 : cout << "error: get_childIndex called on node of type " << "SgTypeTraitBuiltinOperator" << " that has no successors!" << endl;
22220 0 : ROSE_ASSERT(false);
22221 : return 0;
22222 : }
22223 : vector<SgNode*>
22224 0 : SgCompoundLiteralExp::get_traversalSuccessorContainer() {
22225 0 : vector<SgNode*> traversalSuccessorContainer;
22226 0 : return traversalSuccessorContainer;
22227 : }
22228 : vector<string>
22229 0 : SgCompoundLiteralExp::get_traversalSuccessorNamesContainer() {
22230 0 : vector<string> traversalSuccessorContainer;
22231 0 : return traversalSuccessorContainer;
22232 : }
22233 : size_t
22234 0 : SgCompoundLiteralExp::get_numberOfTraversalSuccessors() {
22235 0 : return 0;
22236 : }
22237 : SgNode *
22238 0 : SgCompoundLiteralExp::get_traversalSuccessorByIndex(size_t idx) {
22239 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgCompoundLiteralExp" << " that has no successors!" << endl;
22240 0 : ROSE_ASSERT(false);
22241 : return NULL;
22242 : }
22243 : size_t
22244 0 : SgCompoundLiteralExp::get_childIndex(SgNode *child) {
22245 0 : cout << "error: get_childIndex called on node of type " << "SgCompoundLiteralExp" << " that has no successors!" << endl;
22246 0 : ROSE_ASSERT(false);
22247 : return 0;
22248 : }
22249 : vector<SgNode*>
22250 0 : SgTypeExpression::get_traversalSuccessorContainer() {
22251 0 : vector<SgNode*> traversalSuccessorContainer;
22252 0 : return traversalSuccessorContainer;
22253 : }
22254 : vector<string>
22255 0 : SgTypeExpression::get_traversalSuccessorNamesContainer() {
22256 0 : vector<string> traversalSuccessorContainer;
22257 0 : return traversalSuccessorContainer;
22258 : }
22259 : size_t
22260 0 : SgTypeExpression::get_numberOfTraversalSuccessors() {
22261 0 : return 0;
22262 : }
22263 : SgNode *
22264 0 : SgTypeExpression::get_traversalSuccessorByIndex(size_t idx) {
22265 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgTypeExpression" << " that has no successors!" << endl;
22266 0 : ROSE_ASSERT(false);
22267 : return NULL;
22268 : }
22269 : size_t
22270 0 : SgTypeExpression::get_childIndex(SgNode *child) {
22271 0 : cout << "error: get_childIndex called on node of type " << "SgTypeExpression" << " that has no successors!" << endl;
22272 0 : ROSE_ASSERT(false);
22273 : return 0;
22274 : }
22275 : vector<SgNode*>
22276 0 : SgClassExp::get_traversalSuccessorContainer() {
22277 0 : vector<SgNode*> traversalSuccessorContainer;
22278 0 : return traversalSuccessorContainer;
22279 : }
22280 : vector<string>
22281 0 : SgClassExp::get_traversalSuccessorNamesContainer() {
22282 0 : vector<string> traversalSuccessorContainer;
22283 0 : return traversalSuccessorContainer;
22284 : }
22285 : size_t
22286 0 : SgClassExp::get_numberOfTraversalSuccessors() {
22287 0 : return 0;
22288 : }
22289 : SgNode *
22290 0 : SgClassExp::get_traversalSuccessorByIndex(size_t idx) {
22291 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgClassExp" << " that has no successors!" << endl;
22292 0 : ROSE_ASSERT(false);
22293 : return NULL;
22294 : }
22295 : size_t
22296 0 : SgClassExp::get_childIndex(SgNode *child) {
22297 0 : cout << "error: get_childIndex called on node of type " << "SgClassExp" << " that has no successors!" << endl;
22298 0 : ROSE_ASSERT(false);
22299 : return 0;
22300 : }
22301 : vector<SgNode*>
22302 0 : SgFunctionParameterRefExp::get_traversalSuccessorContainer() {
22303 0 : vector<SgNode*> traversalSuccessorContainer;
22304 0 : traversalSuccessorContainer.reserve(1);
22305 0 : traversalSuccessorContainer.push_back(p_parameter_expression);
22306 0 : return traversalSuccessorContainer;
22307 : }
22308 : vector<string>
22309 0 : SgFunctionParameterRefExp::get_traversalSuccessorNamesContainer() {
22310 0 : vector<string> traversalSuccessorContainer;
22311 0 : traversalSuccessorContainer.push_back("p_parameter_expression");
22312 0 : return traversalSuccessorContainer;
22313 : }
22314 : size_t
22315 1020 : SgFunctionParameterRefExp::get_numberOfTraversalSuccessors() {
22316 1020 : return 1;
22317 : }
22318 : SgNode *
22319 1020 : SgFunctionParameterRefExp::get_traversalSuccessorByIndex(size_t idx) {
22320 1020 : switch (idx) {
22321 1020 : case 0: ROSE_ASSERT(p_parameter_expression == NULL || p_parameter_expression != NULL); return p_parameter_expression;
22322 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22323 0 : ROSE_ASSERT(false);
22324 : return NULL;
22325 : }
22326 : }
22327 : size_t
22328 0 : SgFunctionParameterRefExp::get_childIndex(SgNode *child) {
22329 0 : if (child == p_parameter_expression) return 0;
22330 0 : else return (size_t) -1;
22331 : }
22332 : vector<SgNode*>
22333 0 : SgLambdaExp::get_traversalSuccessorContainer() {
22334 0 : vector<SgNode*> traversalSuccessorContainer;
22335 0 : traversalSuccessorContainer.reserve(3);
22336 0 : traversalSuccessorContainer.push_back(p_lambda_capture_list);
22337 0 : traversalSuccessorContainer.push_back(p_lambda_closure_class);
22338 0 : traversalSuccessorContainer.push_back(p_lambda_function);
22339 0 : return traversalSuccessorContainer;
22340 : }
22341 : vector<string>
22342 0 : SgLambdaExp::get_traversalSuccessorNamesContainer() {
22343 0 : vector<string> traversalSuccessorContainer;
22344 0 : traversalSuccessorContainer.push_back("p_lambda_capture_list");
22345 0 : traversalSuccessorContainer.push_back("p_lambda_closure_class");
22346 0 : traversalSuccessorContainer.push_back("p_lambda_function");
22347 0 : return traversalSuccessorContainer;
22348 : }
22349 : size_t
22350 0 : SgLambdaExp::get_numberOfTraversalSuccessors() {
22351 0 : return 3;
22352 : }
22353 : SgNode *
22354 0 : SgLambdaExp::get_traversalSuccessorByIndex(size_t idx) {
22355 0 : switch (idx) {
22356 0 : case 0: ROSE_ASSERT(p_lambda_capture_list == NULL || p_lambda_capture_list != NULL); return p_lambda_capture_list;
22357 0 : case 1: ROSE_ASSERT(p_lambda_closure_class == NULL || p_lambda_closure_class != NULL); return p_lambda_closure_class;
22358 0 : case 2: ROSE_ASSERT(p_lambda_function == NULL || p_lambda_function != NULL); return p_lambda_function;
22359 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22360 0 : ROSE_ASSERT(false);
22361 : return NULL;
22362 : }
22363 : }
22364 : size_t
22365 0 : SgLambdaExp::get_childIndex(SgNode *child) {
22366 0 : if (child == p_lambda_capture_list) return 0;
22367 0 : else if (child == p_lambda_closure_class) return 1;
22368 0 : else if (child == p_lambda_function) return 2;
22369 0 : else return (size_t) -1;
22370 : }
22371 : vector<SgNode*>
22372 3704 : SgNoexceptOp::get_traversalSuccessorContainer() {
22373 3704 : vector<SgNode*> traversalSuccessorContainer;
22374 3704 : traversalSuccessorContainer.reserve(1);
22375 3704 : traversalSuccessorContainer.push_back(p_operand_expr);
22376 3704 : return traversalSuccessorContainer;
22377 : }
22378 : vector<string>
22379 72 : SgNoexceptOp::get_traversalSuccessorNamesContainer() {
22380 72 : vector<string> traversalSuccessorContainer;
22381 144 : traversalSuccessorContainer.push_back("p_operand_expr");
22382 72 : return traversalSuccessorContainer;
22383 : }
22384 : size_t
22385 5682 : SgNoexceptOp::get_numberOfTraversalSuccessors() {
22386 5682 : return 1;
22387 : }
22388 : SgNode *
22389 5676 : SgNoexceptOp::get_traversalSuccessorByIndex(size_t idx) {
22390 5676 : switch (idx) {
22391 5676 : case 0: ROSE_ASSERT(p_operand_expr == NULL || p_operand_expr != NULL); return p_operand_expr;
22392 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22393 0 : ROSE_ASSERT(false);
22394 : return NULL;
22395 : }
22396 : }
22397 : size_t
22398 0 : SgNoexceptOp::get_childIndex(SgNode *child) {
22399 0 : if (child == p_operand_expr) return 0;
22400 0 : else return (size_t) -1;
22401 : }
22402 : vector<SgNode*>
22403 634832 : SgNonrealRefExp::get_traversalSuccessorContainer() {
22404 634832 : vector<SgNode*> traversalSuccessorContainer;
22405 634832 : return traversalSuccessorContainer;
22406 : }
22407 : vector<string>
22408 15242 : SgNonrealRefExp::get_traversalSuccessorNamesContainer() {
22409 15242 : vector<string> traversalSuccessorContainer;
22410 15242 : return traversalSuccessorContainer;
22411 : }
22412 : size_t
22413 1066060 : SgNonrealRefExp::get_numberOfTraversalSuccessors() {
22414 1066060 : return 0;
22415 : }
22416 : SgNode *
22417 0 : SgNonrealRefExp::get_traversalSuccessorByIndex(size_t idx) {
22418 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgNonrealRefExp" << " that has no successors!" << endl;
22419 0 : ROSE_ASSERT(false);
22420 : return NULL;
22421 : }
22422 : size_t
22423 0 : SgNonrealRefExp::get_childIndex(SgNode *child) {
22424 0 : cout << "error: get_childIndex called on node of type " << "SgNonrealRefExp" << " that has no successors!" << endl;
22425 0 : ROSE_ASSERT(false);
22426 : return 0;
22427 : }
22428 : vector<SgNode*>
22429 0 : SgFoldExpression::get_traversalSuccessorContainer() {
22430 0 : vector<SgNode*> traversalSuccessorContainer;
22431 0 : traversalSuccessorContainer.reserve(1);
22432 0 : traversalSuccessorContainer.push_back(p_operands);
22433 0 : return traversalSuccessorContainer;
22434 : }
22435 : vector<string>
22436 0 : SgFoldExpression::get_traversalSuccessorNamesContainer() {
22437 0 : vector<string> traversalSuccessorContainer;
22438 0 : traversalSuccessorContainer.push_back("p_operands");
22439 0 : return traversalSuccessorContainer;
22440 : }
22441 : size_t
22442 0 : SgFoldExpression::get_numberOfTraversalSuccessors() {
22443 0 : return 1;
22444 : }
22445 : SgNode *
22446 0 : SgFoldExpression::get_traversalSuccessorByIndex(size_t idx) {
22447 0 : switch (idx) {
22448 0 : case 0: ROSE_ASSERT(p_operands == NULL || p_operands != NULL); return p_operands;
22449 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22450 0 : ROSE_ASSERT(false);
22451 : return NULL;
22452 : }
22453 : }
22454 : size_t
22455 0 : SgFoldExpression::get_childIndex(SgNode *child) {
22456 0 : if (child == p_operands) return 0;
22457 0 : else return (size_t) -1;
22458 : }
22459 : vector<SgNode*>
22460 0 : SgAwaitExpression::get_traversalSuccessorContainer() {
22461 0 : vector<SgNode*> traversalSuccessorContainer;
22462 0 : traversalSuccessorContainer.reserve(1);
22463 0 : traversalSuccessorContainer.push_back(p_value);
22464 0 : return traversalSuccessorContainer;
22465 : }
22466 : vector<string>
22467 0 : SgAwaitExpression::get_traversalSuccessorNamesContainer() {
22468 0 : vector<string> traversalSuccessorContainer;
22469 0 : traversalSuccessorContainer.push_back("p_value");
22470 0 : return traversalSuccessorContainer;
22471 : }
22472 : size_t
22473 0 : SgAwaitExpression::get_numberOfTraversalSuccessors() {
22474 0 : return 1;
22475 : }
22476 : SgNode *
22477 0 : SgAwaitExpression::get_traversalSuccessorByIndex(size_t idx) {
22478 0 : switch (idx) {
22479 0 : case 0: ROSE_ASSERT(p_value == NULL || p_value != NULL); return p_value;
22480 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22481 0 : ROSE_ASSERT(false);
22482 : return NULL;
22483 : }
22484 : }
22485 : size_t
22486 0 : SgAwaitExpression::get_childIndex(SgNode *child) {
22487 0 : if (child == p_value) return 0;
22488 0 : else return (size_t) -1;
22489 : }
22490 : vector<SgNode*>
22491 0 : SgChooseExpression::get_traversalSuccessorContainer() {
22492 0 : vector<SgNode*> traversalSuccessorContainer;
22493 0 : traversalSuccessorContainer.reserve(1);
22494 0 : traversalSuccessorContainer.push_back(p_value);
22495 0 : return traversalSuccessorContainer;
22496 : }
22497 : vector<string>
22498 0 : SgChooseExpression::get_traversalSuccessorNamesContainer() {
22499 0 : vector<string> traversalSuccessorContainer;
22500 0 : traversalSuccessorContainer.push_back("p_value");
22501 0 : return traversalSuccessorContainer;
22502 : }
22503 : size_t
22504 0 : SgChooseExpression::get_numberOfTraversalSuccessors() {
22505 0 : return 1;
22506 : }
22507 : SgNode *
22508 0 : SgChooseExpression::get_traversalSuccessorByIndex(size_t idx) {
22509 0 : switch (idx) {
22510 0 : case 0: ROSE_ASSERT(p_value == NULL || p_value != NULL); return p_value;
22511 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22512 0 : ROSE_ASSERT(false);
22513 : return NULL;
22514 : }
22515 : }
22516 : size_t
22517 0 : SgChooseExpression::get_childIndex(SgNode *child) {
22518 0 : if (child == p_value) return 0;
22519 0 : else return (size_t) -1;
22520 : }
22521 : vector<SgNode*>
22522 0 : SgSymbol::get_traversalSuccessorContainer() {
22523 0 : vector<SgNode*> traversalSuccessorContainer;
22524 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
22525 0 : << "static: SgSymbol" << endl << "dynamic: " << this->sage_class_name() << endl;
22526 0 : cerr << "Aborting ..." << endl;
22527 0 : ROSE_ASSERT(false);
22528 : return traversalSuccessorContainer;
22529 : }
22530 :
22531 : vector<string>
22532 0 : SgSymbol::get_traversalSuccessorNamesContainer() {
22533 0 : vector<string> traversalSuccessorContainer;
22534 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
22535 0 : << "static: SgSymbol" << endl << "dynamic: " << this->sage_class_name() << endl;
22536 0 : cerr << "Aborting ..." << endl;
22537 0 : ROSE_ASSERT(false);
22538 : return traversalSuccessorContainer;
22539 : }
22540 :
22541 : size_t
22542 0 : SgSymbol::get_numberOfTraversalSuccessors() {
22543 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
22544 0 : << "static: SgSymbol" << endl << "dynamic: this = " << this << " = " << this->sage_class_name() << endl;
22545 0 : cerr << "Aborting ..." << endl;
22546 0 : ROSE_ASSERT(false);
22547 : return 42;
22548 : }
22549 :
22550 : SgNode*
22551 0 : SgSymbol::get_traversalSuccessorByIndex(size_t) {
22552 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
22553 0 : << "static: SgSymbol" << endl << "dynamic: " << this->sage_class_name() << endl;
22554 0 : cerr << "Aborting ..." << endl;
22555 0 : ROSE_ASSERT(false);
22556 : return NULL;
22557 : }
22558 :
22559 : size_t
22560 0 : SgSymbol::get_childIndex(SgNode *) {
22561 0 : cerr << "Internal error(!): called tree traversal mechanism for illegal object: " << endl
22562 0 : << "static: SgSymbol" << endl << "dynamic: " << this->sage_class_name() << endl;
22563 0 : cerr << "Aborting ..." << endl;
22564 0 : ROSE_ASSERT(false);
22565 : return 42;
22566 : }
22567 :
22568 : vector<SgNode*>
22569 0 : SgVariableSymbol::get_traversalSuccessorContainer() {
22570 0 : vector<SgNode*> traversalSuccessorContainer;
22571 0 : return traversalSuccessorContainer;
22572 : }
22573 : vector<string>
22574 0 : SgVariableSymbol::get_traversalSuccessorNamesContainer() {
22575 0 : vector<string> traversalSuccessorContainer;
22576 0 : return traversalSuccessorContainer;
22577 : }
22578 : size_t
22579 0 : SgVariableSymbol::get_numberOfTraversalSuccessors() {
22580 0 : return 0;
22581 : }
22582 : SgNode *
22583 0 : SgVariableSymbol::get_traversalSuccessorByIndex(size_t idx) {
22584 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgVariableSymbol" << " that has no successors!" << endl;
22585 0 : ROSE_ASSERT(false);
22586 : return NULL;
22587 : }
22588 : size_t
22589 0 : SgVariableSymbol::get_childIndex(SgNode *child) {
22590 0 : cout << "error: get_childIndex called on node of type " << "SgVariableSymbol" << " that has no successors!" << endl;
22591 0 : ROSE_ASSERT(false);
22592 : return 0;
22593 : }
22594 : vector<SgNode*>
22595 0 : SgTemplateVariableSymbol::get_traversalSuccessorContainer() {
22596 0 : vector<SgNode*> traversalSuccessorContainer;
22597 0 : return traversalSuccessorContainer;
22598 : }
22599 : vector<string>
22600 0 : SgTemplateVariableSymbol::get_traversalSuccessorNamesContainer() {
22601 0 : vector<string> traversalSuccessorContainer;
22602 0 : return traversalSuccessorContainer;
22603 : }
22604 : size_t
22605 0 : SgTemplateVariableSymbol::get_numberOfTraversalSuccessors() {
22606 0 : return 0;
22607 : }
22608 : SgNode *
22609 0 : SgTemplateVariableSymbol::get_traversalSuccessorByIndex(size_t idx) {
22610 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgTemplateVariableSymbol" << " that has no successors!" << endl;
22611 0 : ROSE_ASSERT(false);
22612 : return NULL;
22613 : }
22614 : size_t
22615 0 : SgTemplateVariableSymbol::get_childIndex(SgNode *child) {
22616 0 : cout << "error: get_childIndex called on node of type " << "SgTemplateVariableSymbol" << " that has no successors!" << endl;
22617 0 : ROSE_ASSERT(false);
22618 : return 0;
22619 : }
22620 : vector<SgNode*>
22621 0 : SgNonrealSymbol::get_traversalSuccessorContainer() {
22622 0 : vector<SgNode*> traversalSuccessorContainer;
22623 0 : traversalSuccessorContainer.reserve(1);
22624 0 : traversalSuccessorContainer.push_back(p_declaration);
22625 0 : return traversalSuccessorContainer;
22626 : }
22627 : vector<string>
22628 0 : SgNonrealSymbol::get_traversalSuccessorNamesContainer() {
22629 0 : vector<string> traversalSuccessorContainer;
22630 0 : traversalSuccessorContainer.push_back("p_declaration");
22631 0 : return traversalSuccessorContainer;
22632 : }
22633 : size_t
22634 0 : SgNonrealSymbol::get_numberOfTraversalSuccessors() {
22635 0 : return 1;
22636 : }
22637 : SgNode *
22638 0 : SgNonrealSymbol::get_traversalSuccessorByIndex(size_t idx) {
22639 0 : switch (idx) {
22640 0 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
22641 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22642 0 : ROSE_ASSERT(false);
22643 : return NULL;
22644 : }
22645 : }
22646 : size_t
22647 0 : SgNonrealSymbol::get_childIndex(SgNode *child) {
22648 0 : if (child == p_declaration) return 0;
22649 0 : else return (size_t) -1;
22650 : }
22651 : vector<SgNode*>
22652 0 : SgFunctionSymbol::get_traversalSuccessorContainer() {
22653 0 : vector<SgNode*> traversalSuccessorContainer;
22654 0 : traversalSuccessorContainer.reserve(1);
22655 0 : traversalSuccessorContainer.push_back(p_declaration);
22656 0 : return traversalSuccessorContainer;
22657 : }
22658 : vector<string>
22659 0 : SgFunctionSymbol::get_traversalSuccessorNamesContainer() {
22660 0 : vector<string> traversalSuccessorContainer;
22661 0 : traversalSuccessorContainer.push_back("p_declaration");
22662 0 : return traversalSuccessorContainer;
22663 : }
22664 : size_t
22665 0 : SgFunctionSymbol::get_numberOfTraversalSuccessors() {
22666 0 : return 1;
22667 : }
22668 : SgNode *
22669 0 : SgFunctionSymbol::get_traversalSuccessorByIndex(size_t idx) {
22670 0 : switch (idx) {
22671 0 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
22672 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22673 0 : ROSE_ASSERT(false);
22674 : return NULL;
22675 : }
22676 : }
22677 : size_t
22678 0 : SgFunctionSymbol::get_childIndex(SgNode *child) {
22679 0 : if (child == p_declaration) return 0;
22680 0 : else return (size_t) -1;
22681 : }
22682 : vector<SgNode*>
22683 0 : SgMemberFunctionSymbol::get_traversalSuccessorContainer() {
22684 0 : vector<SgNode*> traversalSuccessorContainer;
22685 0 : traversalSuccessorContainer.reserve(1);
22686 0 : traversalSuccessorContainer.push_back(p_declaration);
22687 0 : return traversalSuccessorContainer;
22688 : }
22689 : vector<string>
22690 0 : SgMemberFunctionSymbol::get_traversalSuccessorNamesContainer() {
22691 0 : vector<string> traversalSuccessorContainer;
22692 0 : traversalSuccessorContainer.push_back("p_declaration");
22693 0 : return traversalSuccessorContainer;
22694 : }
22695 : size_t
22696 0 : SgMemberFunctionSymbol::get_numberOfTraversalSuccessors() {
22697 0 : return 1;
22698 : }
22699 : SgNode *
22700 0 : SgMemberFunctionSymbol::get_traversalSuccessorByIndex(size_t idx) {
22701 0 : switch (idx) {
22702 0 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
22703 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22704 0 : ROSE_ASSERT(false);
22705 : return NULL;
22706 : }
22707 : }
22708 : size_t
22709 0 : SgMemberFunctionSymbol::get_childIndex(SgNode *child) {
22710 0 : if (child == p_declaration) return 0;
22711 0 : else return (size_t) -1;
22712 : }
22713 : vector<SgNode*>
22714 0 : SgTemplateMemberFunctionSymbol::get_traversalSuccessorContainer() {
22715 0 : vector<SgNode*> traversalSuccessorContainer;
22716 0 : traversalSuccessorContainer.reserve(1);
22717 0 : traversalSuccessorContainer.push_back(p_declaration);
22718 0 : return traversalSuccessorContainer;
22719 : }
22720 : vector<string>
22721 0 : SgTemplateMemberFunctionSymbol::get_traversalSuccessorNamesContainer() {
22722 0 : vector<string> traversalSuccessorContainer;
22723 0 : traversalSuccessorContainer.push_back("p_declaration");
22724 0 : return traversalSuccessorContainer;
22725 : }
22726 : size_t
22727 0 : SgTemplateMemberFunctionSymbol::get_numberOfTraversalSuccessors() {
22728 0 : return 1;
22729 : }
22730 : SgNode *
22731 0 : SgTemplateMemberFunctionSymbol::get_traversalSuccessorByIndex(size_t idx) {
22732 0 : switch (idx) {
22733 0 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
22734 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22735 0 : ROSE_ASSERT(false);
22736 : return NULL;
22737 : }
22738 : }
22739 : size_t
22740 0 : SgTemplateMemberFunctionSymbol::get_childIndex(SgNode *child) {
22741 0 : if (child == p_declaration) return 0;
22742 0 : else return (size_t) -1;
22743 : }
22744 : vector<SgNode*>
22745 0 : SgTemplateFunctionSymbol::get_traversalSuccessorContainer() {
22746 0 : vector<SgNode*> traversalSuccessorContainer;
22747 0 : traversalSuccessorContainer.reserve(1);
22748 0 : traversalSuccessorContainer.push_back(p_declaration);
22749 0 : return traversalSuccessorContainer;
22750 : }
22751 : vector<string>
22752 0 : SgTemplateFunctionSymbol::get_traversalSuccessorNamesContainer() {
22753 0 : vector<string> traversalSuccessorContainer;
22754 0 : traversalSuccessorContainer.push_back("p_declaration");
22755 0 : return traversalSuccessorContainer;
22756 : }
22757 : size_t
22758 0 : SgTemplateFunctionSymbol::get_numberOfTraversalSuccessors() {
22759 0 : return 1;
22760 : }
22761 : SgNode *
22762 0 : SgTemplateFunctionSymbol::get_traversalSuccessorByIndex(size_t idx) {
22763 0 : switch (idx) {
22764 0 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
22765 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22766 0 : ROSE_ASSERT(false);
22767 : return NULL;
22768 : }
22769 : }
22770 : size_t
22771 0 : SgTemplateFunctionSymbol::get_childIndex(SgNode *child) {
22772 0 : if (child == p_declaration) return 0;
22773 0 : else return (size_t) -1;
22774 : }
22775 : vector<SgNode*>
22776 0 : SgRenameSymbol::get_traversalSuccessorContainer() {
22777 0 : vector<SgNode*> traversalSuccessorContainer;
22778 0 : traversalSuccessorContainer.reserve(2);
22779 0 : traversalSuccessorContainer.push_back(p_declaration);
22780 0 : traversalSuccessorContainer.push_back(p_original_symbol);
22781 0 : return traversalSuccessorContainer;
22782 : }
22783 : vector<string>
22784 0 : SgRenameSymbol::get_traversalSuccessorNamesContainer() {
22785 0 : vector<string> traversalSuccessorContainer;
22786 0 : traversalSuccessorContainer.push_back("p_declaration");
22787 0 : traversalSuccessorContainer.push_back("p_original_symbol");
22788 0 : return traversalSuccessorContainer;
22789 : }
22790 : size_t
22791 0 : SgRenameSymbol::get_numberOfTraversalSuccessors() {
22792 0 : return 2;
22793 : }
22794 : SgNode *
22795 0 : SgRenameSymbol::get_traversalSuccessorByIndex(size_t idx) {
22796 0 : switch (idx) {
22797 0 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
22798 0 : case 1: ROSE_ASSERT(p_original_symbol == NULL || p_original_symbol != NULL); return p_original_symbol;
22799 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22800 0 : ROSE_ASSERT(false);
22801 : return NULL;
22802 : }
22803 : }
22804 : size_t
22805 0 : SgRenameSymbol::get_childIndex(SgNode *child) {
22806 0 : if (child == p_declaration) return 0;
22807 0 : else if (child == p_original_symbol) return 1;
22808 0 : else return (size_t) -1;
22809 : }
22810 : vector<SgNode*>
22811 0 : SgFunctionTypeSymbol::get_traversalSuccessorContainer() {
22812 0 : vector<SgNode*> traversalSuccessorContainer;
22813 0 : return traversalSuccessorContainer;
22814 : }
22815 : vector<string>
22816 0 : SgFunctionTypeSymbol::get_traversalSuccessorNamesContainer() {
22817 0 : vector<string> traversalSuccessorContainer;
22818 0 : return traversalSuccessorContainer;
22819 : }
22820 : size_t
22821 0 : SgFunctionTypeSymbol::get_numberOfTraversalSuccessors() {
22822 0 : return 0;
22823 : }
22824 : SgNode *
22825 0 : SgFunctionTypeSymbol::get_traversalSuccessorByIndex(size_t idx) {
22826 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgFunctionTypeSymbol" << " that has no successors!" << endl;
22827 0 : ROSE_ASSERT(false);
22828 : return NULL;
22829 : }
22830 : size_t
22831 0 : SgFunctionTypeSymbol::get_childIndex(SgNode *child) {
22832 0 : cout << "error: get_childIndex called on node of type " << "SgFunctionTypeSymbol" << " that has no successors!" << endl;
22833 0 : ROSE_ASSERT(false);
22834 : return 0;
22835 : }
22836 : vector<SgNode*>
22837 0 : SgClassSymbol::get_traversalSuccessorContainer() {
22838 0 : vector<SgNode*> traversalSuccessorContainer;
22839 0 : traversalSuccessorContainer.reserve(1);
22840 0 : traversalSuccessorContainer.push_back(p_declaration);
22841 0 : return traversalSuccessorContainer;
22842 : }
22843 : vector<string>
22844 0 : SgClassSymbol::get_traversalSuccessorNamesContainer() {
22845 0 : vector<string> traversalSuccessorContainer;
22846 0 : traversalSuccessorContainer.push_back("p_declaration");
22847 0 : return traversalSuccessorContainer;
22848 : }
22849 : size_t
22850 0 : SgClassSymbol::get_numberOfTraversalSuccessors() {
22851 0 : return 1;
22852 : }
22853 : SgNode *
22854 0 : SgClassSymbol::get_traversalSuccessorByIndex(size_t idx) {
22855 0 : switch (idx) {
22856 0 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
22857 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22858 0 : ROSE_ASSERT(false);
22859 : return NULL;
22860 : }
22861 : }
22862 : size_t
22863 0 : SgClassSymbol::get_childIndex(SgNode *child) {
22864 0 : if (child == p_declaration) return 0;
22865 0 : else return (size_t) -1;
22866 : }
22867 : vector<SgNode*>
22868 0 : SgTemplateClassSymbol::get_traversalSuccessorContainer() {
22869 0 : vector<SgNode*> traversalSuccessorContainer;
22870 0 : traversalSuccessorContainer.reserve(1);
22871 0 : traversalSuccessorContainer.push_back(p_declaration);
22872 0 : return traversalSuccessorContainer;
22873 : }
22874 : vector<string>
22875 0 : SgTemplateClassSymbol::get_traversalSuccessorNamesContainer() {
22876 0 : vector<string> traversalSuccessorContainer;
22877 0 : traversalSuccessorContainer.push_back("p_declaration");
22878 0 : return traversalSuccessorContainer;
22879 : }
22880 : size_t
22881 0 : SgTemplateClassSymbol::get_numberOfTraversalSuccessors() {
22882 0 : return 1;
22883 : }
22884 : SgNode *
22885 0 : SgTemplateClassSymbol::get_traversalSuccessorByIndex(size_t idx) {
22886 0 : switch (idx) {
22887 0 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
22888 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22889 0 : ROSE_ASSERT(false);
22890 : return NULL;
22891 : }
22892 : }
22893 : size_t
22894 0 : SgTemplateClassSymbol::get_childIndex(SgNode *child) {
22895 0 : if (child == p_declaration) return 0;
22896 0 : else return (size_t) -1;
22897 : }
22898 : vector<SgNode*>
22899 0 : SgTemplateSymbol::get_traversalSuccessorContainer() {
22900 0 : vector<SgNode*> traversalSuccessorContainer;
22901 0 : traversalSuccessorContainer.reserve(1);
22902 0 : traversalSuccessorContainer.push_back(p_declaration);
22903 0 : return traversalSuccessorContainer;
22904 : }
22905 : vector<string>
22906 0 : SgTemplateSymbol::get_traversalSuccessorNamesContainer() {
22907 0 : vector<string> traversalSuccessorContainer;
22908 0 : traversalSuccessorContainer.push_back("p_declaration");
22909 0 : return traversalSuccessorContainer;
22910 : }
22911 : size_t
22912 0 : SgTemplateSymbol::get_numberOfTraversalSuccessors() {
22913 0 : return 1;
22914 : }
22915 : SgNode *
22916 0 : SgTemplateSymbol::get_traversalSuccessorByIndex(size_t idx) {
22917 0 : switch (idx) {
22918 0 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
22919 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22920 0 : ROSE_ASSERT(false);
22921 : return NULL;
22922 : }
22923 : }
22924 : size_t
22925 0 : SgTemplateSymbol::get_childIndex(SgNode *child) {
22926 0 : if (child == p_declaration) return 0;
22927 0 : else return (size_t) -1;
22928 : }
22929 : vector<SgNode*>
22930 0 : SgEnumSymbol::get_traversalSuccessorContainer() {
22931 0 : vector<SgNode*> traversalSuccessorContainer;
22932 0 : traversalSuccessorContainer.reserve(1);
22933 0 : traversalSuccessorContainer.push_back(p_declaration);
22934 0 : return traversalSuccessorContainer;
22935 : }
22936 : vector<string>
22937 0 : SgEnumSymbol::get_traversalSuccessorNamesContainer() {
22938 0 : vector<string> traversalSuccessorContainer;
22939 0 : traversalSuccessorContainer.push_back("p_declaration");
22940 0 : return traversalSuccessorContainer;
22941 : }
22942 : size_t
22943 0 : SgEnumSymbol::get_numberOfTraversalSuccessors() {
22944 0 : return 1;
22945 : }
22946 : SgNode *
22947 0 : SgEnumSymbol::get_traversalSuccessorByIndex(size_t idx) {
22948 0 : switch (idx) {
22949 0 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
22950 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
22951 0 : ROSE_ASSERT(false);
22952 : return NULL;
22953 : }
22954 : }
22955 : size_t
22956 0 : SgEnumSymbol::get_childIndex(SgNode *child) {
22957 0 : if (child == p_declaration) return 0;
22958 0 : else return (size_t) -1;
22959 : }
22960 : vector<SgNode*>
22961 0 : SgEnumFieldSymbol::get_traversalSuccessorContainer() {
22962 0 : vector<SgNode*> traversalSuccessorContainer;
22963 0 : return traversalSuccessorContainer;
22964 : }
22965 : vector<string>
22966 0 : SgEnumFieldSymbol::get_traversalSuccessorNamesContainer() {
22967 0 : vector<string> traversalSuccessorContainer;
22968 0 : return traversalSuccessorContainer;
22969 : }
22970 : size_t
22971 0 : SgEnumFieldSymbol::get_numberOfTraversalSuccessors() {
22972 0 : return 0;
22973 : }
22974 : SgNode *
22975 0 : SgEnumFieldSymbol::get_traversalSuccessorByIndex(size_t idx) {
22976 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgEnumFieldSymbol" << " that has no successors!" << endl;
22977 0 : ROSE_ASSERT(false);
22978 : return NULL;
22979 : }
22980 : size_t
22981 0 : SgEnumFieldSymbol::get_childIndex(SgNode *child) {
22982 0 : cout << "error: get_childIndex called on node of type " << "SgEnumFieldSymbol" << " that has no successors!" << endl;
22983 0 : ROSE_ASSERT(false);
22984 : return 0;
22985 : }
22986 : vector<SgNode*>
22987 0 : SgTypedefSymbol::get_traversalSuccessorContainer() {
22988 0 : vector<SgNode*> traversalSuccessorContainer;
22989 0 : traversalSuccessorContainer.reserve(1);
22990 0 : traversalSuccessorContainer.push_back(p_declaration);
22991 0 : return traversalSuccessorContainer;
22992 : }
22993 : vector<string>
22994 0 : SgTypedefSymbol::get_traversalSuccessorNamesContainer() {
22995 0 : vector<string> traversalSuccessorContainer;
22996 0 : traversalSuccessorContainer.push_back("p_declaration");
22997 0 : return traversalSuccessorContainer;
22998 : }
22999 : size_t
23000 0 : SgTypedefSymbol::get_numberOfTraversalSuccessors() {
23001 0 : return 1;
23002 : }
23003 : SgNode *
23004 0 : SgTypedefSymbol::get_traversalSuccessorByIndex(size_t idx) {
23005 0 : switch (idx) {
23006 0 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
23007 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
23008 0 : ROSE_ASSERT(false);
23009 : return NULL;
23010 : }
23011 : }
23012 : size_t
23013 0 : SgTypedefSymbol::get_childIndex(SgNode *child) {
23014 0 : if (child == p_declaration) return 0;
23015 0 : else return (size_t) -1;
23016 : }
23017 : vector<SgNode*>
23018 0 : SgTemplateTypedefSymbol::get_traversalSuccessorContainer() {
23019 0 : vector<SgNode*> traversalSuccessorContainer;
23020 0 : traversalSuccessorContainer.reserve(1);
23021 0 : traversalSuccessorContainer.push_back(p_declaration);
23022 0 : return traversalSuccessorContainer;
23023 : }
23024 : vector<string>
23025 0 : SgTemplateTypedefSymbol::get_traversalSuccessorNamesContainer() {
23026 0 : vector<string> traversalSuccessorContainer;
23027 0 : traversalSuccessorContainer.push_back("p_declaration");
23028 0 : return traversalSuccessorContainer;
23029 : }
23030 : size_t
23031 0 : SgTemplateTypedefSymbol::get_numberOfTraversalSuccessors() {
23032 0 : return 1;
23033 : }
23034 : SgNode *
23035 0 : SgTemplateTypedefSymbol::get_traversalSuccessorByIndex(size_t idx) {
23036 0 : switch (idx) {
23037 0 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
23038 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
23039 0 : ROSE_ASSERT(false);
23040 : return NULL;
23041 : }
23042 : }
23043 : size_t
23044 0 : SgTemplateTypedefSymbol::get_childIndex(SgNode *child) {
23045 0 : if (child == p_declaration) return 0;
23046 0 : else return (size_t) -1;
23047 : }
23048 : vector<SgNode*>
23049 0 : SgLabelSymbol::get_traversalSuccessorContainer() {
23050 0 : vector<SgNode*> traversalSuccessorContainer;
23051 0 : traversalSuccessorContainer.reserve(1);
23052 0 : traversalSuccessorContainer.push_back(p_declaration);
23053 0 : return traversalSuccessorContainer;
23054 : }
23055 : vector<string>
23056 0 : SgLabelSymbol::get_traversalSuccessorNamesContainer() {
23057 0 : vector<string> traversalSuccessorContainer;
23058 0 : traversalSuccessorContainer.push_back("p_declaration");
23059 0 : return traversalSuccessorContainer;
23060 : }
23061 : size_t
23062 0 : SgLabelSymbol::get_numberOfTraversalSuccessors() {
23063 0 : return 1;
23064 : }
23065 : SgNode *
23066 0 : SgLabelSymbol::get_traversalSuccessorByIndex(size_t idx) {
23067 0 : switch (idx) {
23068 0 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
23069 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
23070 0 : ROSE_ASSERT(false);
23071 : return NULL;
23072 : }
23073 : }
23074 : size_t
23075 0 : SgLabelSymbol::get_childIndex(SgNode *child) {
23076 0 : if (child == p_declaration) return 0;
23077 0 : else return (size_t) -1;
23078 : }
23079 : vector<SgNode*>
23080 0 : SgDefaultSymbol::get_traversalSuccessorContainer() {
23081 0 : vector<SgNode*> traversalSuccessorContainer;
23082 0 : return traversalSuccessorContainer;
23083 : }
23084 : vector<string>
23085 0 : SgDefaultSymbol::get_traversalSuccessorNamesContainer() {
23086 0 : vector<string> traversalSuccessorContainer;
23087 0 : return traversalSuccessorContainer;
23088 : }
23089 : size_t
23090 0 : SgDefaultSymbol::get_numberOfTraversalSuccessors() {
23091 0 : return 0;
23092 : }
23093 : SgNode *
23094 0 : SgDefaultSymbol::get_traversalSuccessorByIndex(size_t idx) {
23095 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgDefaultSymbol" << " that has no successors!" << endl;
23096 0 : ROSE_ASSERT(false);
23097 : return NULL;
23098 : }
23099 : size_t
23100 0 : SgDefaultSymbol::get_childIndex(SgNode *child) {
23101 0 : cout << "error: get_childIndex called on node of type " << "SgDefaultSymbol" << " that has no successors!" << endl;
23102 0 : ROSE_ASSERT(false);
23103 : return 0;
23104 : }
23105 : vector<SgNode*>
23106 0 : SgNamespaceSymbol::get_traversalSuccessorContainer() {
23107 0 : vector<SgNode*> traversalSuccessorContainer;
23108 0 : traversalSuccessorContainer.reserve(2);
23109 0 : traversalSuccessorContainer.push_back(p_declaration);
23110 0 : traversalSuccessorContainer.push_back(p_aliasDeclaration);
23111 0 : return traversalSuccessorContainer;
23112 : }
23113 : vector<string>
23114 0 : SgNamespaceSymbol::get_traversalSuccessorNamesContainer() {
23115 0 : vector<string> traversalSuccessorContainer;
23116 0 : traversalSuccessorContainer.push_back("p_declaration");
23117 0 : traversalSuccessorContainer.push_back("p_aliasDeclaration");
23118 0 : return traversalSuccessorContainer;
23119 : }
23120 : size_t
23121 0 : SgNamespaceSymbol::get_numberOfTraversalSuccessors() {
23122 0 : return 2;
23123 : }
23124 : SgNode *
23125 0 : SgNamespaceSymbol::get_traversalSuccessorByIndex(size_t idx) {
23126 0 : switch (idx) {
23127 0 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
23128 0 : case 1: ROSE_ASSERT(p_aliasDeclaration == NULL || p_aliasDeclaration != NULL); return p_aliasDeclaration;
23129 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
23130 0 : ROSE_ASSERT(false);
23131 : return NULL;
23132 : }
23133 : }
23134 : size_t
23135 0 : SgNamespaceSymbol::get_childIndex(SgNode *child) {
23136 0 : if (child == p_declaration) return 0;
23137 0 : else if (child == p_aliasDeclaration) return 1;
23138 0 : else return (size_t) -1;
23139 : }
23140 : vector<SgNode*>
23141 0 : SgIntrinsicSymbol::get_traversalSuccessorContainer() {
23142 0 : vector<SgNode*> traversalSuccessorContainer;
23143 0 : return traversalSuccessorContainer;
23144 : }
23145 : vector<string>
23146 0 : SgIntrinsicSymbol::get_traversalSuccessorNamesContainer() {
23147 0 : vector<string> traversalSuccessorContainer;
23148 0 : return traversalSuccessorContainer;
23149 : }
23150 : size_t
23151 0 : SgIntrinsicSymbol::get_numberOfTraversalSuccessors() {
23152 0 : return 0;
23153 : }
23154 : SgNode *
23155 0 : SgIntrinsicSymbol::get_traversalSuccessorByIndex(size_t idx) {
23156 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgIntrinsicSymbol" << " that has no successors!" << endl;
23157 0 : ROSE_ASSERT(false);
23158 : return NULL;
23159 : }
23160 : size_t
23161 0 : SgIntrinsicSymbol::get_childIndex(SgNode *child) {
23162 0 : cout << "error: get_childIndex called on node of type " << "SgIntrinsicSymbol" << " that has no successors!" << endl;
23163 0 : ROSE_ASSERT(false);
23164 : return 0;
23165 : }
23166 : vector<SgNode*>
23167 0 : SgModuleSymbol::get_traversalSuccessorContainer() {
23168 0 : vector<SgNode*> traversalSuccessorContainer;
23169 0 : traversalSuccessorContainer.reserve(1);
23170 0 : traversalSuccessorContainer.push_back(p_declaration);
23171 0 : return traversalSuccessorContainer;
23172 : }
23173 : vector<string>
23174 0 : SgModuleSymbol::get_traversalSuccessorNamesContainer() {
23175 0 : vector<string> traversalSuccessorContainer;
23176 0 : traversalSuccessorContainer.push_back("p_declaration");
23177 0 : return traversalSuccessorContainer;
23178 : }
23179 : size_t
23180 0 : SgModuleSymbol::get_numberOfTraversalSuccessors() {
23181 0 : return 1;
23182 : }
23183 : SgNode *
23184 0 : SgModuleSymbol::get_traversalSuccessorByIndex(size_t idx) {
23185 0 : switch (idx) {
23186 0 : case 0: ROSE_ASSERT(p_declaration == NULL || p_declaration != NULL); return p_declaration;
23187 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
23188 0 : ROSE_ASSERT(false);
23189 : return NULL;
23190 : }
23191 : }
23192 : size_t
23193 0 : SgModuleSymbol::get_childIndex(SgNode *child) {
23194 0 : if (child == p_declaration) return 0;
23195 0 : else return (size_t) -1;
23196 : }
23197 : vector<SgNode*>
23198 0 : SgInterfaceSymbol::get_traversalSuccessorContainer() {
23199 0 : vector<SgNode*> traversalSuccessorContainer;
23200 0 : return traversalSuccessorContainer;
23201 : }
23202 : vector<string>
23203 0 : SgInterfaceSymbol::get_traversalSuccessorNamesContainer() {
23204 0 : vector<string> traversalSuccessorContainer;
23205 0 : return traversalSuccessorContainer;
23206 : }
23207 : size_t
23208 0 : SgInterfaceSymbol::get_numberOfTraversalSuccessors() {
23209 0 : return 0;
23210 : }
23211 : SgNode *
23212 0 : SgInterfaceSymbol::get_traversalSuccessorByIndex(size_t idx) {
23213 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgInterfaceSymbol" << " that has no successors!" << endl;
23214 0 : ROSE_ASSERT(false);
23215 : return NULL;
23216 : }
23217 : size_t
23218 0 : SgInterfaceSymbol::get_childIndex(SgNode *child) {
23219 0 : cout << "error: get_childIndex called on node of type " << "SgInterfaceSymbol" << " that has no successors!" << endl;
23220 0 : ROSE_ASSERT(false);
23221 : return 0;
23222 : }
23223 : vector<SgNode*>
23224 0 : SgCommonSymbol::get_traversalSuccessorContainer() {
23225 0 : vector<SgNode*> traversalSuccessorContainer;
23226 0 : return traversalSuccessorContainer;
23227 : }
23228 : vector<string>
23229 0 : SgCommonSymbol::get_traversalSuccessorNamesContainer() {
23230 0 : vector<string> traversalSuccessorContainer;
23231 0 : return traversalSuccessorContainer;
23232 : }
23233 : size_t
23234 0 : SgCommonSymbol::get_numberOfTraversalSuccessors() {
23235 0 : return 0;
23236 : }
23237 : SgNode *
23238 0 : SgCommonSymbol::get_traversalSuccessorByIndex(size_t idx) {
23239 0 : cout << "error: get_traversalSuccessorByIndex called on node of type " << "SgCommonSymbol" << " that has no successors!" << endl;
23240 0 : ROSE_ASSERT(false);
23241 : return NULL;
23242 : }
23243 : size_t
23244 0 : SgCommonSymbol::get_childIndex(SgNode *child) {
23245 0 : cout << "error: get_childIndex called on node of type " << "SgCommonSymbol" << " that has no successors!" << endl;
23246 0 : ROSE_ASSERT(false);
23247 : return 0;
23248 : }
23249 : vector<SgNode*>
23250 0 : SgAliasSymbol::get_traversalSuccessorContainer() {
23251 0 : vector<SgNode*> traversalSuccessorContainer;
23252 0 : traversalSuccessorContainer.reserve(1);
23253 0 : traversalSuccessorContainer.push_back(p_alias);
23254 0 : return traversalSuccessorContainer;
23255 : }
23256 : vector<string>
23257 0 : SgAliasSymbol::get_traversalSuccessorNamesContainer() {
23258 0 : vector<string> traversalSuccessorContainer;
23259 0 : traversalSuccessorContainer.push_back("p_alias");
23260 0 : return traversalSuccessorContainer;
23261 : }
23262 : size_t
23263 0 : SgAliasSymbol::get_numberOfTraversalSuccessors() {
23264 0 : return 1;
23265 : }
23266 : SgNode *
23267 0 : SgAliasSymbol::get_traversalSuccessorByIndex(size_t idx) {
23268 0 : switch (idx) {
23269 0 : case 0: ROSE_ASSERT(p_alias == NULL || p_alias != NULL); return p_alias;
23270 0 : default: cout << "invalid index " << idx << " in get_traversalSuccessorByIndex()" << endl;
23271 0 : ROSE_ASSERT(false);
23272 : return NULL;
23273 : }
23274 : }
23275 : size_t
23276 0 : SgAliasSymbol::get_childIndex(SgNode *child) {
23277 0 : if (child == p_alias) return 0;
23278 0 : else return (size_t) -1;
23279 : }
23280 :
|
