ROSE 0.11.145.147
Cxx_GrammarVisitorSupport.h
1#ifndef ROSE_CxxGrammarVisitorSupport_H
2#define ROSE_CxxGrammarVisitorSupport_H
3// #line 60 "/workspace/src/ROSETTA/src/visitorSupport.C"
4#include <Cxx_GrammarDeclarations.h>
5
6#ifndef SWIG
8public:
9 virtual ~ROSE_VisitorPattern() {};
10 virtual void visitDefault(SgNode*) {}
11
12 virtual void visit(SgJovialBitVal*);
13 virtual void visit(SgName*);
14 virtual void visit(SgSymbolTable*);
15 virtual void visit(SgPragma*);
16 virtual void visit(SgModifierNodes*);
17 virtual void visit(SgConstVolatileModifier*);
18 virtual void visit(SgStorageModifier*);
19 virtual void visit(SgAccessModifier*);
20 virtual void visit(SgFunctionModifier*);
21 virtual void visit(SgUPC_AccessModifier*);
22 virtual void visit(SgLinkageModifier*);
23 virtual void visit(SgSpecialFunctionModifier*);
24 virtual void visit(SgTypeModifier*);
25 virtual void visit(SgElaboratedTypeModifier*);
26 virtual void visit(SgBaseClassModifier*);
27 virtual void visit(SgDeclarationModifier*);
28 virtual void visit(SgStructureModifier*);
29 virtual void visit(SgOpenclAccessModeModifier*);
30 virtual void visit(SgModifier*);
31 virtual void visit(Sg_File_Info*);
32 virtual void visit(SgSourceFile*);
33 virtual void visit(SgUnknownFile*);
34 virtual void visit(SgJvmComposite*);
35 virtual void visit(SgBinaryComposite*);
36 virtual void visit(SgFile*);
37 virtual void visit(SgFileList*);
38 virtual void visit(SgDirectory*);
39 virtual void visit(SgDirectoryList*);
40 virtual void visit(SgProject*);
41 virtual void visit(SgOptions*);
42 virtual void visit(SgUnparse_Info*);
43 virtual void visit(SgIncludeFile*);
44 virtual void visit(SgFuncDecl_attr*);
45 virtual void visit(SgClassDecl_attr*);
46 virtual void visit(SgTypedefSeq*);
47 virtual void visit(SgFunctionParameterTypeList*);
48 virtual void visit(SgTemplateParameter*);
49 virtual void visit(SgTemplateArgument*);
50 virtual void visit(SgTemplateParameterList*);
51 virtual void visit(SgTemplateArgumentList*);
52 virtual void visit(SgBitAttribute*);
53 virtual void visit(SgAttribute*);
54 virtual void visit(SgExpBaseClass*);
55 virtual void visit(SgNonrealBaseClass*);
56 virtual void visit(SgBaseClass*);
57 virtual void visit(SgUndirectedGraphEdge*);
58 virtual void visit(SgDirectedGraphEdge*);
59 virtual void visit(SgGraphNode*);
60 virtual void visit(SgGraphEdge*);
61 virtual void visit(SgStringKeyedBidirectionalGraph*);
62 virtual void visit(SgIntKeyedBidirectionalGraph*);
63 virtual void visit(SgBidirectionalGraph*);
64 virtual void visit(SgIncidenceDirectedGraph*);
65 virtual void visit(SgIncidenceUndirectedGraph*);
66 virtual void visit(SgGraph*);
67 virtual void visit(SgGraphNodeList*);
68 virtual void visit(SgGraphEdgeList*);
69 virtual void visit(SgQualifiedName*);
70 virtual void visit(SgNameGroup*);
71 virtual void visit(SgDimensionObject*);
72 virtual void visit(SgDataStatementGroup*);
73 virtual void visit(SgDataStatementObject*);
74 virtual void visit(SgDataStatementValue*);
75 virtual void visit(SgFormatItem*);
76 virtual void visit(SgFormatItemList*);
77 virtual void visit(SgTypeTable*);
78 virtual void visit(SgJavaImportStatementList*);
79 virtual void visit(SgJavaClassDeclarationList*);
80 virtual void visit(SgHeaderFileReport*);
81 virtual void visit(SgSupport*);
82 virtual void visit(SgTypeUnknown*);
83 virtual void visit(SgTypeChar*);
84 virtual void visit(SgTypeSignedChar*);
85 virtual void visit(SgTypeUnsignedChar*);
86 virtual void visit(SgTypeShort*);
87 virtual void visit(SgTypeSignedShort*);
88 virtual void visit(SgTypeUnsignedShort*);
89 virtual void visit(SgTypeInt*);
90 virtual void visit(SgTypeSignedInt*);
91 virtual void visit(SgTypeUnsignedInt*);
92 virtual void visit(SgTypeLong*);
93 virtual void visit(SgTypeSignedLong*);
94 virtual void visit(SgTypeUnsignedLong*);
95 virtual void visit(SgTypeVoid*);
96 virtual void visit(SgTypeGlobalVoid*);
97 virtual void visit(SgTypeWchar*);
98 virtual void visit(SgTypeFloat*);
99 virtual void visit(SgTypeDouble*);
100 virtual void visit(SgTypeLongLong*);
101 virtual void visit(SgTypeSignedLongLong*);
102 virtual void visit(SgTypeUnsignedLongLong*);
103 virtual void visit(SgTypeLongDouble*);
104 virtual void visit(SgTypeFloat80*);
105 virtual void visit(SgTypeFloat128*);
106 virtual void visit(SgTypeString*);
107 virtual void visit(SgTypeBool*);
108 virtual void visit(SgTypeFixed*);
109 virtual void visit(SgTypeMatrix*);
110 virtual void visit(SgTypeTuple*);
111 virtual void visit(SgTypeNullptr*);
112 virtual void visit(SgTypeComplex*);
113 virtual void visit(SgTypeImaginary*);
114 virtual void visit(SgTypeDefault*);
115 virtual void visit(SgPointerMemberType*);
116 virtual void visit(SgReferenceType*);
117 virtual void visit(SgRvalueReferenceType*);
118 virtual void visit(SgDeclType*);
119 virtual void visit(SgTypeOfType*);
120 virtual void visit(SgTypeCAFTeam*);
121 virtual void visit(SgTypeUnsigned128bitInteger*);
122 virtual void visit(SgTypeSigned128bitInteger*);
123 virtual void visit(SgTypeLabel*);
124 virtual void visit(SgJavaParameterizedType*);
125 virtual void visit(SgJavaQualifiedType*);
126 virtual void visit(SgJavaWildcardType*);
127 virtual void visit(SgJavaUnionType*);
128 virtual void visit(SgJavaParameterType*);
129 virtual void visit(SgJovialTableType*);
130 virtual void visit(SgTemplateType*);
131 virtual void visit(SgEnumType*);
132 virtual void visit(SgTypedefType*);
133 virtual void visit(SgNonrealType*);
134 virtual void visit(SgAutoType*);
135 virtual void visit(SgModifierType*);
136 virtual void visit(SgPartialFunctionModifierType*);
137 virtual void visit(SgArrayType*);
138 virtual void visit(SgTypeEllipse*);
139 virtual void visit(SgAdaAccessType*);
140 virtual void visit(SgAdaSubtype*);
141 virtual void visit(SgAdaDerivedType*);
142 virtual void visit(SgAdaModularType*);
143 virtual void visit(SgAdaDiscriminatedType*);
144 virtual void visit(SgAdaFormalType*);
145 virtual void visit(SgAdaDiscreteType*);
146 virtual void visit(SgAdaSubroutineType*);
147 virtual void visit(SgRangeType*);
148 virtual void visit(SgJovialBitType*);
149 virtual void visit(SgTypeCrayPointer*);
150 virtual void visit(SgPartialFunctionType*);
151 virtual void visit(SgMemberFunctionType*);
152 virtual void visit(SgFunctionType*);
153 virtual void visit(SgPointerType*);
154 virtual void visit(SgAdaTaskType*);
155 virtual void visit(SgAdaProtectedType*);
156 virtual void visit(SgClassType*);
157 virtual void visit(SgNamedType*);
158 virtual void visit(SgQualifiedNameType*);
159 virtual void visit(SgTypeChar16*);
160 virtual void visit(SgTypeChar32*);
161 virtual void visit(SgType*);
162 virtual void visit(SgForStatement*);
163 virtual void visit(SgForInitStatement*);
164 virtual void visit(SgRangeBasedForStatement*);
165 virtual void visit(SgCatchStatementSeq*);
166 virtual void visit(SgFunctionParameterList*);
167 virtual void visit(SgAdaParameterList*);
168 virtual void visit(SgCtorInitializerList*);
169 virtual void visit(SgBasicBlock*);
170 virtual void visit(SgGlobal*);
171 virtual void visit(SgIfStmt*);
172 virtual void visit(SgWhileStmt*);
173 virtual void visit(SgDoWhileStmt*);
174 virtual void visit(SgSwitchStatement*);
175 virtual void visit(SgCatchOptionStmt*);
176 virtual void visit(SgFunctionParameterScope*);
177 virtual void visit(SgDeclarationScope*);
178 virtual void visit(SgVariableDefinition*);
179 virtual void visit(SgStmtDeclarationStatement*);
180 virtual void visit(SgEnumDeclaration*);
181 virtual void visit(SgAsmStmt*);
182 virtual void visit(SgFunctionTypeTable*);
183 virtual void visit(SgExprStatement*);
184 virtual void visit(SgLabelStatement*);
185 virtual void visit(SgCaseOptionStmt*);
186 virtual void visit(SgTryStmt*);
187 virtual void visit(SgDefaultOptionStmt*);
188 virtual void visit(SgBreakStmt*);
189 virtual void visit(SgContinueStmt*);
190 virtual void visit(SgReturnStmt*);
191 virtual void visit(SgGotoStatement*);
192 virtual void visit(SgAdaExitStmt*);
193 virtual void visit(SgAdaLoopStmt*);
194 virtual void visit(SgAdaDelayStmt*);
195 virtual void visit(SgAdaSelectStmt*);
196 virtual void visit(SgAdaSelectAlternativeStmt*);
197 virtual void visit(SgAdaTerminateStmt*);
198 virtual void visit(SgAdaUnscopedBlock*);
199 virtual void visit(SgAdaVariantWhenStmt*);
200 virtual void visit(SgSpawnStmt*);
201 virtual void visit(SgFortranContinueStmt*);
202 virtual void visit(SgTemplateTypedefDeclaration*);
204 virtual void visit(SgTypedefDeclaration*);
205 virtual void visit(SgNullStatement*);
206 virtual void visit(SgVariantStatement*);
207 virtual void visit(SgPragmaDeclaration*);
208 virtual void visit(SgTemplateClassDeclaration*);
209 virtual void visit(SgTemplateMemberFunctionDeclaration*);
210 virtual void visit(SgTemplateFunctionDeclaration*);
211 virtual void visit(SgTemplateVariableDeclaration*);
212 virtual void visit(SgTemplateDeclaration*);
213 virtual void visit(SgVariableDeclaration*);
214 virtual void visit(SgTemplateInstantiationDecl*);
215 virtual void visit(SgTemplateInstantiationDefn*);
216 virtual void visit(SgTemplateInstantiationFunctionDecl*);
218 virtual void visit(SgNonrealDecl*);
219 virtual void visit(SgWithStatement*);
220 virtual void visit(SgPythonGlobalStmt*);
221 virtual void visit(SgPythonPrintStmt*);
222 virtual void visit(SgPassStatement*);
223 virtual void visit(SgAssertStmt*);
224 virtual void visit(SgExecStatement*);
225 virtual void visit(SgProgramHeaderStatement*);
226 virtual void visit(SgProcedureHeaderStatement*);
227 virtual void visit(SgEntryStatement*);
228 virtual void visit(SgFortranNonblockedDo*);
229 virtual void visit(SgInterfaceStatement*);
230 virtual void visit(SgParameterStatement*);
231 virtual void visit(SgCommonBlock*);
232 virtual void visit(SgModuleStatement*);
233 virtual void visit(SgUseStatement*);
234 virtual void visit(SgProcessControlStatement*);
235 virtual void visit(SgPrintStatement*);
236 virtual void visit(SgReadStatement*);
237 virtual void visit(SgWriteStatement*);
238 virtual void visit(SgOpenStatement*);
239 virtual void visit(SgCloseStatement*);
240 virtual void visit(SgInquireStatement*);
241 virtual void visit(SgFlushStatement*);
242 virtual void visit(SgBackspaceStatement*);
243 virtual void visit(SgRewindStatement*);
244 virtual void visit(SgEndfileStatement*);
245 virtual void visit(SgWaitStatement*);
246 virtual void visit(SgCAFWithTeamStatement*);
247 virtual void visit(SgFormatStatement*);
248 virtual void visit(SgFortranDo*);
249 virtual void visit(SgForAllStatement*);
250 virtual void visit(SgIOStatement*);
251 virtual void visit(SgSyncAllStatement*);
252 virtual void visit(SgSyncImagesStatement*);
253 virtual void visit(SgSyncMemoryStatement*);
254 virtual void visit(SgSyncTeamStatement*);
255 virtual void visit(SgLockStatement*);
256 virtual void visit(SgUnlockStatement*);
257 virtual void visit(SgImageControlStatement*);
258 virtual void visit(SgJovialCompoolStatement*);
259 virtual void visit(SgJovialDefineDeclaration*);
260 virtual void visit(SgJovialDirectiveStatement*);
261 virtual void visit(SgJovialLabelDeclaration*);
262 virtual void visit(SgJovialOverlayDeclaration*);
263 virtual void visit(SgJovialForThenStatement*);
264 virtual void visit(SgMatlabForStatement*);
265 virtual void visit(SgUpcNotifyStatement*);
266 virtual void visit(SgUpcWaitStatement*);
267 virtual void visit(SgUpcBarrierStatement*);
268 virtual void visit(SgUpcFenceStatement*);
269 virtual void visit(SgUpcForAllStatement*);
270 virtual void visit(SgOmpParallelStatement*);
271 virtual void visit(SgOmpSingleStatement*);
272 virtual void visit(SgOmpTaskStatement*);
273 virtual void visit(SgOmpForStatement*);
274 virtual void visit(SgOmpForSimdStatement*);
275 virtual void visit(SgOmpDoStatement*);
276 virtual void visit(SgOmpSectionsStatement*);
277 virtual void visit(SgOmpAtomicStatement*);
278 virtual void visit(SgOmpTargetStatement*);
279 virtual void visit(SgOmpTargetDataStatement*);
280 virtual void visit(SgOmpSimdStatement*);
281 virtual void visit(SgOmpClauseBodyStatement*);
282 virtual void visit(SgOmpMasterStatement*);
283 virtual void visit(SgOmpSectionStatement*);
284 virtual void visit(SgOmpOrderedStatement*);
285 virtual void visit(SgOmpWorkshareStatement*);
286 virtual void visit(SgOmpCriticalStatement*);
287 virtual void visit(SgOmpBodyStatement*);
288 virtual void visit(SgJavaThrowStatement*);
289 virtual void visit(SgJavaForEachStatement*);
290 virtual void visit(SgJavaSynchronizedStatement*);
291 virtual void visit(SgJavaLabelStatement*);
292 virtual void visit(SgJavaImportStatement*);
293 virtual void visit(SgJavaPackageDeclaration*);
294 virtual void visit(SgJavaPackageStatement*);
295 virtual void visit(SgAsyncStmt*);
296 virtual void visit(SgFinishStmt*);
297 virtual void visit(SgAtStmt*);
298 virtual void visit(SgAtomicStmt*);
299 virtual void visit(SgWhenStmt*);
300 virtual void visit(SgBlockDataStatement*);
301 virtual void visit(SgImplicitStatement*);
302 virtual void visit(SgStatementFunctionStatement*);
303 virtual void visit(SgWhereStatement*);
304 virtual void visit(SgNullifyStatement*);
305 virtual void visit(SgEquivalenceStatement*);
306 virtual void visit(SgDerivedTypeStatement*);
307 virtual void visit(SgJovialTableStatement*);
308 virtual void visit(SgAttributeSpecificationStatement*);
309 virtual void visit(SgAllocateStatement*);
310 virtual void visit(SgDeallocateStatement*);
311 virtual void visit(SgContainsStatement*);
312 virtual void visit(SgSequenceStatement*);
313 virtual void visit(SgElseWhereStatement*);
314 virtual void visit(SgArithmeticIfStatement*);
315 virtual void visit(SgAssignStatement*);
316 virtual void visit(SgComputedGotoStatement*);
317 virtual void visit(SgAssignedGotoStatement*);
318 virtual void visit(SgNamelistStatement*);
319 virtual void visit(SgImportStatement*);
320 virtual void visit(SgAssociateStatement*);
321 virtual void visit(SgFortranIncludeLine*);
322 virtual void visit(SgNamespaceDeclarationStatement*);
323 virtual void visit(SgNamespaceAliasDeclarationStatement*);
324 virtual void visit(SgNamespaceDefinitionStatement*);
325 virtual void visit(SgUsingDeclarationStatement*);
326 virtual void visit(SgUsingDirectiveStatement*);
328 virtual void visit(SgStaticAssertionDeclaration*);
329 virtual void visit(SgTemplateClassDefinition*);
330 virtual void visit(SgTemplateFunctionDefinition*);
331 virtual void visit(SgClassDeclaration*);
332 virtual void visit(SgClassDefinition*);
333 virtual void visit(SgFunctionDefinition*);
334 virtual void visit(SgAdaAcceptStmt*);
335 virtual void visit(SgAdaPackageBody*);
336 virtual void visit(SgAdaPackageSpec*);
337 virtual void visit(SgAdaTaskBody*);
338 virtual void visit(SgAdaTaskSpec*);
339 virtual void visit(SgAdaProtectedBody*);
340 virtual void visit(SgAdaProtectedSpec*);
341 virtual void visit(SgAdaGenericDefn*);
342 virtual void visit(SgScopeStatement*);
343 virtual void visit(SgMemberFunctionDeclaration*);
344 virtual void visit(SgAdaEntryDecl*);
345 virtual void visit(SgAdaFunctionRenamingDecl*);
346 virtual void visit(SgFunctionDeclaration*);
347 virtual void visit(SgIncludeDirectiveStatement*);
348 virtual void visit(SgDefineDirectiveStatement*);
349 virtual void visit(SgUndefDirectiveStatement*);
350 virtual void visit(SgIfdefDirectiveStatement*);
351 virtual void visit(SgIfndefDirectiveStatement*);
352 virtual void visit(SgIfDirectiveStatement*);
353 virtual void visit(SgDeadIfDirectiveStatement*);
354 virtual void visit(SgElseDirectiveStatement*);
355 virtual void visit(SgElseifDirectiveStatement*);
356 virtual void visit(SgEndifDirectiveStatement*);
357 virtual void visit(SgLineDirectiveStatement*);
358 virtual void visit(SgWarningDirectiveStatement*);
359 virtual void visit(SgErrorDirectiveStatement*);
360 virtual void visit(SgEmptyDirectiveStatement*);
361 virtual void visit(SgIncludeNextDirectiveStatement*);
362 virtual void visit(SgIdentDirectiveStatement*);
363 virtual void visit(SgLinemarkerDirectiveStatement*);
364 virtual void visit(SgC_PreprocessorDirectiveStatement*);
365 virtual void visit(SgClinkageStartStatement*);
366 virtual void visit(SgClinkageEndStatement*);
367 virtual void visit(SgClinkageDeclarationStatement*);
368 virtual void visit(SgOmpFlushStatement*);
369 virtual void visit(SgOmpDeclareSimdStatement*);
370 virtual void visit(SgOmpBarrierStatement*);
371 virtual void visit(SgOmpTaskwaitStatement*);
372 virtual void visit(SgOmpThreadprivateStatement*);
373 virtual void visit(SgMicrosoftAttributeDeclaration*);
374 virtual void visit(SgEmptyDeclaration*);
375 virtual void visit(SgAdaPackageSpecDecl*);
376 virtual void visit(SgAdaPackageBodyDecl*);
377 virtual void visit(SgAdaTaskSpecDecl*);
378 virtual void visit(SgAdaTaskTypeDecl*);
379 virtual void visit(SgAdaTaskBodyDecl*);
380 virtual void visit(SgAdaProtectedSpecDecl*);
381 virtual void visit(SgAdaProtectedTypeDecl*);
382 virtual void visit(SgAdaProtectedBodyDecl*);
383 virtual void visit(SgAdaRepresentationClause*);
384 virtual void visit(SgAdaEnumRepresentationClause*);
385 virtual void visit(SgAdaAttributeClause*);
386 virtual void visit(SgAdaComponentClause*);
387 virtual void visit(SgAdaRenamingDecl*);
388 virtual void visit(SgAdaGenericDecl*);
389 virtual void visit(SgAdaGenericInstanceDecl*);
390 virtual void visit(SgAdaFormalTypeDecl*);
391 virtual void visit(SgAdaFormalPackageDecl*);
392 virtual void visit(SgAdaDiscriminatedTypeDecl*);
393 virtual void visit(SgAdaVariantDecl*);
394 virtual void visit(SgDeclarationStatement*);
395 virtual void visit(SgStatement*);
396 virtual void visit(SgAbsOp*);
397 virtual void visit(SgActualArgumentExpression*);
398 virtual void visit(SgAdaAncestorInitializer*);
399 virtual void visit(SgAdaAttributeExp*);
400 virtual void visit(SgAdaFloatVal*);
401 virtual void visit(SgAdaOthersExp*);
402 virtual void visit(SgAdaProtectedRefExp*);
403 virtual void visit(SgAdaRenamingRefExp*);
404 virtual void visit(SgAdaTaskRefExp*);
405 virtual void visit(SgAdaUnitRefExp*);
406 virtual void visit(SgAddOp*);
407 virtual void visit(SgAddressOfOp*);
408 virtual void visit(SgAggregateInitializer*);
409 virtual void visit(SgAlignOfOp*);
410 virtual void visit(SgAndAssignOp*);
411 virtual void visit(SgAndOp*);
412 virtual void visit(SgArrowExp*);
413 virtual void visit(SgArrowStarOp*);
414 virtual void visit(SgAsmOp*);
415 virtual void visit(SgAssignInitializer*);
416 virtual void visit(SgAssignOp*);
417 virtual void visit(SgAsteriskShapeExp*);
418 virtual void visit(SgAtExp*);
419 virtual void visit(SgAtOp*);
420 virtual void visit(SgAwaitExpression*);
421 virtual void visit(SgBitAndOp*);
422 virtual void visit(SgBitComplementOp*);
423 virtual void visit(SgBitEqvOp*);
424 virtual void visit(SgBitOrOp*);
425 virtual void visit(SgBitXorOp*);
426 virtual void visit(SgBoolValExp*);
427 virtual void visit(SgBracedInitializer*);
428 virtual void visit(SgCAFCoExpression*);
429 virtual void visit(SgCastExp*);
430 virtual void visit(SgChar16Val*);
431 virtual void visit(SgChar32Val*);
432 virtual void visit(SgCharVal*);
433 virtual void visit(SgChooseExpression*);
434 virtual void visit(SgClassExp*);
435 virtual void visit(SgClassNameRefExp*);
436 virtual void visit(SgColonShapeExp*);
437 virtual void visit(SgCommaOpExp*);
438 virtual void visit(SgComplexVal*);
439 virtual void visit(SgCompoundInitializer*);
440 virtual void visit(SgCompoundLiteralExp*);
441 virtual void visit(SgComprehension*);
442 virtual void visit(SgConcatenationOp*);
443 virtual void visit(SgConjugateOp*);
444 virtual void visit(SgConditionalExp*);
445 virtual void visit(SgConstructorInitializer*);
446 virtual void visit(SgCudaKernelCallExp*);
447 virtual void visit(SgCudaKernelExecConfig*);
448 virtual void visit(SgDeleteExp*);
449 virtual void visit(SgDesignatedInitializer*);
450 virtual void visit(SgDictionaryComprehension*);
451 virtual void visit(SgDictionaryExp*);
452 virtual void visit(SgDivAssignOp*);
453 virtual void visit(SgDivideOp*);
454 virtual void visit(SgDotDotExp*);
455 virtual void visit(SgDotExp*);
456 virtual void visit(SgDotStarOp*);
457 virtual void visit(SgDoubleVal*);
458 virtual void visit(SgElementwiseAddOp*);
459 virtual void visit(SgElementwiseDivideOp*);
460 virtual void visit(SgElementwiseLeftDivideOp*);
461 virtual void visit(SgElementwiseMultiplyOp*);
462 virtual void visit(SgElementwisePowerOp*);
463 virtual void visit(SgElementwiseSubtractOp*);
464 virtual void visit(SgEnumVal*);
465 virtual void visit(SgEqualityOp*);
466 virtual void visit(SgExponentiationAssignOp*);
467 virtual void visit(SgExponentiationOp*);
468 virtual void visit(SgExpressionRoot*);
469 virtual void visit(SgFinishExp*);
470 virtual void visit(SgFloat128Val*);
471 virtual void visit(SgFloat80Val*);
472 virtual void visit(SgFloatVal*);
473 virtual void visit(SgFoldExpression*);
474 virtual void visit(SgFunctionParameterRefExp*);
475 virtual void visit(SgFunctionRefExp*);
476 virtual void visit(SgGreaterOrEqualOp*);
477 virtual void visit(SgGreaterThanOp*);
478 virtual void visit(SgHereExp*);
479 virtual void visit(SgImagPartOp*);
480 virtual void visit(SgImpliedDo*);
481 virtual void visit(SgIntegerDivideAssignOp*);
482 virtual void visit(SgIntegerDivideOp*);
483 virtual void visit(SgIntVal*);
484 virtual void visit(SgIOItemExpression*);
485 virtual void visit(SgIorAssignOp*);
486 virtual void visit(SgIsNotOp*);
487 virtual void visit(SgIsOp*);
488 virtual void visit(SgJavaInstanceOfOp*);
489 virtual void visit(SgJavaMarkerAnnotation*);
490 virtual void visit(SgJavaNormalAnnotation*);
491 virtual void visit(SgJavaSingleMemberAnnotation*);
492 virtual void visit(SgJavaTypeExpression*);
493 virtual void visit(SgJavaUnsignedRshiftAssignOp*);
494 virtual void visit(SgJavaUnsignedRshiftOp*);
495 virtual void visit(SgJovialPresetPositionExp*);
496 virtual void visit(SgJovialTablePresetExp*);
497 virtual void visit(SgKeyDatumPair*);
498 virtual void visit(SgLabelRefExp*);
499 virtual void visit(SgLambdaExp*);
500 virtual void visit(SgLambdaRefExp*);
501 virtual void visit(SgLeftDivideOp*);
502 virtual void visit(SgLessOrEqualOp*);
503 virtual void visit(SgLessThanOp*);
504 virtual void visit(SgListComprehension*);
505 virtual void visit(SgListExp*);
506 virtual void visit(SgLongDoubleVal*);
507 virtual void visit(SgLongIntVal*);
508 virtual void visit(SgLongLongIntVal*);
509 virtual void visit(SgLshiftAssignOp*);
510 virtual void visit(SgLshiftOp*);
511 virtual void visit(SgMagicColonExp*);
512 virtual void visit(SgMatrixExp*);
513 virtual void visit(SgMatrixTransposeOp*);
514 virtual void visit(SgMemberFunctionRefExp*);
515 virtual void visit(SgMembershipOp*);
516 virtual void visit(SgMinusAssignOp*);
517 virtual void visit(SgMinusMinusOp*);
518 virtual void visit(SgMinusOp*);
519 virtual void visit(SgModAssignOp*);
520 virtual void visit(SgModOp*);
521 virtual void visit(SgMultAssignOp*);
522 virtual void visit(SgMultiplyOp*);
523 virtual void visit(SgNaryBooleanOp*);
524 virtual void visit(SgNaryComparisonOp*);
525 virtual void visit(SgNewExp*);
526 virtual void visit(SgNoexceptOp*);
527 virtual void visit(SgNonMembershipOp*);
528 virtual void visit(SgNonrealRefExp*);
529 virtual void visit(SgNotOp*);
530 virtual void visit(SgNotEqualOp*);
531 virtual void visit(SgNullExpression*);
532 virtual void visit(SgNullptrValExp*);
533 virtual void visit(SgOrOp*);
534 virtual void visit(SgPlusAssignOp*);
535 virtual void visit(SgPlusPlusOp*);
536 virtual void visit(SgPntrArrRefExp*);
537 virtual void visit(SgPointerAssignOp*);
538 virtual void visit(SgPointerDerefExp*);
539 virtual void visit(SgPowerOp*);
540 virtual void visit(SgPseudoDestructorRefExp*);
541 virtual void visit(SgRangeExp*);
542 virtual void visit(SgRealPartOp*);
543 virtual void visit(SgRefExp*);
544 virtual void visit(SgRemOp*);
545 virtual void visit(SgReplicationOp*);
546 virtual void visit(SgRshiftAssignOp*);
547 virtual void visit(SgRshiftOp*);
548 virtual void visit(SgScopeOp*);
549 virtual void visit(SgSetComprehension*);
550 virtual void visit(SgShortVal*);
551 virtual void visit(SgSizeOfOp*);
552 virtual void visit(SgSpaceshipOp*);
553 virtual void visit(SgStatementExpression*);
554 virtual void visit(SgStringConversion*);
555 virtual void visit(SgStringVal*);
556 virtual void visit(SgSubscriptExpression*);
557 virtual void visit(SgSubtractOp*);
558 virtual void visit(SgSuperExp*);
559 virtual void visit(SgTemplateFunctionRefExp*);
560 virtual void visit(SgTemplateMemberFunctionRefExp*);
561 virtual void visit(SgTemplateParameterVal*);
562 virtual void visit(SgThisExp*);
563 virtual void visit(SgThrowOp*);
564 virtual void visit(SgTupleExp*);
565 virtual void visit(SgTypeExpression*);
566 virtual void visit(SgTypeIdOp*);
567 virtual void visit(SgTypeTraitBuiltinOperator*);
568 virtual void visit(SgUnaryAddOp*);
569 virtual void visit(SgUnknownArrayOrFunctionReference*);
570 virtual void visit(SgUnsignedCharVal*);
571 virtual void visit(SgUnsignedIntVal*);
572 virtual void visit(SgUnsignedLongLongIntVal*);
573 virtual void visit(SgUnsignedLongVal*);
574 virtual void visit(SgUnsignedShortVal*);
575 virtual void visit(SgUpcBlocksizeofExpression*);
576 virtual void visit(SgUpcElemsizeofExpression*);
577 virtual void visit(SgUpcLocalsizeofExpression*);
578 virtual void visit(SgUpcMythread*);
579 virtual void visit(SgUpcThreads*);
580 virtual void visit(SgUserDefinedBinaryOp*);
581 virtual void visit(SgUserDefinedUnaryOp*);
582 virtual void visit(SgVarArgCopyOp*);
583 virtual void visit(SgVarArgEndOp*);
584 virtual void visit(SgVarArgOp*);
585 virtual void visit(SgVarArgStartOneOperandOp*);
586 virtual void visit(SgVarArgStartOp*);
587 virtual void visit(SgVariantExpression*);
588 virtual void visit(SgVarRefExp*);
589 virtual void visit(SgVoidVal*);
590 virtual void visit(SgWcharVal*);
591 virtual void visit(SgXorAssignOp*);
592 virtual void visit(SgYieldExpression*);
593 virtual void visit(SgCompoundAssignOp*);
594 virtual void visit(SgElementwiseOp*);
595 virtual void visit(SgBinaryOp*);
596 virtual void visit(SgFunctionCallExp*);
597 virtual void visit(SgCallExpression*);
598 virtual void visit(SgExprListExp*);
599 virtual void visit(SgInitializer*);
600 virtual void visit(SgJavaAnnotation*);
601 virtual void visit(SgNaryOp*);
602 virtual void visit(SgUnaryOp*);
603 virtual void visit(SgValueExp*);
604 virtual void visit(SgExpression*);
605 virtual void visit(SgTemplateVariableSymbol*);
606 virtual void visit(SgVariableSymbol*);
607 virtual void visit(SgFunctionTypeSymbol*);
608 virtual void visit(SgTemplateClassSymbol*);
609 virtual void visit(SgClassSymbol*);
610 virtual void visit(SgTemplateSymbol*);
611 virtual void visit(SgEnumSymbol*);
612 virtual void visit(SgEnumFieldSymbol*);
613 virtual void visit(SgTemplateTypedefSymbol*);
614 virtual void visit(SgTypedefSymbol*);
615 virtual void visit(SgTemplateFunctionSymbol*);
616 virtual void visit(SgTemplateMemberFunctionSymbol*);
617 virtual void visit(SgLabelSymbol*);
618 virtual void visit(SgJavaLabelSymbol*);
619 virtual void visit(SgDefaultSymbol*);
620 virtual void visit(SgNamespaceSymbol*);
621 virtual void visit(SgIntrinsicSymbol*);
622 virtual void visit(SgModuleSymbol*);
623 virtual void visit(SgInterfaceSymbol*);
624 virtual void visit(SgCommonSymbol*);
625 virtual void visit(SgRenameSymbol*);
626 virtual void visit(SgAdaInheritedFunctionSymbol*);
627 virtual void visit(SgMemberFunctionSymbol*);
628 virtual void visit(SgFunctionSymbol*);
629 virtual void visit(SgAsmBinaryAddressSymbol*);
630 virtual void visit(SgAsmBinaryDataSymbol*);
631 virtual void visit(SgAliasSymbol*);
632 virtual void visit(SgNonrealSymbol*);
633 virtual void visit(SgAdaPackageSymbol*);
634 virtual void visit(SgAdaTaskSymbol*);
635 virtual void visit(SgAdaProtectedSymbol*);
636 virtual void visit(SgAdaGenericSymbol*);
637 virtual void visit(SgAdaGenericInstanceSymbol*);
638 virtual void visit(SgAdaFormalPackageSymbol*);
639 virtual void visit(SgAdaRenamingSymbol*);
640 virtual void visit(SgSymbol*);
641 virtual void visit(SgAsmX86Instruction*);
642 virtual void visit(SgAsmVoidType*);
643 virtual void visit(SgAsmVectorType*);
644 virtual void visit(SgAsmUserInstruction*);
645 virtual void visit(SgAsmUnaryUnsignedExtend*);
646 virtual void visit(SgAsmUnaryTruncate*);
647 virtual void visit(SgAsmUnarySignedExtend*);
648 virtual void visit(SgAsmUnaryRrx*);
649 virtual void visit(SgAsmUnaryPlus*);
650 virtual void visit(SgAsmUnaryMinus*);
651 virtual void visit(SgAsmUnaryExpression*);
652 virtual void visit(SgAsmSynthesizedFieldDeclaration*);
653 virtual void visit(SgAsmSynthesizedDataStructureDeclaration*);
654 virtual void visit(SgAsmStringStorage*);
655 virtual void visit(SgAsmStoredString*);
656 virtual void visit(SgAsmStaticData*);
657 virtual void visit(SgAsmStackExpression*);
658 virtual void visit(SgAsmRiscOperation*);
659 virtual void visit(SgAsmRegisterNames*);
660 virtual void visit(SgAsmPowerpcInstruction*);
661 virtual void visit(SgAsmPointerType*);
662 virtual void visit(SgAsmPEStringSection*);
663 virtual void visit(SgAsmPESectionTable*);
664 virtual void visit(SgAsmPESectionTableEntry*);
665 virtual void visit(SgAsmPERVASizePairList*);
666 virtual void visit(SgAsmPERVASizePair*);
667 virtual void visit(SgAsmPEImportSection*);
668 virtual void visit(SgAsmPEImportItemList*);
669 virtual void visit(SgAsmPEImportItem*);
670 virtual void visit(SgAsmPEImportDirectoryList*);
671 virtual void visit(SgAsmPEImportDirectory*);
672 virtual void visit(SgAsmPEFileHeader*);
673 virtual void visit(SgAsmPEExportSection*);
674 virtual void visit(SgAsmPESection*);
675 virtual void visit(SgAsmPEExportEntryList*);
676 virtual void visit(SgAsmPEExportEntry*);
677 virtual void visit(SgAsmPEExportDirectory*);
678 virtual void visit(SgAsmOperandList*);
679 virtual void visit(SgAsmNullInstruction*);
680 virtual void visit(SgAsmNEStringTable*);
681 virtual void visit(SgAsmNESectionTable*);
682 virtual void visit(SgAsmNESectionTableEntry*);
683 virtual void visit(SgAsmNESection*);
684 virtual void visit(SgAsmNERelocTable*);
685 virtual void visit(SgAsmNERelocEntry*);
686 virtual void visit(SgAsmNENameTable*);
687 virtual void visit(SgAsmNEModuleTable*);
688 virtual void visit(SgAsmNEFileHeader*);
689 virtual void visit(SgAsmNEEntryTable*);
690 virtual void visit(SgAsmNEEntryPoint*);
691 virtual void visit(SgAsmMipsInstruction*);
692 virtual void visit(SgAsmMemoryReferenceExpression*);
693 virtual void visit(SgAsmM68kInstruction*);
694 virtual void visit(SgAsmLESectionTable*);
695 virtual void visit(SgAsmLESectionTableEntry*);
696 virtual void visit(SgAsmLESection*);
697 virtual void visit(SgAsmLERelocTable*);
698 virtual void visit(SgAsmLEPageTable*);
699 virtual void visit(SgAsmLEPageTableEntry*);
700 virtual void visit(SgAsmLENameTable*);
701 virtual void visit(SgAsmLEFileHeader*);
702 virtual void visit(SgAsmLEEntryTable*);
703 virtual void visit(SgAsmLEEntryPoint*);
704 virtual void visit(SgAsmJvmStackMapVerificationType*);
705 virtual void visit(SgAsmJvmStackMapTable*);
706 virtual void visit(SgAsmJvmStackMapFrame*);
707 virtual void visit(SgAsmJvmSourceFile*);
708 virtual void visit(SgAsmJvmSignature*);
709 virtual void visit(SgAsmJvmNestMembers*);
710 virtual void visit(SgAsmJvmNestHost*);
711 virtual void visit(SgAsmJvmModuleMainClass*);
712 virtual void visit(SgAsmJvmMethodTable*);
713 virtual void visit(SgAsmJvmMethodParameters*);
714 virtual void visit(SgAsmJvmMethodParametersEntry*);
715 virtual void visit(SgAsmJvmMethod*);
716 virtual void visit(SgAsmJvmLocalVariableTypeTable*);
717 virtual void visit(SgAsmJvmLocalVariableTypeEntry*);
718 virtual void visit(SgAsmJvmLocalVariableTable*);
719 virtual void visit(SgAsmJvmLocalVariableEntry*);
720 virtual void visit(SgAsmJvmLineNumberTable*);
721 virtual void visit(SgAsmJvmLineNumberEntry*);
722 virtual void visit(SgAsmJvmInstruction*);
723 virtual void visit(SgAsmJvmInnerClasses*);
724 virtual void visit(SgAsmJvmInnerClassesEntry*);
725 virtual void visit(SgAsmJvmFileHeader*);
726 virtual void visit(SgAsmJvmFieldTable*);
727 virtual void visit(SgAsmJvmField*);
728 virtual void visit(SgAsmJvmExceptionTable*);
729 virtual void visit(SgAsmJvmExceptions*);
730 virtual void visit(SgAsmJvmExceptionHandler*);
731 virtual void visit(SgAsmJvmEnclosingMethod*);
732 virtual void visit(SgAsmJvmConstantValue*);
733 virtual void visit(SgAsmJvmConstantPool*);
734 virtual void visit(SgAsmJvmConstantPoolEntry*);
735 virtual void visit(SgAsmJvmCodeAttribute*);
736 virtual void visit(SgAsmJvmClass*);
737 virtual void visit(SgAsmJvmBootstrapMethods*);
738 virtual void visit(SgAsmJvmBootstrapMethod*);
739 virtual void visit(SgAsmJvmAttributeTable*);
740 virtual void visit(SgAsmJvmAttribute*);
741 virtual void visit(SgAsmJvmNode*);
742 virtual void visit(SgAsmInterpretationList*);
743 virtual void visit(SgAsmInterpretation*);
744 virtual void visit(SgAsmIntegerValueExpression*);
745 virtual void visit(SgAsmIntegerType*);
746 virtual void visit(SgAsmInstructionList*);
747 virtual void visit(SgAsmIndirectRegisterExpression*);
748 virtual void visit(SgAsmGenericSymbolList*);
749 virtual void visit(SgAsmGenericSectionList*);
750 virtual void visit(SgAsmGenericHeaderList*);
751 virtual void visit(SgAsmGenericFormat*);
752 virtual void visit(SgAsmGenericFileList*);
753 virtual void visit(SgAsmGenericFile*);
754 virtual void visit(SgAsmGenericDLLList*);
755 virtual void visit(SgAsmGenericDLL*);
756 virtual void visit(SgAsmFunction*);
757 virtual void visit(SgAsmSynthesizedDeclaration*);
758 virtual void visit(SgAsmFloatValueExpression*);
759 virtual void visit(SgAsmFloatType*);
760 virtual void visit(SgAsmScalarType*);
761 virtual void visit(SgAsmType*);
762 virtual void visit(SgAsmExprListExp*);
763 virtual void visit(SgAsmElfSymverSection*);
764 virtual void visit(SgAsmElfSymverNeededSection*);
765 virtual void visit(SgAsmElfSymverNeededEntryList*);
766 virtual void visit(SgAsmElfSymverNeededEntry*);
767 virtual void visit(SgAsmElfSymverNeededAuxList*);
768 virtual void visit(SgAsmElfSymverNeededAux*);
769 virtual void visit(SgAsmElfSymverEntryList*);
770 virtual void visit(SgAsmElfSymverEntry*);
771 virtual void visit(SgAsmElfSymverDefinedSection*);
772 virtual void visit(SgAsmElfSymverDefinedEntryList*);
773 virtual void visit(SgAsmElfSymverDefinedEntry*);
774 virtual void visit(SgAsmElfSymverDefinedAuxList*);
775 virtual void visit(SgAsmElfSymverDefinedAux*);
776 virtual void visit(SgAsmElfSymbolSection*);
777 virtual void visit(SgAsmElfSymbolList*);
778 virtual void visit(SgAsmElfSymbol*);
779 virtual void visit(SgAsmElfStrtab*);
780 virtual void visit(SgAsmElfStringSection*);
781 virtual void visit(SgAsmElfSegmentTable*);
782 virtual void visit(SgAsmElfSegmentTableEntryList*);
783 virtual void visit(SgAsmElfSegmentTableEntry*);
784 virtual void visit(SgAsmElfSectionTable*);
785 virtual void visit(SgAsmElfSectionTableEntry*);
786 virtual void visit(SgAsmElfRelocSection*);
787 virtual void visit(SgAsmElfRelocEntryList*);
788 virtual void visit(SgAsmElfRelocEntry*);
789 virtual void visit(SgAsmElfNoteSection*);
790 virtual void visit(SgAsmElfNoteEntryList*);
791 virtual void visit(SgAsmElfNoteEntry*);
792 virtual void visit(SgAsmElfFileHeader*);
793 virtual void visit(SgAsmElfEHFrameSection*);
794 virtual void visit(SgAsmElfEHFrameEntryFDList*);
795 virtual void visit(SgAsmElfEHFrameEntryFD*);
796 virtual void visit(SgAsmElfEHFrameEntryCIList*);
797 virtual void visit(SgAsmElfEHFrameEntryCI*);
798 virtual void visit(SgAsmElfDynamicSection*);
799 virtual void visit(SgAsmElfSection*);
800 virtual void visit(SgAsmElfDynamicEntryList*);
801 virtual void visit(SgAsmElfDynamicEntry*);
802 virtual void visit(SgAsmDwarfWithStmt*);
803 virtual void visit(SgAsmDwarfVolatileType*);
804 virtual void visit(SgAsmDwarfVariantPart*);
805 virtual void visit(SgAsmDwarfVariant*);
806 virtual void visit(SgAsmDwarfVariable*);
807 virtual void visit(SgAsmDwarfUpcStrictType*);
808 virtual void visit(SgAsmDwarfUpcSharedType*);
809 virtual void visit(SgAsmDwarfUpcRelaxedType*);
810 virtual void visit(SgAsmDwarfUnspecifiedType*);
811 virtual void visit(SgAsmDwarfUnspecifiedParameters*);
812 virtual void visit(SgAsmDwarfUnknownConstruct*);
813 virtual void visit(SgAsmDwarfUnionType*);
814 virtual void visit(SgAsmDwarfTypedef*);
815 virtual void visit(SgAsmDwarfTryBlock*);
816 virtual void visit(SgAsmDwarfThrownType*);
817 virtual void visit(SgAsmDwarfTemplateValueParameter*);
818 virtual void visit(SgAsmDwarfTemplateTypeParameter*);
819 virtual void visit(SgAsmDwarfSubroutineType*);
820 virtual void visit(SgAsmDwarfSubrangeType*);
821 virtual void visit(SgAsmDwarfSubprogram*);
822 virtual void visit(SgAsmDwarfStructureType*);
823 virtual void visit(SgAsmDwarfStringType*);
824 virtual void visit(SgAsmDwarfSharedType*);
825 virtual void visit(SgAsmDwarfSetType*);
826 virtual void visit(SgAsmDwarfRestrictType*);
827 virtual void visit(SgAsmDwarfReferenceType*);
828 virtual void visit(SgAsmDwarfPtrToMemberType*);
829 virtual void visit(SgAsmDwarfPointerType*);
830 virtual void visit(SgAsmDwarfPartialUnit*);
831 virtual void visit(SgAsmDwarfPackedType*);
832 virtual void visit(SgAsmDwarfNamespace*);
833 virtual void visit(SgAsmDwarfNamelistItem*);
834 virtual void visit(SgAsmDwarfNamelist*);
835 virtual void visit(SgAsmDwarfMutableType*);
836 virtual void visit(SgAsmDwarfModule*);
837 virtual void visit(SgAsmDwarfMember*);
838 virtual void visit(SgAsmDwarfMacroList*);
839 virtual void visit(SgAsmDwarfMacro*);
840 virtual void visit(SgAsmDwarfLineList*);
841 virtual void visit(SgAsmDwarfLine*);
842 virtual void visit(SgAsmDwarfLexicalBlock*);
843 virtual void visit(SgAsmDwarfLabel*);
844 virtual void visit(SgAsmDwarfInterfaceType*);
845 virtual void visit(SgAsmDwarfInlinedSubroutine*);
846 virtual void visit(SgAsmDwarfInheritance*);
847 virtual void visit(SgAsmDwarfImportedUnit*);
848 virtual void visit(SgAsmDwarfImportedModule*);
849 virtual void visit(SgAsmDwarfImportedDeclaration*);
850 virtual void visit(SgAsmDwarfFunctionTemplate*);
851 virtual void visit(SgAsmDwarfFriend*);
852 virtual void visit(SgAsmDwarfFormatLabel*);
853 virtual void visit(SgAsmDwarfFormalParameter*);
854 virtual void visit(SgAsmDwarfFileType*);
855 virtual void visit(SgAsmDwarfEnumerator*);
856 virtual void visit(SgAsmDwarfEnumerationType*);
857 virtual void visit(SgAsmDwarfEntryPoint*);
858 virtual void visit(SgAsmDwarfDwarfProcedure*);
859 virtual void visit(SgAsmDwarfConstType*);
860 virtual void visit(SgAsmDwarfConstructList*);
861 virtual void visit(SgAsmDwarfConstant*);
862 virtual void visit(SgAsmDwarfCondition*);
863 virtual void visit(SgAsmDwarfCompilationUnitList*);
864 virtual void visit(SgAsmDwarfCompilationUnit*);
865 virtual void visit(SgAsmDwarfCommonInclusion*);
866 virtual void visit(SgAsmDwarfCommonBlock*);
867 virtual void visit(SgAsmDwarfClassType*);
868 virtual void visit(SgAsmDwarfClassTemplate*);
869 virtual void visit(SgAsmDwarfCatchBlock*);
870 virtual void visit(SgAsmDwarfBaseType*);
871 virtual void visit(SgAsmDwarfArrayType*);
872 virtual void visit(SgAsmDwarfAccessDeclaration*);
873 virtual void visit(SgAsmDwarfConstruct*);
874 virtual void visit(SgAsmDwarfInformation*);
875 virtual void visit(SgAsmDOSFileHeader*);
876 virtual void visit(SgAsmGenericHeader*);
877 virtual void visit(SgAsmDOSExtendedHeader*);
878 virtual void visit(SgAsmDirectRegisterExpression*);
879 virtual void visit(SgAsmRegisterReferenceExpression*);
880 virtual void visit(SgAsmControlFlagsExpression*);
881 virtual void visit(SgAsmConstantExpression*);
882 virtual void visit(SgAsmValueExpression*);
883 virtual void visit(SgAsmCommonSubExpression*);
884 virtual void visit(SgAsmCoffSymbolTable*);
885 virtual void visit(SgAsmCoffSymbolList*);
886 virtual void visit(SgAsmCoffSymbol*);
887 virtual void visit(SgAsmGenericSymbol*);
888 virtual void visit(SgAsmCoffStrtab*);
889 virtual void visit(SgAsmGenericStrtab*);
890 virtual void visit(SgAsmCliHeader*);
891 virtual void visit(SgAsmGenericSection*);
892 virtual void visit(SgAsmCilUint8Heap*);
893 virtual void visit(SgAsmCilUint32Heap*);
894 virtual void visit(SgAsmCilTypeSpecTable*);
895 virtual void visit(SgAsmCilTypeSpec*);
896 virtual void visit(SgAsmCilTypeRefTable*);
897 virtual void visit(SgAsmCilTypeRef*);
898 virtual void visit(SgAsmCilTypeDefTable*);
899 virtual void visit(SgAsmCilTypeDef*);
900 virtual void visit(SgAsmCilStandAloneSigTable*);
901 virtual void visit(SgAsmCilStandAloneSig*);
902 virtual void visit(SgAsmCilPropertyTable*);
903 virtual void visit(SgAsmCilPropertyMapTable*);
904 virtual void visit(SgAsmCilPropertyMap*);
905 virtual void visit(SgAsmCilProperty*);
906 virtual void visit(SgAsmCilParamTable*);
907 virtual void visit(SgAsmCilParam*);
908 virtual void visit(SgAsmCilNestedClassTable*);
909 virtual void visit(SgAsmCilNestedClass*);
910 virtual void visit(SgAsmCilModuleTable*);
911 virtual void visit(SgAsmCilModuleRefTable*);
912 virtual void visit(SgAsmCilModuleRef*);
913 virtual void visit(SgAsmCilModule*);
914 virtual void visit(SgAsmCilMethodSpecTable*);
915 virtual void visit(SgAsmCilMethodSpec*);
916 virtual void visit(SgAsmCilMethodSemanticsTable*);
917 virtual void visit(SgAsmCilMethodSemantics*);
918 virtual void visit(SgAsmCilMethodImplTable*);
919 virtual void visit(SgAsmCilMethodImpl*);
920 virtual void visit(SgAsmCilMethodDefTable*);
921 virtual void visit(SgAsmCilMethodDef*);
922 virtual void visit(SgAsmCilMethodData*);
923 virtual void visit(SgAsmCilMetadataRoot*);
924 virtual void visit(SgAsmCilMetadataHeap*);
925 virtual void visit(SgAsmCilMemberRefTable*);
926 virtual void visit(SgAsmCilMemberRef*);
927 virtual void visit(SgAsmCilManifestResourceTable*);
928 virtual void visit(SgAsmCilManifestResource*);
929 virtual void visit(SgAsmCilInterfaceImplTable*);
930 virtual void visit(SgAsmCilInterfaceImpl*);
931 virtual void visit(SgAsmCilInstruction*);
932 virtual void visit(SgAsmCilImplMapTable*);
933 virtual void visit(SgAsmCilImplMap*);
934 virtual void visit(SgAsmCilGenericParamTable*);
935 virtual void visit(SgAsmCilGenericParam*);
936 virtual void visit(SgAsmCilGenericParamConstraintTable*);
937 virtual void visit(SgAsmCilGenericParamConstraint*);
938 virtual void visit(SgAsmCilFileTable*);
939 virtual void visit(SgAsmCilFile*);
940 virtual void visit(SgAsmCilFieldTable*);
941 virtual void visit(SgAsmCilFieldRVATable*);
942 virtual void visit(SgAsmCilFieldRVA*);
943 virtual void visit(SgAsmCilFieldMarshalTable*);
944 virtual void visit(SgAsmCilFieldMarshal*);
945 virtual void visit(SgAsmCilFieldLayoutTable*);
946 virtual void visit(SgAsmCilFieldLayout*);
947 virtual void visit(SgAsmCilField*);
948 virtual void visit(SgAsmCilExportedTypeTable*);
949 virtual void visit(SgAsmCilExportedType*);
950 virtual void visit(SgAsmCilExceptionData*);
951 virtual void visit(SgAsmCilEventTable*);
952 virtual void visit(SgAsmCilEventMapTable*);
953 virtual void visit(SgAsmCilEventMap*);
954 virtual void visit(SgAsmCilEvent*);
955 virtual void visit(SgAsmCilDeclSecurityTable*);
956 virtual void visit(SgAsmCilDeclSecurity*);
957 virtual void visit(SgAsmCilDataStream*);
958 virtual void visit(SgAsmCilCustomAttributeTable*);
959 virtual void visit(SgAsmCilCustomAttribute*);
960 virtual void visit(SgAsmCilConstantTable*);
961 virtual void visit(SgAsmCilConstant*);
962 virtual void visit(SgAsmCilClassLayoutTable*);
963 virtual void visit(SgAsmCilClassLayout*);
964 virtual void visit(SgAsmCilAssemblyTable*);
965 virtual void visit(SgAsmCilAssemblyRefTable*);
966 virtual void visit(SgAsmCilAssemblyRefProcessorTable*);
967 virtual void visit(SgAsmCilAssemblyRefProcessor*);
968 virtual void visit(SgAsmCilAssemblyRefOSTable*);
969 virtual void visit(SgAsmCilAssemblyRefOS*);
970 virtual void visit(SgAsmCilAssemblyRef*);
971 virtual void visit(SgAsmCilAssemblyProcessorTable*);
972 virtual void visit(SgAsmCilAssemblyProcessor*);
973 virtual void visit(SgAsmCilAssemblyOSTable*);
974 virtual void visit(SgAsmCilAssemblyOS*);
975 virtual void visit(SgAsmCilAssembly*);
976 virtual void visit(SgAsmCilMetadata*);
977 virtual void visit(SgAsmCilNode*);
978 virtual void visit(SgAsmByteOrder*);
979 virtual void visit(SgAsmBlock*);
980 virtual void visit(SgAsmBinarySubtract*);
981 virtual void visit(SgAsmBinaryRor*);
982 virtual void visit(SgAsmBinaryPreupdate*);
983 virtual void visit(SgAsmBinaryPostupdate*);
984 virtual void visit(SgAsmBinaryMultiply*);
985 virtual void visit(SgAsmBinaryMsl*);
986 virtual void visit(SgAsmBinaryMod*);
987 virtual void visit(SgAsmBinaryLsr*);
988 virtual void visit(SgAsmBinaryLsl*);
989 virtual void visit(SgAsmBinaryDivide*);
990 virtual void visit(SgAsmBinaryConcat*);
991 virtual void visit(SgAsmBinaryAsr*);
992 virtual void visit(SgAsmBinaryAdd*);
993 virtual void visit(SgAsmBinaryExpression*);
994 virtual void visit(SgAsmBasicString*);
995 virtual void visit(SgAsmGenericString*);
996 virtual void visit(SgAsmExecutableFileFormat*);
997 virtual void visit(SgAsmInstruction*);
998 virtual void visit(SgAsmStatement*);
999 virtual void visit(SgAsmAarch32Coprocessor*);
1000 virtual void visit(SgAsmExpression*);
1001 virtual void visit(SgAsmNode*);
1002 virtual void visit(SgCommonBlockObject*);
1003 virtual void visit(SgInitializedName*);
1004 virtual void visit(SgLambdaCapture*);
1005 virtual void visit(SgLambdaCaptureList*);
1006 virtual void visit(SgJavaMemberValuePair*);
1007 virtual void visit(SgOmpOrderedClause*);
1008 virtual void visit(SgOmpNowaitClause*);
1009 virtual void visit(SgOmpBeginClause*);
1010 virtual void visit(SgOmpEndClause*);
1011 virtual void visit(SgOmpUntiedClause*);
1012 virtual void visit(SgOmpMergeableClause*);
1013 virtual void visit(SgOmpDefaultClause*);
1014 virtual void visit(SgOmpAtomicClause*);
1015 virtual void visit(SgOmpProcBindClause*);
1016 virtual void visit(SgOmpInbranchClause*);
1017 virtual void visit(SgOmpNotinbranchClause*);
1018 virtual void visit(SgOmpCollapseClause*);
1019 virtual void visit(SgOmpIfClause*);
1020 virtual void visit(SgOmpFinalClause*);
1021 virtual void visit(SgOmpPriorityClause*);
1022 virtual void visit(SgOmpNumThreadsClause*);
1023 virtual void visit(SgOmpDeviceClause*);
1024 virtual void visit(SgOmpSafelenClause*);
1025 virtual void visit(SgOmpSimdlenClause*);
1026 virtual void visit(SgOmpExpressionClause*);
1027 virtual void visit(SgOmpCopyprivateClause*);
1028 virtual void visit(SgOmpPrivateClause*);
1029 virtual void visit(SgOmpFirstprivateClause*);
1030 virtual void visit(SgOmpSharedClause*);
1031 virtual void visit(SgOmpCopyinClause*);
1032 virtual void visit(SgOmpLastprivateClause*);
1033 virtual void visit(SgOmpReductionClause*);
1034 virtual void visit(SgOmpDependClause*);
1035 virtual void visit(SgOmpMapClause*);
1036 virtual void visit(SgOmpLinearClause*);
1037 virtual void visit(SgOmpUniformClause*);
1038 virtual void visit(SgOmpAlignedClause*);
1039 virtual void visit(SgOmpVariablesClause*);
1040 virtual void visit(SgOmpScheduleClause*);
1041 virtual void visit(SgOmpClause*);
1042 virtual void visit(SgRenamePair*);
1043 virtual void visit(SgInterfaceBody*);
1044 virtual void visit(SgHeaderFileBody*);
1045 virtual void visit(SgAdaRangeConstraint*);
1046 virtual void visit(SgAdaIndexConstraint*);
1047 virtual void visit(SgAdaDigitsConstraint*);
1048 virtual void visit(SgAdaDeltaConstraint*);
1049 virtual void visit(SgAdaDiscriminantConstraint*);
1050 virtual void visit(SgAdaNullConstraint*);
1051 virtual void visit(SgAdaTypeConstraint*);
1052 virtual void visit(SgLocatedNodeSupport*);
1053 virtual void visit(SgToken*);
1054 virtual void visit(SgLocatedNode*);
1055 virtual void visit(SgNode*);
1056};
1057
1059public:
1060 void visit(SgJovialBitVal*);
1061 void visit(SgName*);
1062 void visit(SgSymbolTable*);
1063 void visit(SgPragma*);
1064 void visit(SgModifierNodes*);
1065 void visit(SgConstVolatileModifier*);
1066 void visit(SgStorageModifier*);
1067 void visit(SgAccessModifier*);
1068 void visit(SgFunctionModifier*);
1069 void visit(SgUPC_AccessModifier*);
1070 void visit(SgLinkageModifier*);
1071 void visit(SgSpecialFunctionModifier*);
1072 void visit(SgTypeModifier*);
1073 void visit(SgElaboratedTypeModifier*);
1074 void visit(SgBaseClassModifier*);
1075 void visit(SgDeclarationModifier*);
1076 void visit(SgStructureModifier*);
1077 void visit(SgOpenclAccessModeModifier*);
1078 void visit(SgModifier*);
1079 void visit(Sg_File_Info*);
1080 void visit(SgSourceFile*);
1081 void visit(SgUnknownFile*);
1082 void visit(SgJvmComposite*);
1083 void visit(SgBinaryComposite*);
1084 void visit(SgFile*);
1085 void visit(SgFileList*);
1086 void visit(SgDirectory*);
1087 void visit(SgDirectoryList*);
1088 void visit(SgProject*);
1089 void visit(SgOptions*);
1090 void visit(SgUnparse_Info*);
1091 void visit(SgIncludeFile*);
1092 void visit(SgFuncDecl_attr*);
1093 void visit(SgClassDecl_attr*);
1094 void visit(SgTypedefSeq*);
1095 void visit(SgFunctionParameterTypeList*);
1096 void visit(SgTemplateParameter*);
1097 void visit(SgTemplateArgument*);
1098 void visit(SgTemplateParameterList*);
1099 void visit(SgTemplateArgumentList*);
1100 void visit(SgBitAttribute*);
1101 void visit(SgAttribute*);
1102 void visit(SgExpBaseClass*);
1103 void visit(SgNonrealBaseClass*);
1104 void visit(SgBaseClass*);
1105 void visit(SgUndirectedGraphEdge*);
1106 void visit(SgDirectedGraphEdge*);
1107 void visit(SgGraphNode*);
1108 void visit(SgGraphEdge*);
1110 void visit(SgIntKeyedBidirectionalGraph*);
1111 void visit(SgBidirectionalGraph*);
1112 void visit(SgIncidenceDirectedGraph*);
1113 void visit(SgIncidenceUndirectedGraph*);
1114 void visit(SgGraph*);
1115 void visit(SgGraphNodeList*);
1116 void visit(SgGraphEdgeList*);
1117 void visit(SgQualifiedName*);
1118 void visit(SgNameGroup*);
1119 void visit(SgDimensionObject*);
1120 void visit(SgDataStatementGroup*);
1121 void visit(SgDataStatementObject*);
1122 void visit(SgDataStatementValue*);
1123 void visit(SgFormatItem*);
1124 void visit(SgFormatItemList*);
1125 void visit(SgTypeTable*);
1126 void visit(SgJavaImportStatementList*);
1127 void visit(SgJavaClassDeclarationList*);
1128 void visit(SgHeaderFileReport*);
1129 void visit(SgSupport*);
1130 void visit(SgTypeUnknown*);
1131 void visit(SgTypeChar*);
1132 void visit(SgTypeSignedChar*);
1133 void visit(SgTypeUnsignedChar*);
1134 void visit(SgTypeShort*);
1135 void visit(SgTypeSignedShort*);
1136 void visit(SgTypeUnsignedShort*);
1137 void visit(SgTypeInt*);
1138 void visit(SgTypeSignedInt*);
1139 void visit(SgTypeUnsignedInt*);
1140 void visit(SgTypeLong*);
1141 void visit(SgTypeSignedLong*);
1142 void visit(SgTypeUnsignedLong*);
1143 void visit(SgTypeVoid*);
1144 void visit(SgTypeGlobalVoid*);
1145 void visit(SgTypeWchar*);
1146 void visit(SgTypeFloat*);
1147 void visit(SgTypeDouble*);
1148 void visit(SgTypeLongLong*);
1149 void visit(SgTypeSignedLongLong*);
1150 void visit(SgTypeUnsignedLongLong*);
1151 void visit(SgTypeLongDouble*);
1152 void visit(SgTypeFloat80*);
1153 void visit(SgTypeFloat128*);
1154 void visit(SgTypeString*);
1155 void visit(SgTypeBool*);
1156 void visit(SgTypeFixed*);
1157 void visit(SgTypeMatrix*);
1158 void visit(SgTypeTuple*);
1159 void visit(SgTypeNullptr*);
1160 void visit(SgTypeComplex*);
1161 void visit(SgTypeImaginary*);
1162 void visit(SgTypeDefault*);
1163 void visit(SgPointerMemberType*);
1164 void visit(SgReferenceType*);
1165 void visit(SgRvalueReferenceType*);
1166 void visit(SgDeclType*);
1167 void visit(SgTypeOfType*);
1168 void visit(SgTypeCAFTeam*);
1169 void visit(SgTypeUnsigned128bitInteger*);
1170 void visit(SgTypeSigned128bitInteger*);
1171 void visit(SgTypeLabel*);
1172 void visit(SgJavaParameterizedType*);
1173 void visit(SgJavaQualifiedType*);
1174 void visit(SgJavaWildcardType*);
1175 void visit(SgJavaUnionType*);
1176 void visit(SgJavaParameterType*);
1177 void visit(SgJovialTableType*);
1178 void visit(SgTemplateType*);
1179 void visit(SgEnumType*);
1180 void visit(SgTypedefType*);
1181 void visit(SgNonrealType*);
1182 void visit(SgAutoType*);
1183 void visit(SgModifierType*);
1184 void visit(SgPartialFunctionModifierType*);
1185 void visit(SgArrayType*);
1186 void visit(SgTypeEllipse*);
1187 void visit(SgAdaAccessType*);
1188 void visit(SgAdaSubtype*);
1189 void visit(SgAdaDerivedType*);
1190 void visit(SgAdaModularType*);
1191 void visit(SgAdaDiscriminatedType*);
1192 void visit(SgAdaFormalType*);
1193 void visit(SgAdaDiscreteType*);
1194 void visit(SgAdaSubroutineType*);
1195 void visit(SgRangeType*);
1196 void visit(SgJovialBitType*);
1197 void visit(SgTypeCrayPointer*);
1198 void visit(SgPartialFunctionType*);
1199 void visit(SgMemberFunctionType*);
1200 void visit(SgFunctionType*);
1201 void visit(SgPointerType*);
1202 void visit(SgAdaTaskType*);
1203 void visit(SgAdaProtectedType*);
1204 void visit(SgClassType*);
1205 void visit(SgNamedType*);
1206 void visit(SgQualifiedNameType*);
1207 void visit(SgTypeChar16*);
1208 void visit(SgTypeChar32*);
1209 void visit(SgType*);
1210 void visit(SgForStatement*);
1211 void visit(SgForInitStatement*);
1212 void visit(SgRangeBasedForStatement*);
1213 void visit(SgCatchStatementSeq*);
1214 void visit(SgFunctionParameterList*);
1215 void visit(SgAdaParameterList*);
1216 void visit(SgCtorInitializerList*);
1217 void visit(SgBasicBlock*);
1218 void visit(SgGlobal*);
1219 void visit(SgIfStmt*);
1220 void visit(SgWhileStmt*);
1221 void visit(SgDoWhileStmt*);
1222 void visit(SgSwitchStatement*);
1223 void visit(SgCatchOptionStmt*);
1224 void visit(SgFunctionParameterScope*);
1225 void visit(SgDeclarationScope*);
1226 void visit(SgVariableDefinition*);
1227 void visit(SgStmtDeclarationStatement*);
1228 void visit(SgEnumDeclaration*);
1229 void visit(SgAsmStmt*);
1230 void visit(SgFunctionTypeTable*);
1231 void visit(SgExprStatement*);
1232 void visit(SgLabelStatement*);
1233 void visit(SgCaseOptionStmt*);
1234 void visit(SgTryStmt*);
1235 void visit(SgDefaultOptionStmt*);
1236 void visit(SgBreakStmt*);
1237 void visit(SgContinueStmt*);
1238 void visit(SgReturnStmt*);
1239 void visit(SgGotoStatement*);
1240 void visit(SgAdaExitStmt*);
1241 void visit(SgAdaLoopStmt*);
1242 void visit(SgAdaDelayStmt*);
1243 void visit(SgAdaSelectStmt*);
1244 void visit(SgAdaSelectAlternativeStmt*);
1245 void visit(SgAdaTerminateStmt*);
1246 void visit(SgAdaUnscopedBlock*);
1247 void visit(SgAdaVariantWhenStmt*);
1248 void visit(SgSpawnStmt*);
1249 void visit(SgFortranContinueStmt*);
1250 void visit(SgTemplateTypedefDeclaration*);
1252 void visit(SgTypedefDeclaration*);
1253 void visit(SgNullStatement*);
1254 void visit(SgVariantStatement*);
1255 void visit(SgPragmaDeclaration*);
1256 void visit(SgTemplateClassDeclaration*);
1258 void visit(SgTemplateFunctionDeclaration*);
1259 void visit(SgTemplateVariableDeclaration*);
1260 void visit(SgTemplateDeclaration*);
1261 void visit(SgVariableDeclaration*);
1262 void visit(SgTemplateInstantiationDecl*);
1263 void visit(SgTemplateInstantiationDefn*);
1266 void visit(SgNonrealDecl*);
1267 void visit(SgWithStatement*);
1268 void visit(SgPythonGlobalStmt*);
1269 void visit(SgPythonPrintStmt*);
1270 void visit(SgPassStatement*);
1271 void visit(SgAssertStmt*);
1272 void visit(SgExecStatement*);
1273 void visit(SgProgramHeaderStatement*);
1274 void visit(SgProcedureHeaderStatement*);
1275 void visit(SgEntryStatement*);
1276 void visit(SgFortranNonblockedDo*);
1277 void visit(SgInterfaceStatement*);
1278 void visit(SgParameterStatement*);
1279 void visit(SgCommonBlock*);
1280 void visit(SgModuleStatement*);
1281 void visit(SgUseStatement*);
1282 void visit(SgProcessControlStatement*);
1283 void visit(SgPrintStatement*);
1284 void visit(SgReadStatement*);
1285 void visit(SgWriteStatement*);
1286 void visit(SgOpenStatement*);
1287 void visit(SgCloseStatement*);
1288 void visit(SgInquireStatement*);
1289 void visit(SgFlushStatement*);
1290 void visit(SgBackspaceStatement*);
1291 void visit(SgRewindStatement*);
1292 void visit(SgEndfileStatement*);
1293 void visit(SgWaitStatement*);
1294 void visit(SgCAFWithTeamStatement*);
1295 void visit(SgFormatStatement*);
1296 void visit(SgFortranDo*);
1297 void visit(SgForAllStatement*);
1298 void visit(SgIOStatement*);
1299 void visit(SgSyncAllStatement*);
1300 void visit(SgSyncImagesStatement*);
1301 void visit(SgSyncMemoryStatement*);
1302 void visit(SgSyncTeamStatement*);
1303 void visit(SgLockStatement*);
1304 void visit(SgUnlockStatement*);
1305 void visit(SgImageControlStatement*);
1306 void visit(SgJovialCompoolStatement*);
1307 void visit(SgJovialDefineDeclaration*);
1308 void visit(SgJovialDirectiveStatement*);
1309 void visit(SgJovialLabelDeclaration*);
1310 void visit(SgJovialOverlayDeclaration*);
1311 void visit(SgJovialForThenStatement*);
1312 void visit(SgMatlabForStatement*);
1313 void visit(SgUpcNotifyStatement*);
1314 void visit(SgUpcWaitStatement*);
1315 void visit(SgUpcBarrierStatement*);
1316 void visit(SgUpcFenceStatement*);
1317 void visit(SgUpcForAllStatement*);
1318 void visit(SgOmpParallelStatement*);
1319 void visit(SgOmpSingleStatement*);
1320 void visit(SgOmpTaskStatement*);
1321 void visit(SgOmpForStatement*);
1322 void visit(SgOmpForSimdStatement*);
1323 void visit(SgOmpDoStatement*);
1324 void visit(SgOmpSectionsStatement*);
1325 void visit(SgOmpAtomicStatement*);
1326 void visit(SgOmpTargetStatement*);
1327 void visit(SgOmpTargetDataStatement*);
1328 void visit(SgOmpSimdStatement*);
1329 void visit(SgOmpClauseBodyStatement*);
1330 void visit(SgOmpMasterStatement*);
1331 void visit(SgOmpSectionStatement*);
1332 void visit(SgOmpOrderedStatement*);
1333 void visit(SgOmpWorkshareStatement*);
1334 void visit(SgOmpCriticalStatement*);
1335 void visit(SgOmpBodyStatement*);
1336 void visit(SgJavaThrowStatement*);
1337 void visit(SgJavaForEachStatement*);
1338 void visit(SgJavaSynchronizedStatement*);
1339 void visit(SgJavaLabelStatement*);
1340 void visit(SgJavaImportStatement*);
1341 void visit(SgJavaPackageDeclaration*);
1342 void visit(SgJavaPackageStatement*);
1343 void visit(SgAsyncStmt*);
1344 void visit(SgFinishStmt*);
1345 void visit(SgAtStmt*);
1346 void visit(SgAtomicStmt*);
1347 void visit(SgWhenStmt*);
1348 void visit(SgBlockDataStatement*);
1349 void visit(SgImplicitStatement*);
1350 void visit(SgStatementFunctionStatement*);
1351 void visit(SgWhereStatement*);
1352 void visit(SgNullifyStatement*);
1353 void visit(SgEquivalenceStatement*);
1354 void visit(SgDerivedTypeStatement*);
1355 void visit(SgJovialTableStatement*);
1357 void visit(SgAllocateStatement*);
1358 void visit(SgDeallocateStatement*);
1359 void visit(SgContainsStatement*);
1360 void visit(SgSequenceStatement*);
1361 void visit(SgElseWhereStatement*);
1362 void visit(SgArithmeticIfStatement*);
1363 void visit(SgAssignStatement*);
1364 void visit(SgComputedGotoStatement*);
1365 void visit(SgAssignedGotoStatement*);
1366 void visit(SgNamelistStatement*);
1367 void visit(SgImportStatement*);
1368 void visit(SgAssociateStatement*);
1369 void visit(SgFortranIncludeLine*);
1372 void visit(SgNamespaceDefinitionStatement*);
1373 void visit(SgUsingDeclarationStatement*);
1374 void visit(SgUsingDirectiveStatement*);
1376 void visit(SgStaticAssertionDeclaration*);
1377 void visit(SgTemplateClassDefinition*);
1378 void visit(SgTemplateFunctionDefinition*);
1379 void visit(SgClassDeclaration*);
1380 void visit(SgClassDefinition*);
1381 void visit(SgFunctionDefinition*);
1382 void visit(SgAdaAcceptStmt*);
1383 void visit(SgAdaPackageBody*);
1384 void visit(SgAdaPackageSpec*);
1385 void visit(SgAdaTaskBody*);
1386 void visit(SgAdaTaskSpec*);
1387 void visit(SgAdaProtectedBody*);
1388 void visit(SgAdaProtectedSpec*);
1389 void visit(SgAdaGenericDefn*);
1390 void visit(SgScopeStatement*);
1391 void visit(SgMemberFunctionDeclaration*);
1392 void visit(SgAdaEntryDecl*);
1393 void visit(SgAdaFunctionRenamingDecl*);
1394 void visit(SgFunctionDeclaration*);
1395 void visit(SgIncludeDirectiveStatement*);
1396 void visit(SgDefineDirectiveStatement*);
1397 void visit(SgUndefDirectiveStatement*);
1398 void visit(SgIfdefDirectiveStatement*);
1399 void visit(SgIfndefDirectiveStatement*);
1400 void visit(SgIfDirectiveStatement*);
1401 void visit(SgDeadIfDirectiveStatement*);
1402 void visit(SgElseDirectiveStatement*);
1403 void visit(SgElseifDirectiveStatement*);
1404 void visit(SgEndifDirectiveStatement*);
1405 void visit(SgLineDirectiveStatement*);
1406 void visit(SgWarningDirectiveStatement*);
1407 void visit(SgErrorDirectiveStatement*);
1408 void visit(SgEmptyDirectiveStatement*);
1410 void visit(SgIdentDirectiveStatement*);
1411 void visit(SgLinemarkerDirectiveStatement*);
1413 void visit(SgClinkageStartStatement*);
1414 void visit(SgClinkageEndStatement*);
1415 void visit(SgClinkageDeclarationStatement*);
1416 void visit(SgOmpFlushStatement*);
1417 void visit(SgOmpDeclareSimdStatement*);
1418 void visit(SgOmpBarrierStatement*);
1419 void visit(SgOmpTaskwaitStatement*);
1420 void visit(SgOmpThreadprivateStatement*);
1422 void visit(SgEmptyDeclaration*);
1423 void visit(SgAdaPackageSpecDecl*);
1424 void visit(SgAdaPackageBodyDecl*);
1425 void visit(SgAdaTaskSpecDecl*);
1426 void visit(SgAdaTaskTypeDecl*);
1427 void visit(SgAdaTaskBodyDecl*);
1428 void visit(SgAdaProtectedSpecDecl*);
1429 void visit(SgAdaProtectedTypeDecl*);
1430 void visit(SgAdaProtectedBodyDecl*);
1431 void visit(SgAdaRepresentationClause*);
1432 void visit(SgAdaEnumRepresentationClause*);
1433 void visit(SgAdaAttributeClause*);
1434 void visit(SgAdaComponentClause*);
1435 void visit(SgAdaRenamingDecl*);
1436 void visit(SgAdaGenericDecl*);
1437 void visit(SgAdaGenericInstanceDecl*);
1438 void visit(SgAdaFormalTypeDecl*);
1439 void visit(SgAdaFormalPackageDecl*);
1440 void visit(SgAdaDiscriminatedTypeDecl*);
1441 void visit(SgAdaVariantDecl*);
1442 void visit(SgDeclarationStatement*);
1443 void visit(SgStatement*);
1444 void visit(SgAbsOp*);
1445 void visit(SgActualArgumentExpression*);
1446 void visit(SgAdaAncestorInitializer*);
1447 void visit(SgAdaAttributeExp*);
1448 void visit(SgAdaFloatVal*);
1449 void visit(SgAdaOthersExp*);
1450 void visit(SgAdaProtectedRefExp*);
1451 void visit(SgAdaRenamingRefExp*);
1452 void visit(SgAdaTaskRefExp*);
1453 void visit(SgAdaUnitRefExp*);
1454 void visit(SgAddOp*);
1455 void visit(SgAddressOfOp*);
1456 void visit(SgAggregateInitializer*);
1457 void visit(SgAlignOfOp*);
1458 void visit(SgAndAssignOp*);
1459 void visit(SgAndOp*);
1460 void visit(SgArrowExp*);
1461 void visit(SgArrowStarOp*);
1462 void visit(SgAsmOp*);
1463 void visit(SgAssignInitializer*);
1464 void visit(SgAssignOp*);
1465 void visit(SgAsteriskShapeExp*);
1466 void visit(SgAtExp*);
1467 void visit(SgAtOp*);
1468 void visit(SgAwaitExpression*);
1469 void visit(SgBitAndOp*);
1470 void visit(SgBitComplementOp*);
1471 void visit(SgBitEqvOp*);
1472 void visit(SgBitOrOp*);
1473 void visit(SgBitXorOp*);
1474 void visit(SgBoolValExp*);
1475 void visit(SgBracedInitializer*);
1476 void visit(SgCAFCoExpression*);
1477 void visit(SgCastExp*);
1478 void visit(SgChar16Val*);
1479 void visit(SgChar32Val*);
1480 void visit(SgCharVal*);
1481 void visit(SgChooseExpression*);
1482 void visit(SgClassExp*);
1483 void visit(SgClassNameRefExp*);
1484 void visit(SgColonShapeExp*);
1485 void visit(SgCommaOpExp*);
1486 void visit(SgComplexVal*);
1487 void visit(SgCompoundInitializer*);
1488 void visit(SgCompoundLiteralExp*);
1489 void visit(SgComprehension*);
1490 void visit(SgConcatenationOp*);
1491 void visit(SgConjugateOp*);
1492 void visit(SgConditionalExp*);
1493 void visit(SgConstructorInitializer*);
1494 void visit(SgCudaKernelCallExp*);
1495 void visit(SgCudaKernelExecConfig*);
1496 void visit(SgDeleteExp*);
1497 void visit(SgDesignatedInitializer*);
1498 void visit(SgDictionaryComprehension*);
1499 void visit(SgDictionaryExp*);
1500 void visit(SgDivAssignOp*);
1501 void visit(SgDivideOp*);
1502 void visit(SgDotDotExp*);
1503 void visit(SgDotExp*);
1504 void visit(SgDotStarOp*);
1505 void visit(SgDoubleVal*);
1506 void visit(SgElementwiseAddOp*);
1507 void visit(SgElementwiseDivideOp*);
1508 void visit(SgElementwiseLeftDivideOp*);
1509 void visit(SgElementwiseMultiplyOp*);
1510 void visit(SgElementwisePowerOp*);
1511 void visit(SgElementwiseSubtractOp*);
1512 void visit(SgEnumVal*);
1513 void visit(SgEqualityOp*);
1514 void visit(SgExponentiationAssignOp*);
1515 void visit(SgExponentiationOp*);
1516 void visit(SgExpressionRoot*);
1517 void visit(SgFinishExp*);
1518 void visit(SgFloat128Val*);
1519 void visit(SgFloat80Val*);
1520 void visit(SgFloatVal*);
1521 void visit(SgFoldExpression*);
1522 void visit(SgFunctionParameterRefExp*);
1523 void visit(SgFunctionRefExp*);
1524 void visit(SgGreaterOrEqualOp*);
1525 void visit(SgGreaterThanOp*);
1526 void visit(SgHereExp*);
1527 void visit(SgImagPartOp*);
1528 void visit(SgImpliedDo*);
1529 void visit(SgIntegerDivideAssignOp*);
1530 void visit(SgIntegerDivideOp*);
1531 void visit(SgIntVal*);
1532 void visit(SgIOItemExpression*);
1533 void visit(SgIorAssignOp*);
1534 void visit(SgIsNotOp*);
1535 void visit(SgIsOp*);
1536 void visit(SgJavaInstanceOfOp*);
1537 void visit(SgJavaMarkerAnnotation*);
1538 void visit(SgJavaNormalAnnotation*);
1539 void visit(SgJavaSingleMemberAnnotation*);
1540 void visit(SgJavaTypeExpression*);
1541 void visit(SgJavaUnsignedRshiftAssignOp*);
1542 void visit(SgJavaUnsignedRshiftOp*);
1543 void visit(SgJovialPresetPositionExp*);
1544 void visit(SgJovialTablePresetExp*);
1545 void visit(SgKeyDatumPair*);
1546 void visit(SgLabelRefExp*);
1547 void visit(SgLambdaExp*);
1548 void visit(SgLambdaRefExp*);
1549 void visit(SgLeftDivideOp*);
1550 void visit(SgLessOrEqualOp*);
1551 void visit(SgLessThanOp*);
1552 void visit(SgListComprehension*);
1553 void visit(SgListExp*);
1554 void visit(SgLongDoubleVal*);
1555 void visit(SgLongIntVal*);
1556 void visit(SgLongLongIntVal*);
1557 void visit(SgLshiftAssignOp*);
1558 void visit(SgLshiftOp*);
1559 void visit(SgMagicColonExp*);
1560 void visit(SgMatrixExp*);
1561 void visit(SgMatrixTransposeOp*);
1562 void visit(SgMemberFunctionRefExp*);
1563 void visit(SgMembershipOp*);
1564 void visit(SgMinusAssignOp*);
1565 void visit(SgMinusMinusOp*);
1566 void visit(SgMinusOp*);
1567 void visit(SgModAssignOp*);
1568 void visit(SgModOp*);
1569 void visit(SgMultAssignOp*);
1570 void visit(SgMultiplyOp*);
1571 void visit(SgNaryBooleanOp*);
1572 void visit(SgNaryComparisonOp*);
1573 void visit(SgNewExp*);
1574 void visit(SgNoexceptOp*);
1575 void visit(SgNonMembershipOp*);
1576 void visit(SgNonrealRefExp*);
1577 void visit(SgNotOp*);
1578 void visit(SgNotEqualOp*);
1579 void visit(SgNullExpression*);
1580 void visit(SgNullptrValExp*);
1581 void visit(SgOrOp*);
1582 void visit(SgPlusAssignOp*);
1583 void visit(SgPlusPlusOp*);
1584 void visit(SgPntrArrRefExp*);
1585 void visit(SgPointerAssignOp*);
1586 void visit(SgPointerDerefExp*);
1587 void visit(SgPowerOp*);
1588 void visit(SgPseudoDestructorRefExp*);
1589 void visit(SgRangeExp*);
1590 void visit(SgRealPartOp*);
1591 void visit(SgRefExp*);
1592 void visit(SgRemOp*);
1593 void visit(SgReplicationOp*);
1594 void visit(SgRshiftAssignOp*);
1595 void visit(SgRshiftOp*);
1596 void visit(SgScopeOp*);
1597 void visit(SgSetComprehension*);
1598 void visit(SgShortVal*);
1599 void visit(SgSizeOfOp*);
1600 void visit(SgSpaceshipOp*);
1601 void visit(SgStatementExpression*);
1602 void visit(SgStringConversion*);
1603 void visit(SgStringVal*);
1604 void visit(SgSubscriptExpression*);
1605 void visit(SgSubtractOp*);
1606 void visit(SgSuperExp*);
1607 void visit(SgTemplateFunctionRefExp*);
1608 void visit(SgTemplateMemberFunctionRefExp*);
1609 void visit(SgTemplateParameterVal*);
1610 void visit(SgThisExp*);
1611 void visit(SgThrowOp*);
1612 void visit(SgTupleExp*);
1613 void visit(SgTypeExpression*);
1614 void visit(SgTypeIdOp*);
1615 void visit(SgTypeTraitBuiltinOperator*);
1616 void visit(SgUnaryAddOp*);
1618 void visit(SgUnsignedCharVal*);
1619 void visit(SgUnsignedIntVal*);
1620 void visit(SgUnsignedLongLongIntVal*);
1621 void visit(SgUnsignedLongVal*);
1622 void visit(SgUnsignedShortVal*);
1623 void visit(SgUpcBlocksizeofExpression*);
1624 void visit(SgUpcElemsizeofExpression*);
1625 void visit(SgUpcLocalsizeofExpression*);
1626 void visit(SgUpcMythread*);
1627 void visit(SgUpcThreads*);
1628 void visit(SgUserDefinedBinaryOp*);
1629 void visit(SgUserDefinedUnaryOp*);
1630 void visit(SgVarArgCopyOp*);
1631 void visit(SgVarArgEndOp*);
1632 void visit(SgVarArgOp*);
1633 void visit(SgVarArgStartOneOperandOp*);
1634 void visit(SgVarArgStartOp*);
1635 void visit(SgVariantExpression*);
1636 void visit(SgVarRefExp*);
1637 void visit(SgVoidVal*);
1638 void visit(SgWcharVal*);
1639 void visit(SgXorAssignOp*);
1640 void visit(SgYieldExpression*);
1641 void visit(SgCompoundAssignOp*);
1642 void visit(SgElementwiseOp*);
1643 void visit(SgBinaryOp*);
1644 void visit(SgFunctionCallExp*);
1645 void visit(SgCallExpression*);
1646 void visit(SgExprListExp*);
1647 void visit(SgInitializer*);
1648 void visit(SgJavaAnnotation*);
1649 void visit(SgNaryOp*);
1650 void visit(SgUnaryOp*);
1651 void visit(SgValueExp*);
1652 void visit(SgExpression*);
1653 void visit(SgTemplateVariableSymbol*);
1654 void visit(SgVariableSymbol*);
1655 void visit(SgFunctionTypeSymbol*);
1656 void visit(SgTemplateClassSymbol*);
1657 void visit(SgClassSymbol*);
1658 void visit(SgTemplateSymbol*);
1659 void visit(SgEnumSymbol*);
1660 void visit(SgEnumFieldSymbol*);
1661 void visit(SgTemplateTypedefSymbol*);
1662 void visit(SgTypedefSymbol*);
1663 void visit(SgTemplateFunctionSymbol*);
1664 void visit(SgTemplateMemberFunctionSymbol*);
1665 void visit(SgLabelSymbol*);
1666 void visit(SgJavaLabelSymbol*);
1667 void visit(SgDefaultSymbol*);
1668 void visit(SgNamespaceSymbol*);
1669 void visit(SgIntrinsicSymbol*);
1670 void visit(SgModuleSymbol*);
1671 void visit(SgInterfaceSymbol*);
1672 void visit(SgCommonSymbol*);
1673 void visit(SgRenameSymbol*);
1674 void visit(SgAdaInheritedFunctionSymbol*);
1675 void visit(SgMemberFunctionSymbol*);
1676 void visit(SgFunctionSymbol*);
1677 void visit(SgAsmBinaryAddressSymbol*);
1678 void visit(SgAsmBinaryDataSymbol*);
1679 void visit(SgAliasSymbol*);
1680 void visit(SgNonrealSymbol*);
1681 void visit(SgAdaPackageSymbol*);
1682 void visit(SgAdaTaskSymbol*);
1683 void visit(SgAdaProtectedSymbol*);
1684 void visit(SgAdaGenericSymbol*);
1685 void visit(SgAdaGenericInstanceSymbol*);
1686 void visit(SgAdaFormalPackageSymbol*);
1687 void visit(SgAdaRenamingSymbol*);
1688 void visit(SgSymbol*);
1689 void visit(SgAsmX86Instruction*);
1690 void visit(SgAsmVoidType*);
1691 void visit(SgAsmVectorType*);
1692 void visit(SgAsmUserInstruction*);
1693 void visit(SgAsmUnaryUnsignedExtend*);
1694 void visit(SgAsmUnaryTruncate*);
1695 void visit(SgAsmUnarySignedExtend*);
1696 void visit(SgAsmUnaryRrx*);
1697 void visit(SgAsmUnaryPlus*);
1698 void visit(SgAsmUnaryMinus*);
1699 void visit(SgAsmUnaryExpression*);
1702 void visit(SgAsmStringStorage*);
1703 void visit(SgAsmStoredString*);
1704 void visit(SgAsmStaticData*);
1705 void visit(SgAsmStackExpression*);
1706 void visit(SgAsmRiscOperation*);
1707 void visit(SgAsmRegisterNames*);
1708 void visit(SgAsmPowerpcInstruction*);
1709 void visit(SgAsmPointerType*);
1710 void visit(SgAsmPEStringSection*);
1711 void visit(SgAsmPESectionTable*);
1712 void visit(SgAsmPESectionTableEntry*);
1713 void visit(SgAsmPERVASizePairList*);
1714 void visit(SgAsmPERVASizePair*);
1715 void visit(SgAsmPEImportSection*);
1716 void visit(SgAsmPEImportItemList*);
1717 void visit(SgAsmPEImportItem*);
1718 void visit(SgAsmPEImportDirectoryList*);
1719 void visit(SgAsmPEImportDirectory*);
1720 void visit(SgAsmPEFileHeader*);
1721 void visit(SgAsmPEExportSection*);
1722 void visit(SgAsmPESection*);
1723 void visit(SgAsmPEExportEntryList*);
1724 void visit(SgAsmPEExportEntry*);
1725 void visit(SgAsmPEExportDirectory*);
1726 void visit(SgAsmOperandList*);
1727 void visit(SgAsmNullInstruction*);
1728 void visit(SgAsmNEStringTable*);
1729 void visit(SgAsmNESectionTable*);
1730 void visit(SgAsmNESectionTableEntry*);
1731 void visit(SgAsmNESection*);
1732 void visit(SgAsmNERelocTable*);
1733 void visit(SgAsmNERelocEntry*);
1734 void visit(SgAsmNENameTable*);
1735 void visit(SgAsmNEModuleTable*);
1736 void visit(SgAsmNEFileHeader*);
1737 void visit(SgAsmNEEntryTable*);
1738 void visit(SgAsmNEEntryPoint*);
1739 void visit(SgAsmMipsInstruction*);
1740 void visit(SgAsmMemoryReferenceExpression*);
1741 void visit(SgAsmM68kInstruction*);
1742 void visit(SgAsmLESectionTable*);
1743 void visit(SgAsmLESectionTableEntry*);
1744 void visit(SgAsmLESection*);
1745 void visit(SgAsmLERelocTable*);
1746 void visit(SgAsmLEPageTable*);
1747 void visit(SgAsmLEPageTableEntry*);
1748 void visit(SgAsmLENameTable*);
1749 void visit(SgAsmLEFileHeader*);
1750 void visit(SgAsmLEEntryTable*);
1751 void visit(SgAsmLEEntryPoint*);
1753 void visit(SgAsmJvmStackMapTable*);
1754 void visit(SgAsmJvmStackMapFrame*);
1755 void visit(SgAsmJvmSourceFile*);
1756 void visit(SgAsmJvmSignature*);
1757 void visit(SgAsmJvmNestMembers*);
1758 void visit(SgAsmJvmNestHost*);
1759 void visit(SgAsmJvmModuleMainClass*);
1760 void visit(SgAsmJvmMethodTable*);
1761 void visit(SgAsmJvmMethodParameters*);
1762 void visit(SgAsmJvmMethodParametersEntry*);
1763 void visit(SgAsmJvmMethod*);
1764 void visit(SgAsmJvmLocalVariableTypeTable*);
1765 void visit(SgAsmJvmLocalVariableTypeEntry*);
1766 void visit(SgAsmJvmLocalVariableTable*);
1767 void visit(SgAsmJvmLocalVariableEntry*);
1768 void visit(SgAsmJvmLineNumberTable*);
1769 void visit(SgAsmJvmLineNumberEntry*);
1770 void visit(SgAsmJvmInstruction*);
1771 void visit(SgAsmJvmInnerClasses*);
1772 void visit(SgAsmJvmInnerClassesEntry*);
1773 void visit(SgAsmJvmFileHeader*);
1774 void visit(SgAsmJvmFieldTable*);
1775 void visit(SgAsmJvmField*);
1776 void visit(SgAsmJvmExceptionTable*);
1777 void visit(SgAsmJvmExceptions*);
1778 void visit(SgAsmJvmExceptionHandler*);
1779 void visit(SgAsmJvmEnclosingMethod*);
1780 void visit(SgAsmJvmConstantValue*);
1781 void visit(SgAsmJvmConstantPool*);
1782 void visit(SgAsmJvmConstantPoolEntry*);
1783 void visit(SgAsmJvmCodeAttribute*);
1784 void visit(SgAsmJvmClass*);
1785 void visit(SgAsmJvmBootstrapMethods*);
1786 void visit(SgAsmJvmBootstrapMethod*);
1787 void visit(SgAsmJvmAttributeTable*);
1788 void visit(SgAsmJvmAttribute*);
1789 void visit(SgAsmJvmNode*);
1790 void visit(SgAsmInterpretationList*);
1791 void visit(SgAsmInterpretation*);
1792 void visit(SgAsmIntegerValueExpression*);
1793 void visit(SgAsmIntegerType*);
1794 void visit(SgAsmInstructionList*);
1796 void visit(SgAsmGenericSymbolList*);
1797 void visit(SgAsmGenericSectionList*);
1798 void visit(SgAsmGenericHeaderList*);
1799 void visit(SgAsmGenericFormat*);
1800 void visit(SgAsmGenericFileList*);
1801 void visit(SgAsmGenericFile*);
1802 void visit(SgAsmGenericDLLList*);
1803 void visit(SgAsmGenericDLL*);
1804 void visit(SgAsmFunction*);
1805 void visit(SgAsmSynthesizedDeclaration*);
1806 void visit(SgAsmFloatValueExpression*);
1807 void visit(SgAsmFloatType*);
1808 void visit(SgAsmScalarType*);
1809 void visit(SgAsmType*);
1810 void visit(SgAsmExprListExp*);
1811 void visit(SgAsmElfSymverSection*);
1812 void visit(SgAsmElfSymverNeededSection*);
1813 void visit(SgAsmElfSymverNeededEntryList*);
1814 void visit(SgAsmElfSymverNeededEntry*);
1815 void visit(SgAsmElfSymverNeededAuxList*);
1816 void visit(SgAsmElfSymverNeededAux*);
1817 void visit(SgAsmElfSymverEntryList*);
1818 void visit(SgAsmElfSymverEntry*);
1819 void visit(SgAsmElfSymverDefinedSection*);
1820 void visit(SgAsmElfSymverDefinedEntryList*);
1821 void visit(SgAsmElfSymverDefinedEntry*);
1822 void visit(SgAsmElfSymverDefinedAuxList*);
1823 void visit(SgAsmElfSymverDefinedAux*);
1824 void visit(SgAsmElfSymbolSection*);
1825 void visit(SgAsmElfSymbolList*);
1826 void visit(SgAsmElfSymbol*);
1827 void visit(SgAsmElfStrtab*);
1828 void visit(SgAsmElfStringSection*);
1829 void visit(SgAsmElfSegmentTable*);
1830 void visit(SgAsmElfSegmentTableEntryList*);
1831 void visit(SgAsmElfSegmentTableEntry*);
1832 void visit(SgAsmElfSectionTable*);
1833 void visit(SgAsmElfSectionTableEntry*);
1834 void visit(SgAsmElfRelocSection*);
1835 void visit(SgAsmElfRelocEntryList*);
1836 void visit(SgAsmElfRelocEntry*);
1837 void visit(SgAsmElfNoteSection*);
1838 void visit(SgAsmElfNoteEntryList*);
1839 void visit(SgAsmElfNoteEntry*);
1840 void visit(SgAsmElfFileHeader*);
1841 void visit(SgAsmElfEHFrameSection*);
1842 void visit(SgAsmElfEHFrameEntryFDList*);
1843 void visit(SgAsmElfEHFrameEntryFD*);
1844 void visit(SgAsmElfEHFrameEntryCIList*);
1845 void visit(SgAsmElfEHFrameEntryCI*);
1846 void visit(SgAsmElfDynamicSection*);
1847 void visit(SgAsmElfSection*);
1848 void visit(SgAsmElfDynamicEntryList*);
1849 void visit(SgAsmElfDynamicEntry*);
1850 void visit(SgAsmDwarfWithStmt*);
1851 void visit(SgAsmDwarfVolatileType*);
1852 void visit(SgAsmDwarfVariantPart*);
1853 void visit(SgAsmDwarfVariant*);
1854 void visit(SgAsmDwarfVariable*);
1855 void visit(SgAsmDwarfUpcStrictType*);
1856 void visit(SgAsmDwarfUpcSharedType*);
1857 void visit(SgAsmDwarfUpcRelaxedType*);
1858 void visit(SgAsmDwarfUnspecifiedType*);
1860 void visit(SgAsmDwarfUnknownConstruct*);
1861 void visit(SgAsmDwarfUnionType*);
1862 void visit(SgAsmDwarfTypedef*);
1863 void visit(SgAsmDwarfTryBlock*);
1864 void visit(SgAsmDwarfThrownType*);
1867 void visit(SgAsmDwarfSubroutineType*);
1868 void visit(SgAsmDwarfSubrangeType*);
1869 void visit(SgAsmDwarfSubprogram*);
1870 void visit(SgAsmDwarfStructureType*);
1871 void visit(SgAsmDwarfStringType*);
1872 void visit(SgAsmDwarfSharedType*);
1873 void visit(SgAsmDwarfSetType*);
1874 void visit(SgAsmDwarfRestrictType*);
1875 void visit(SgAsmDwarfReferenceType*);
1876 void visit(SgAsmDwarfPtrToMemberType*);
1877 void visit(SgAsmDwarfPointerType*);
1878 void visit(SgAsmDwarfPartialUnit*);
1879 void visit(SgAsmDwarfPackedType*);
1880 void visit(SgAsmDwarfNamespace*);
1881 void visit(SgAsmDwarfNamelistItem*);
1882 void visit(SgAsmDwarfNamelist*);
1883 void visit(SgAsmDwarfMutableType*);
1884 void visit(SgAsmDwarfModule*);
1885 void visit(SgAsmDwarfMember*);
1886 void visit(SgAsmDwarfMacroList*);
1887 void visit(SgAsmDwarfMacro*);
1888 void visit(SgAsmDwarfLineList*);
1889 void visit(SgAsmDwarfLine*);
1890 void visit(SgAsmDwarfLexicalBlock*);
1891 void visit(SgAsmDwarfLabel*);
1892 void visit(SgAsmDwarfInterfaceType*);
1893 void visit(SgAsmDwarfInlinedSubroutine*);
1894 void visit(SgAsmDwarfInheritance*);
1895 void visit(SgAsmDwarfImportedUnit*);
1896 void visit(SgAsmDwarfImportedModule*);
1897 void visit(SgAsmDwarfImportedDeclaration*);
1898 void visit(SgAsmDwarfFunctionTemplate*);
1899 void visit(SgAsmDwarfFriend*);
1900 void visit(SgAsmDwarfFormatLabel*);
1901 void visit(SgAsmDwarfFormalParameter*);
1902 void visit(SgAsmDwarfFileType*);
1903 void visit(SgAsmDwarfEnumerator*);
1904 void visit(SgAsmDwarfEnumerationType*);
1905 void visit(SgAsmDwarfEntryPoint*);
1906 void visit(SgAsmDwarfDwarfProcedure*);
1907 void visit(SgAsmDwarfConstType*);
1908 void visit(SgAsmDwarfConstructList*);
1909 void visit(SgAsmDwarfConstant*);
1910 void visit(SgAsmDwarfCondition*);
1911 void visit(SgAsmDwarfCompilationUnitList*);
1912 void visit(SgAsmDwarfCompilationUnit*);
1913 void visit(SgAsmDwarfCommonInclusion*);
1914 void visit(SgAsmDwarfCommonBlock*);
1915 void visit(SgAsmDwarfClassType*);
1916 void visit(SgAsmDwarfClassTemplate*);
1917 void visit(SgAsmDwarfCatchBlock*);
1918 void visit(SgAsmDwarfBaseType*);
1919 void visit(SgAsmDwarfArrayType*);
1920 void visit(SgAsmDwarfAccessDeclaration*);
1921 void visit(SgAsmDwarfConstruct*);
1922 void visit(SgAsmDwarfInformation*);
1923 void visit(SgAsmDOSFileHeader*);
1924 void visit(SgAsmGenericHeader*);
1925 void visit(SgAsmDOSExtendedHeader*);
1926 void visit(SgAsmDirectRegisterExpression*);
1928 void visit(SgAsmControlFlagsExpression*);
1929 void visit(SgAsmConstantExpression*);
1930 void visit(SgAsmValueExpression*);
1931 void visit(SgAsmCommonSubExpression*);
1932 void visit(SgAsmCoffSymbolTable*);
1933 void visit(SgAsmCoffSymbolList*);
1934 void visit(SgAsmCoffSymbol*);
1935 void visit(SgAsmGenericSymbol*);
1936 void visit(SgAsmCoffStrtab*);
1937 void visit(SgAsmGenericStrtab*);
1938 void visit(SgAsmCliHeader*);
1939 void visit(SgAsmGenericSection*);
1940 void visit(SgAsmCilUint8Heap*);
1941 void visit(SgAsmCilUint32Heap*);
1942 void visit(SgAsmCilTypeSpecTable*);
1943 void visit(SgAsmCilTypeSpec*);
1944 void visit(SgAsmCilTypeRefTable*);
1945 void visit(SgAsmCilTypeRef*);
1946 void visit(SgAsmCilTypeDefTable*);
1947 void visit(SgAsmCilTypeDef*);
1948 void visit(SgAsmCilStandAloneSigTable*);
1949 void visit(SgAsmCilStandAloneSig*);
1950 void visit(SgAsmCilPropertyTable*);
1951 void visit(SgAsmCilPropertyMapTable*);
1952 void visit(SgAsmCilPropertyMap*);
1953 void visit(SgAsmCilProperty*);
1954 void visit(SgAsmCilParamTable*);
1955 void visit(SgAsmCilParam*);
1956 void visit(SgAsmCilNestedClassTable*);
1957 void visit(SgAsmCilNestedClass*);
1958 void visit(SgAsmCilModuleTable*);
1959 void visit(SgAsmCilModuleRefTable*);
1960 void visit(SgAsmCilModuleRef*);
1961 void visit(SgAsmCilModule*);
1962 void visit(SgAsmCilMethodSpecTable*);
1963 void visit(SgAsmCilMethodSpec*);
1964 void visit(SgAsmCilMethodSemanticsTable*);
1965 void visit(SgAsmCilMethodSemantics*);
1966 void visit(SgAsmCilMethodImplTable*);
1967 void visit(SgAsmCilMethodImpl*);
1968 void visit(SgAsmCilMethodDefTable*);
1969 void visit(SgAsmCilMethodDef*);
1970 void visit(SgAsmCilMethodData*);
1971 void visit(SgAsmCilMetadataRoot*);
1972 void visit(SgAsmCilMetadataHeap*);
1973 void visit(SgAsmCilMemberRefTable*);
1974 void visit(SgAsmCilMemberRef*);
1975 void visit(SgAsmCilManifestResourceTable*);
1976 void visit(SgAsmCilManifestResource*);
1977 void visit(SgAsmCilInterfaceImplTable*);
1978 void visit(SgAsmCilInterfaceImpl*);
1979 void visit(SgAsmCilInstruction*);
1980 void visit(SgAsmCilImplMapTable*);
1981 void visit(SgAsmCilImplMap*);
1982 void visit(SgAsmCilGenericParamTable*);
1983 void visit(SgAsmCilGenericParam*);
1985 void visit(SgAsmCilGenericParamConstraint*);
1986 void visit(SgAsmCilFileTable*);
1987 void visit(SgAsmCilFile*);
1988 void visit(SgAsmCilFieldTable*);
1989 void visit(SgAsmCilFieldRVATable*);
1990 void visit(SgAsmCilFieldRVA*);
1991 void visit(SgAsmCilFieldMarshalTable*);
1992 void visit(SgAsmCilFieldMarshal*);
1993 void visit(SgAsmCilFieldLayoutTable*);
1994 void visit(SgAsmCilFieldLayout*);
1995 void visit(SgAsmCilField*);
1996 void visit(SgAsmCilExportedTypeTable*);
1997 void visit(SgAsmCilExportedType*);
1998 void visit(SgAsmCilExceptionData*);
1999 void visit(SgAsmCilEventTable*);
2000 void visit(SgAsmCilEventMapTable*);
2001 void visit(SgAsmCilEventMap*);
2002 void visit(SgAsmCilEvent*);
2003 void visit(SgAsmCilDeclSecurityTable*);
2004 void visit(SgAsmCilDeclSecurity*);
2005 void visit(SgAsmCilDataStream*);
2006 void visit(SgAsmCilCustomAttributeTable*);
2007 void visit(SgAsmCilCustomAttribute*);
2008 void visit(SgAsmCilConstantTable*);
2009 void visit(SgAsmCilConstant*);
2010 void visit(SgAsmCilClassLayoutTable*);
2011 void visit(SgAsmCilClassLayout*);
2012 void visit(SgAsmCilAssemblyTable*);
2013 void visit(SgAsmCilAssemblyRefTable*);
2015 void visit(SgAsmCilAssemblyRefProcessor*);
2016 void visit(SgAsmCilAssemblyRefOSTable*);
2017 void visit(SgAsmCilAssemblyRefOS*);
2018 void visit(SgAsmCilAssemblyRef*);
2019 void visit(SgAsmCilAssemblyProcessorTable*);
2020 void visit(SgAsmCilAssemblyProcessor*);
2021 void visit(SgAsmCilAssemblyOSTable*);
2022 void visit(SgAsmCilAssemblyOS*);
2023 void visit(SgAsmCilAssembly*);
2024 void visit(SgAsmCilMetadata*);
2025 void visit(SgAsmCilNode*);
2026 void visit(SgAsmByteOrder*);
2027 void visit(SgAsmBlock*);
2028 void visit(SgAsmBinarySubtract*);
2029 void visit(SgAsmBinaryRor*);
2030 void visit(SgAsmBinaryPreupdate*);
2031 void visit(SgAsmBinaryPostupdate*);
2032 void visit(SgAsmBinaryMultiply*);
2033 void visit(SgAsmBinaryMsl*);
2034 void visit(SgAsmBinaryMod*);
2035 void visit(SgAsmBinaryLsr*);
2036 void visit(SgAsmBinaryLsl*);
2037 void visit(SgAsmBinaryDivide*);
2038 void visit(SgAsmBinaryConcat*);
2039 void visit(SgAsmBinaryAsr*);
2040 void visit(SgAsmBinaryAdd*);
2041 void visit(SgAsmBinaryExpression*);
2042 void visit(SgAsmBasicString*);
2043 void visit(SgAsmGenericString*);
2044 void visit(SgAsmExecutableFileFormat*);
2045 void visit(SgAsmInstruction*);
2046 void visit(SgAsmStatement*);
2047 void visit(SgAsmAarch32Coprocessor*);
2048 void visit(SgAsmExpression*);
2049 void visit(SgAsmNode*);
2050 void visit(SgCommonBlockObject*);
2051 void visit(SgInitializedName*);
2052 void visit(SgLambdaCapture*);
2053 void visit(SgLambdaCaptureList*);
2054 void visit(SgJavaMemberValuePair*);
2055 void visit(SgOmpOrderedClause*);
2056 void visit(SgOmpNowaitClause*);
2057 void visit(SgOmpBeginClause*);
2058 void visit(SgOmpEndClause*);
2059 void visit(SgOmpUntiedClause*);
2060 void visit(SgOmpMergeableClause*);
2061 void visit(SgOmpDefaultClause*);
2062 void visit(SgOmpAtomicClause*);
2063 void visit(SgOmpProcBindClause*);
2064 void visit(SgOmpInbranchClause*);
2065 void visit(SgOmpNotinbranchClause*);
2066 void visit(SgOmpCollapseClause*);
2067 void visit(SgOmpIfClause*);
2068 void visit(SgOmpFinalClause*);
2069 void visit(SgOmpPriorityClause*);
2070 void visit(SgOmpNumThreadsClause*);
2071 void visit(SgOmpDeviceClause*);
2072 void visit(SgOmpSafelenClause*);
2073 void visit(SgOmpSimdlenClause*);
2074 void visit(SgOmpExpressionClause*);
2075 void visit(SgOmpCopyprivateClause*);
2076 void visit(SgOmpPrivateClause*);
2077 void visit(SgOmpFirstprivateClause*);
2078 void visit(SgOmpSharedClause*);
2079 void visit(SgOmpCopyinClause*);
2080 void visit(SgOmpLastprivateClause*);
2081 void visit(SgOmpReductionClause*);
2082 void visit(SgOmpDependClause*);
2083 void visit(SgOmpMapClause*);
2084 void visit(SgOmpLinearClause*);
2085 void visit(SgOmpUniformClause*);
2086 void visit(SgOmpAlignedClause*);
2087 void visit(SgOmpVariablesClause*);
2088 void visit(SgOmpScheduleClause*);
2089 void visit(SgOmpClause*);
2090 void visit(SgRenamePair*);
2091 void visit(SgInterfaceBody*);
2092 void visit(SgHeaderFileBody*);
2093 void visit(SgAdaRangeConstraint*);
2094 void visit(SgAdaIndexConstraint*);
2095 void visit(SgAdaDigitsConstraint*);
2096 void visit(SgAdaDeltaConstraint*);
2097 void visit(SgAdaDiscriminantConstraint*);
2098 void visit(SgAdaNullConstraint*);
2099 void visit(SgAdaTypeConstraint*);
2100 void visit(SgLocatedNodeSupport*);
2101 void visit(SgToken*);
2102 void visit(SgLocatedNode*);
2103 virtual void visit(SgNode*);
2104};
2105
2106template<class R>
2108protected:
2111
2112public:
2113 virtual ~Visitor_R() {}
2114
2116 virtual R& getResult() {
2117 return _result;
2118 }
2119
2121 virtual const R& getResult() const {
2122 return _result;
2123 }
2124};
2125
2133template<class R>
2134class ContextVis_R: public Visitor_R<R> {
2135protected:
2137 ROSE_VisitorPattern* _strategy; // not owned by this context.
2138
2139public:
2140 virtual ~ContextVis_R() {
2141 _strategy = nullptr;
2142 }
2143
2148 _strategy = strategy;
2149 }
2150
2151 virtual void visitDefault(SgNode *x) {
2152 _strategy->visitDefault(x);
2153 }
2154
2155 virtual void visit(SgJovialBitVal *x) {
2156 _strategy->visit(x);
2157 }
2158
2159 virtual void visit(SgName *x) {
2160 _strategy->visit(x);
2161 }
2162
2163 virtual void visit(SgSymbolTable *x) {
2164 _strategy->visit(x);
2165 }
2166
2167 virtual void visit(SgPragma *x) {
2168 _strategy->visit(x);
2169 }
2170
2171 virtual void visit(SgModifierNodes *x) {
2172 _strategy->visit(x);
2173 }
2174
2175 virtual void visit(SgConstVolatileModifier *x) {
2176 _strategy->visit(x);
2177 }
2178
2179 virtual void visit(SgStorageModifier *x) {
2180 _strategy->visit(x);
2181 }
2182
2183 virtual void visit(SgAccessModifier *x) {
2184 _strategy->visit(x);
2185 }
2186
2187 virtual void visit(SgFunctionModifier *x) {
2188 _strategy->visit(x);
2189 }
2190
2191 virtual void visit(SgUPC_AccessModifier *x) {
2192 _strategy->visit(x);
2193 }
2194
2195 virtual void visit(SgLinkageModifier *x) {
2196 _strategy->visit(x);
2197 }
2198
2199 virtual void visit(SgSpecialFunctionModifier *x) {
2200 _strategy->visit(x);
2201 }
2202
2203 virtual void visit(SgTypeModifier *x) {
2204 _strategy->visit(x);
2205 }
2206
2207 virtual void visit(SgElaboratedTypeModifier *x) {
2208 _strategy->visit(x);
2209 }
2210
2211 virtual void visit(SgBaseClassModifier *x) {
2212 _strategy->visit(x);
2213 }
2214
2215 virtual void visit(SgDeclarationModifier *x) {
2216 _strategy->visit(x);
2217 }
2218
2219 virtual void visit(SgStructureModifier *x) {
2220 _strategy->visit(x);
2221 }
2222
2223 virtual void visit(SgOpenclAccessModeModifier *x) {
2224 _strategy->visit(x);
2225 }
2226
2227 virtual void visit(SgModifier *x) {
2228 _strategy->visit(x);
2229 }
2230
2231 virtual void visit(Sg_File_Info *x) {
2232 _strategy->visit(x);
2233 }
2234
2235 virtual void visit(SgSourceFile *x) {
2236 _strategy->visit(x);
2237 }
2238
2239 virtual void visit(SgUnknownFile *x) {
2240 _strategy->visit(x);
2241 }
2242
2243 virtual void visit(SgJvmComposite *x) {
2244 _strategy->visit(x);
2245 }
2246
2247 virtual void visit(SgBinaryComposite *x) {
2248 _strategy->visit(x);
2249 }
2250
2251 virtual void visit(SgFile *x) {
2252 _strategy->visit(x);
2253 }
2254
2255 virtual void visit(SgFileList *x) {
2256 _strategy->visit(x);
2257 }
2258
2259 virtual void visit(SgDirectory *x) {
2260 _strategy->visit(x);
2261 }
2262
2263 virtual void visit(SgDirectoryList *x) {
2264 _strategy->visit(x);
2265 }
2266
2267 virtual void visit(SgProject *x) {
2268 _strategy->visit(x);
2269 }
2270
2271 virtual void visit(SgOptions *x) {
2272 _strategy->visit(x);
2273 }
2274
2275 virtual void visit(SgUnparse_Info *x) {
2276 _strategy->visit(x);
2277 }
2278
2279 virtual void visit(SgIncludeFile *x) {
2280 _strategy->visit(x);
2281 }
2282
2283 virtual void visit(SgFuncDecl_attr *x) {
2284 _strategy->visit(x);
2285 }
2286
2287 virtual void visit(SgClassDecl_attr *x) {
2288 _strategy->visit(x);
2289 }
2290
2291 virtual void visit(SgTypedefSeq *x) {
2292 _strategy->visit(x);
2293 }
2294
2295 virtual void visit(SgFunctionParameterTypeList *x) {
2296 _strategy->visit(x);
2297 }
2298
2299 virtual void visit(SgTemplateParameter *x) {
2300 _strategy->visit(x);
2301 }
2302
2303 virtual void visit(SgTemplateArgument *x) {
2304 _strategy->visit(x);
2305 }
2306
2307 virtual void visit(SgTemplateParameterList *x) {
2308 _strategy->visit(x);
2309 }
2310
2311 virtual void visit(SgTemplateArgumentList *x) {
2312 _strategy->visit(x);
2313 }
2314
2315 virtual void visit(SgBitAttribute *x) {
2316 _strategy->visit(x);
2317 }
2318
2319 virtual void visit(SgAttribute *x) {
2320 _strategy->visit(x);
2321 }
2322
2323 virtual void visit(SgExpBaseClass *x) {
2324 _strategy->visit(x);
2325 }
2326
2327 virtual void visit(SgNonrealBaseClass *x) {
2328 _strategy->visit(x);
2329 }
2330
2331 virtual void visit(SgBaseClass *x) {
2332 _strategy->visit(x);
2333 }
2334
2335 virtual void visit(SgUndirectedGraphEdge *x) {
2336 _strategy->visit(x);
2337 }
2338
2339 virtual void visit(SgDirectedGraphEdge *x) {
2340 _strategy->visit(x);
2341 }
2342
2343 virtual void visit(SgGraphNode *x) {
2344 _strategy->visit(x);
2345 }
2346
2347 virtual void visit(SgGraphEdge *x) {
2348 _strategy->visit(x);
2349 }
2350
2351 virtual void visit(SgStringKeyedBidirectionalGraph *x) {
2352 _strategy->visit(x);
2353 }
2354
2355 virtual void visit(SgIntKeyedBidirectionalGraph *x) {
2356 _strategy->visit(x);
2357 }
2358
2359 virtual void visit(SgBidirectionalGraph *x) {
2360 _strategy->visit(x);
2361 }
2362
2363 virtual void visit(SgIncidenceDirectedGraph *x) {
2364 _strategy->visit(x);
2365 }
2366
2367 virtual void visit(SgIncidenceUndirectedGraph *x) {
2368 _strategy->visit(x);
2369 }
2370
2371 virtual void visit(SgGraph *x) {
2372 _strategy->visit(x);
2373 }
2374
2375 virtual void visit(SgGraphNodeList *x) {
2376 _strategy->visit(x);
2377 }
2378
2379 virtual void visit(SgGraphEdgeList *x) {
2380 _strategy->visit(x);
2381 }
2382
2383 virtual void visit(SgQualifiedName *x) {
2384 _strategy->visit(x);
2385 }
2386
2387 virtual void visit(SgNameGroup *x) {
2388 _strategy->visit(x);
2389 }
2390
2391 virtual void visit(SgDimensionObject *x) {
2392 _strategy->visit(x);
2393 }
2394
2395 virtual void visit(SgDataStatementGroup *x) {
2396 _strategy->visit(x);
2397 }
2398
2399 virtual void visit(SgDataStatementObject *x) {
2400 _strategy->visit(x);
2401 }
2402
2403 virtual void visit(SgDataStatementValue *x) {
2404 _strategy->visit(x);
2405 }
2406
2407 virtual void visit(SgFormatItem *x) {
2408 _strategy->visit(x);
2409 }
2410
2411 virtual void visit(SgFormatItemList *x) {
2412 _strategy->visit(x);
2413 }
2414
2415 virtual void visit(SgTypeTable *x) {
2416 _strategy->visit(x);
2417 }
2418
2419 virtual void visit(SgJavaImportStatementList *x) {
2420 _strategy->visit(x);
2421 }
2422
2423 virtual void visit(SgJavaClassDeclarationList *x) {
2424 _strategy->visit(x);
2425 }
2426
2427 virtual void visit(SgHeaderFileReport *x) {
2428 _strategy->visit(x);
2429 }
2430
2431 virtual void visit(SgSupport *x) {
2432 _strategy->visit(x);
2433 }
2434
2435 virtual void visit(SgTypeUnknown *x) {
2436 _strategy->visit(x);
2437 }
2438
2439 virtual void visit(SgTypeChar *x) {
2440 _strategy->visit(x);
2441 }
2442
2443 virtual void visit(SgTypeSignedChar *x) {
2444 _strategy->visit(x);
2445 }
2446
2447 virtual void visit(SgTypeUnsignedChar *x) {
2448 _strategy->visit(x);
2449 }
2450
2451 virtual void visit(SgTypeShort *x) {
2452 _strategy->visit(x);
2453 }
2454
2455 virtual void visit(SgTypeSignedShort *x) {
2456 _strategy->visit(x);
2457 }
2458
2459 virtual void visit(SgTypeUnsignedShort *x) {
2460 _strategy->visit(x);
2461 }
2462
2463 virtual void visit(SgTypeInt *x) {
2464 _strategy->visit(x);
2465 }
2466
2467 virtual void visit(SgTypeSignedInt *x) {
2468 _strategy->visit(x);
2469 }
2470
2471 virtual void visit(SgTypeUnsignedInt *x) {
2472 _strategy->visit(x);
2473 }
2474
2475 virtual void visit(SgTypeLong *x) {
2476 _strategy->visit(x);
2477 }
2478
2479 virtual void visit(SgTypeSignedLong *x) {
2480 _strategy->visit(x);
2481 }
2482
2483 virtual void visit(SgTypeUnsignedLong *x) {
2484 _strategy->visit(x);
2485 }
2486
2487 virtual void visit(SgTypeVoid *x) {
2488 _strategy->visit(x);
2489 }
2490
2491 virtual void visit(SgTypeGlobalVoid *x) {
2492 _strategy->visit(x);
2493 }
2494
2495 virtual void visit(SgTypeWchar *x) {
2496 _strategy->visit(x);
2497 }
2498
2499 virtual void visit(SgTypeFloat *x) {
2500 _strategy->visit(x);
2501 }
2502
2503 virtual void visit(SgTypeDouble *x) {
2504 _strategy->visit(x);
2505 }
2506
2507 virtual void visit(SgTypeLongLong *x) {
2508 _strategy->visit(x);
2509 }
2510
2511 virtual void visit(SgTypeSignedLongLong *x) {
2512 _strategy->visit(x);
2513 }
2514
2515 virtual void visit(SgTypeUnsignedLongLong *x) {
2516 _strategy->visit(x);
2517 }
2518
2519 virtual void visit(SgTypeLongDouble *x) {
2520 _strategy->visit(x);
2521 }
2522
2523 virtual void visit(SgTypeFloat80 *x) {
2524 _strategy->visit(x);
2525 }
2526
2527 virtual void visit(SgTypeFloat128 *x) {
2528 _strategy->visit(x);
2529 }
2530
2531 virtual void visit(SgTypeString *x) {
2532 _strategy->visit(x);
2533 }
2534
2535 virtual void visit(SgTypeBool *x) {
2536 _strategy->visit(x);
2537 }
2538
2539 virtual void visit(SgTypeFixed *x) {
2540 _strategy->visit(x);
2541 }
2542
2543 virtual void visit(SgTypeMatrix *x) {
2544 _strategy->visit(x);
2545 }
2546
2547 virtual void visit(SgTypeTuple *x) {
2548 _strategy->visit(x);
2549 }
2550
2551 virtual void visit(SgTypeNullptr *x) {
2552 _strategy->visit(x);
2553 }
2554
2555 virtual void visit(SgTypeComplex *x) {
2556 _strategy->visit(x);
2557 }
2558
2559 virtual void visit(SgTypeImaginary *x) {
2560 _strategy->visit(x);
2561 }
2562
2563 virtual void visit(SgTypeDefault *x) {
2564 _strategy->visit(x);
2565 }
2566
2567 virtual void visit(SgPointerMemberType *x) {
2568 _strategy->visit(x);
2569 }
2570
2571 virtual void visit(SgReferenceType *x) {
2572 _strategy->visit(x);
2573 }
2574
2575 virtual void visit(SgRvalueReferenceType *x) {
2576 _strategy->visit(x);
2577 }
2578
2579 virtual void visit(SgDeclType *x) {
2580 _strategy->visit(x);
2581 }
2582
2583 virtual void visit(SgTypeOfType *x) {
2584 _strategy->visit(x);
2585 }
2586
2587 virtual void visit(SgTypeCAFTeam *x) {
2588 _strategy->visit(x);
2589 }
2590
2591 virtual void visit(SgTypeUnsigned128bitInteger *x) {
2592 _strategy->visit(x);
2593 }
2594
2595 virtual void visit(SgTypeSigned128bitInteger *x) {
2596 _strategy->visit(x);
2597 }
2598
2599 virtual void visit(SgTypeLabel *x) {
2600 _strategy->visit(x);
2601 }
2602
2603 virtual void visit(SgJavaParameterizedType *x) {
2604 _strategy->visit(x);
2605 }
2606
2607 virtual void visit(SgJavaQualifiedType *x) {
2608 _strategy->visit(x);
2609 }
2610
2611 virtual void visit(SgJavaWildcardType *x) {
2612 _strategy->visit(x);
2613 }
2614
2615 virtual void visit(SgJavaUnionType *x) {
2616 _strategy->visit(x);
2617 }
2618
2619 virtual void visit(SgJavaParameterType *x) {
2620 _strategy->visit(x);
2621 }
2622
2623 virtual void visit(SgJovialTableType *x) {
2624 _strategy->visit(x);
2625 }
2626
2627 virtual void visit(SgTemplateType *x) {
2628 _strategy->visit(x);
2629 }
2630
2631 virtual void visit(SgEnumType *x) {
2632 _strategy->visit(x);
2633 }
2634
2635 virtual void visit(SgTypedefType *x) {
2636 _strategy->visit(x);
2637 }
2638
2639 virtual void visit(SgNonrealType *x) {
2640 _strategy->visit(x);
2641 }
2642
2643 virtual void visit(SgAutoType *x) {
2644 _strategy->visit(x);
2645 }
2646
2647 virtual void visit(SgModifierType *x) {
2648 _strategy->visit(x);
2649 }
2650
2651 virtual void visit(SgPartialFunctionModifierType *x) {
2652 _strategy->visit(x);
2653 }
2654
2655 virtual void visit(SgArrayType *x) {
2656 _strategy->visit(x);
2657 }
2658
2659 virtual void visit(SgTypeEllipse *x) {
2660 _strategy->visit(x);
2661 }
2662
2663 virtual void visit(SgAdaAccessType *x) {
2664 _strategy->visit(x);
2665 }
2666
2667 virtual void visit(SgAdaSubtype *x) {
2668 _strategy->visit(x);
2669 }
2670
2671 virtual void visit(SgAdaDerivedType *x) {
2672 _strategy->visit(x);
2673 }
2674
2675 virtual void visit(SgAdaModularType *x) {
2676 _strategy->visit(x);
2677 }
2678
2679 virtual void visit(SgAdaDiscriminatedType *x) {
2680 _strategy->visit(x);
2681 }
2682
2683 virtual void visit(SgAdaFormalType *x) {
2684 _strategy->visit(x);
2685 }
2686
2687 virtual void visit(SgAdaDiscreteType *x) {
2688 _strategy->visit(x);
2689 }
2690
2691 virtual void visit(SgAdaSubroutineType *x) {
2692 _strategy->visit(x);
2693 }
2694
2695 virtual void visit(SgRangeType *x) {
2696 _strategy->visit(x);
2697 }
2698
2699 virtual void visit(SgJovialBitType *x) {
2700 _strategy->visit(x);
2701 }
2702
2703 virtual void visit(SgTypeCrayPointer *x) {
2704 _strategy->visit(x);
2705 }
2706
2707 virtual void visit(SgPartialFunctionType *x) {
2708 _strategy->visit(x);
2709 }
2710
2711 virtual void visit(SgMemberFunctionType *x) {
2712 _strategy->visit(x);
2713 }
2714
2715 virtual void visit(SgFunctionType *x) {
2716 _strategy->visit(x);
2717 }
2718
2719 virtual void visit(SgPointerType *x) {
2720 _strategy->visit(x);
2721 }
2722
2723 virtual void visit(SgAdaTaskType *x) {
2724 _strategy->visit(x);
2725 }
2726
2727 virtual void visit(SgAdaProtectedType *x) {
2728 _strategy->visit(x);
2729 }
2730
2731 virtual void visit(SgClassType *x) {
2732 _strategy->visit(x);
2733 }
2734
2735 virtual void visit(SgNamedType *x) {
2736 _strategy->visit(x);
2737 }
2738
2739 virtual void visit(SgQualifiedNameType *x) {
2740 _strategy->visit(x);
2741 }
2742
2743 virtual void visit(SgTypeChar16 *x) {
2744 _strategy->visit(x);
2745 }
2746
2747 virtual void visit(SgTypeChar32 *x) {
2748 _strategy->visit(x);
2749 }
2750
2751 virtual void visit(SgType *x) {
2752 _strategy->visit(x);
2753 }
2754
2755 virtual void visit(SgForStatement *x) {
2756 _strategy->visit(x);
2757 }
2758
2759 virtual void visit(SgForInitStatement *x) {
2760 _strategy->visit(x);
2761 }
2762
2763 virtual void visit(SgRangeBasedForStatement *x) {
2764 _strategy->visit(x);
2765 }
2766
2767 virtual void visit(SgCatchStatementSeq *x) {
2768 _strategy->visit(x);
2769 }
2770
2771 virtual void visit(SgFunctionParameterList *x) {
2772 _strategy->visit(x);
2773 }
2774
2775 virtual void visit(SgAdaParameterList *x) {
2776 _strategy->visit(x);
2777 }
2778
2779 virtual void visit(SgCtorInitializerList *x) {
2780 _strategy->visit(x);
2781 }
2782
2783 virtual void visit(SgBasicBlock *x) {
2784 _strategy->visit(x);
2785 }
2786
2787 virtual void visit(SgGlobal *x) {
2788 _strategy->visit(x);
2789 }
2790
2791 virtual void visit(SgIfStmt *x) {
2792 _strategy->visit(x);
2793 }
2794
2795 virtual void visit(SgWhileStmt *x) {
2796 _strategy->visit(x);
2797 }
2798
2799 virtual void visit(SgDoWhileStmt *x) {
2800 _strategy->visit(x);
2801 }
2802
2803 virtual void visit(SgSwitchStatement *x) {
2804 _strategy->visit(x);
2805 }
2806
2807 virtual void visit(SgCatchOptionStmt *x) {
2808 _strategy->visit(x);
2809 }
2810
2811 virtual void visit(SgFunctionParameterScope *x) {
2812 _strategy->visit(x);
2813 }
2814
2815 virtual void visit(SgDeclarationScope *x) {
2816 _strategy->visit(x);
2817 }
2818
2819 virtual void visit(SgVariableDefinition *x) {
2820 _strategy->visit(x);
2821 }
2822
2823 virtual void visit(SgStmtDeclarationStatement *x) {
2824 _strategy->visit(x);
2825 }
2826
2827 virtual void visit(SgEnumDeclaration *x) {
2828 _strategy->visit(x);
2829 }
2830
2831 virtual void visit(SgAsmStmt *x) {
2832 _strategy->visit(x);
2833 }
2834
2835 virtual void visit(SgFunctionTypeTable *x) {
2836 _strategy->visit(x);
2837 }
2838
2839 virtual void visit(SgExprStatement *x) {
2840 _strategy->visit(x);
2841 }
2842
2843 virtual void visit(SgLabelStatement *x) {
2844 _strategy->visit(x);
2845 }
2846
2847 virtual void visit(SgCaseOptionStmt *x) {
2848 _strategy->visit(x);
2849 }
2850
2851 virtual void visit(SgTryStmt *x) {
2852 _strategy->visit(x);
2853 }
2854
2855 virtual void visit(SgDefaultOptionStmt *x) {
2856 _strategy->visit(x);
2857 }
2858
2859 virtual void visit(SgBreakStmt *x) {
2860 _strategy->visit(x);
2861 }
2862
2863 virtual void visit(SgContinueStmt *x) {
2864 _strategy->visit(x);
2865 }
2866
2867 virtual void visit(SgReturnStmt *x) {
2868 _strategy->visit(x);
2869 }
2870
2871 virtual void visit(SgGotoStatement *x) {
2872 _strategy->visit(x);
2873 }
2874
2875 virtual void visit(SgAdaExitStmt *x) {
2876 _strategy->visit(x);
2877 }
2878
2879 virtual void visit(SgAdaLoopStmt *x) {
2880 _strategy->visit(x);
2881 }
2882
2883 virtual void visit(SgAdaDelayStmt *x) {
2884 _strategy->visit(x);
2885 }
2886
2887 virtual void visit(SgAdaSelectStmt *x) {
2888 _strategy->visit(x);
2889 }
2890
2891 virtual void visit(SgAdaSelectAlternativeStmt *x) {
2892 _strategy->visit(x);
2893 }
2894
2895 virtual void visit(SgAdaTerminateStmt *x) {
2896 _strategy->visit(x);
2897 }
2898
2899 virtual void visit(SgAdaUnscopedBlock *x) {
2900 _strategy->visit(x);
2901 }
2902
2903 virtual void visit(SgAdaVariantWhenStmt *x) {
2904 _strategy->visit(x);
2905 }
2906
2907 virtual void visit(SgSpawnStmt *x) {
2908 _strategy->visit(x);
2909 }
2910
2911 virtual void visit(SgFortranContinueStmt *x) {
2912 _strategy->visit(x);
2913 }
2914
2915 virtual void visit(SgTemplateTypedefDeclaration *x) {
2916 _strategy->visit(x);
2917 }
2918
2919 virtual void visit(SgTemplateInstantiationTypedefDeclaration *x) {
2920 _strategy->visit(x);
2921 }
2922
2923 virtual void visit(SgTypedefDeclaration *x) {
2924 _strategy->visit(x);
2925 }
2926
2927 virtual void visit(SgNullStatement *x) {
2928 _strategy->visit(x);
2929 }
2930
2931 virtual void visit(SgVariantStatement *x) {
2932 _strategy->visit(x);
2933 }
2934
2935 virtual void visit(SgPragmaDeclaration *x) {
2936 _strategy->visit(x);
2937 }
2938
2939 virtual void visit(SgTemplateClassDeclaration *x) {
2940 _strategy->visit(x);
2941 }
2942
2943 virtual void visit(SgTemplateMemberFunctionDeclaration *x) {
2944 _strategy->visit(x);
2945 }
2946
2947 virtual void visit(SgTemplateFunctionDeclaration *x) {
2948 _strategy->visit(x);
2949 }
2950
2951 virtual void visit(SgTemplateVariableDeclaration *x) {
2952 _strategy->visit(x);
2953 }
2954
2955 virtual void visit(SgTemplateDeclaration *x) {
2956 _strategy->visit(x);
2957 }
2958
2959 virtual void visit(SgVariableDeclaration *x) {
2960 _strategy->visit(x);
2961 }
2962
2963 virtual void visit(SgTemplateInstantiationDecl *x) {
2964 _strategy->visit(x);
2965 }
2966
2967 virtual void visit(SgTemplateInstantiationDefn *x) {
2968 _strategy->visit(x);
2969 }
2970
2971 virtual void visit(SgTemplateInstantiationFunctionDecl *x) {
2972 _strategy->visit(x);
2973 }
2974
2975 virtual void visit(SgTemplateInstantiationMemberFunctionDecl *x) {
2976 _strategy->visit(x);
2977 }
2978
2979 virtual void visit(SgNonrealDecl *x) {
2980 _strategy->visit(x);
2981 }
2982
2983 virtual void visit(SgWithStatement *x) {
2984 _strategy->visit(x);
2985 }
2986
2987 virtual void visit(SgPythonGlobalStmt *x) {
2988 _strategy->visit(x);
2989 }
2990
2991 virtual void visit(SgPythonPrintStmt *x) {
2992 _strategy->visit(x);
2993 }
2994
2995 virtual void visit(SgPassStatement *x) {
2996 _strategy->visit(x);
2997 }
2998
2999 virtual void visit(SgAssertStmt *x) {
3000 _strategy->visit(x);
3001 }
3002
3003 virtual void visit(SgExecStatement *x) {
3004 _strategy->visit(x);
3005 }
3006
3007 virtual void visit(SgProgramHeaderStatement *x) {
3008 _strategy->visit(x);
3009 }
3010
3011 virtual void visit(SgProcedureHeaderStatement *x) {
3012 _strategy->visit(x);
3013 }
3014
3015 virtual void visit(SgEntryStatement *x) {
3016 _strategy->visit(x);
3017 }
3018
3019 virtual void visit(SgFortranNonblockedDo *x) {
3020 _strategy->visit(x);
3021 }
3022
3023 virtual void visit(SgInterfaceStatement *x) {
3024 _strategy->visit(x);
3025 }
3026
3027 virtual void visit(SgParameterStatement *x) {
3028 _strategy->visit(x);
3029 }
3030
3031 virtual void visit(SgCommonBlock *x) {
3032 _strategy->visit(x);
3033 }
3034
3035 virtual void visit(SgModuleStatement *x) {
3036 _strategy->visit(x);
3037 }
3038
3039 virtual void visit(SgUseStatement *x) {
3040 _strategy->visit(x);
3041 }
3042
3043 virtual void visit(SgProcessControlStatement *x) {
3044 _strategy->visit(x);
3045 }
3046
3047 virtual void visit(SgPrintStatement *x) {
3048 _strategy->visit(x);
3049 }
3050
3051 virtual void visit(SgReadStatement *x) {
3052 _strategy->visit(x);
3053 }
3054
3055 virtual void visit(SgWriteStatement *x) {
3056 _strategy->visit(x);
3057 }
3058
3059 virtual void visit(SgOpenStatement *x) {
3060 _strategy->visit(x);
3061 }
3062
3063 virtual void visit(SgCloseStatement *x) {
3064 _strategy->visit(x);
3065 }
3066
3067 virtual void visit(SgInquireStatement *x) {
3068 _strategy->visit(x);
3069 }
3070
3071 virtual void visit(SgFlushStatement *x) {
3072 _strategy->visit(x);
3073 }
3074
3075 virtual void visit(SgBackspaceStatement *x) {
3076 _strategy->visit(x);
3077 }
3078
3079 virtual void visit(SgRewindStatement *x) {
3080 _strategy->visit(x);
3081 }
3082
3083 virtual void visit(SgEndfileStatement *x) {
3084 _strategy->visit(x);
3085 }
3086
3087 virtual void visit(SgWaitStatement *x) {
3088 _strategy->visit(x);
3089 }
3090
3091 virtual void visit(SgCAFWithTeamStatement *x) {
3092 _strategy->visit(x);
3093 }
3094
3095 virtual void visit(SgFormatStatement *x) {
3096 _strategy->visit(x);
3097 }
3098
3099 virtual void visit(SgFortranDo *x) {
3100 _strategy->visit(x);
3101 }
3102
3103 virtual void visit(SgForAllStatement *x) {
3104 _strategy->visit(x);
3105 }
3106
3107 virtual void visit(SgIOStatement *x) {
3108 _strategy->visit(x);
3109 }
3110
3111 virtual void visit(SgSyncAllStatement *x) {
3112 _strategy->visit(x);
3113 }
3114
3115 virtual void visit(SgSyncImagesStatement *x) {
3116 _strategy->visit(x);
3117 }
3118
3119 virtual void visit(SgSyncMemoryStatement *x) {
3120 _strategy->visit(x);
3121 }
3122
3123 virtual void visit(SgSyncTeamStatement *x) {
3124 _strategy->visit(x);
3125 }
3126
3127 virtual void visit(SgLockStatement *x) {
3128 _strategy->visit(x);
3129 }
3130
3131 virtual void visit(SgUnlockStatement *x) {
3132 _strategy->visit(x);
3133 }
3134
3135 virtual void visit(SgImageControlStatement *x) {
3136 _strategy->visit(x);
3137 }
3138
3139 virtual void visit(SgJovialCompoolStatement *x) {
3140 _strategy->visit(x);
3141 }
3142
3143 virtual void visit(SgJovialDefineDeclaration *x) {
3144 _strategy->visit(x);
3145 }
3146
3147 virtual void visit(SgJovialDirectiveStatement *x) {
3148 _strategy->visit(x);
3149 }
3150
3151 virtual void visit(SgJovialLabelDeclaration *x) {
3152 _strategy->visit(x);
3153 }
3154
3155 virtual void visit(SgJovialOverlayDeclaration *x) {
3156 _strategy->visit(x);
3157 }
3158
3159 virtual void visit(SgJovialForThenStatement *x) {
3160 _strategy->visit(x);
3161 }
3162
3163 virtual void visit(SgMatlabForStatement *x) {
3164 _strategy->visit(x);
3165 }
3166
3167 virtual void visit(SgUpcNotifyStatement *x) {
3168 _strategy->visit(x);
3169 }
3170
3171 virtual void visit(SgUpcWaitStatement *x) {
3172 _strategy->visit(x);
3173 }
3174
3175 virtual void visit(SgUpcBarrierStatement *x) {
3176 _strategy->visit(x);
3177 }
3178
3179 virtual void visit(SgUpcFenceStatement *x) {
3180 _strategy->visit(x);
3181 }
3182
3183 virtual void visit(SgUpcForAllStatement *x) {
3184 _strategy->visit(x);
3185 }
3186
3187 virtual void visit(SgOmpParallelStatement *x) {
3188 _strategy->visit(x);
3189 }
3190
3191 virtual void visit(SgOmpSingleStatement *x) {
3192 _strategy->visit(x);
3193 }
3194
3195 virtual void visit(SgOmpTaskStatement *x) {
3196 _strategy->visit(x);
3197 }
3198
3199 virtual void visit(SgOmpForStatement *x) {
3200 _strategy->visit(x);
3201 }
3202
3203 virtual void visit(SgOmpForSimdStatement *x) {
3204 _strategy->visit(x);
3205 }
3206
3207 virtual void visit(SgOmpDoStatement *x) {
3208 _strategy->visit(x);
3209 }
3210
3211 virtual void visit(SgOmpSectionsStatement *x) {
3212 _strategy->visit(x);
3213 }
3214
3215 virtual void visit(SgOmpAtomicStatement *x) {
3216 _strategy->visit(x);
3217 }
3218
3219 virtual void visit(SgOmpTargetStatement *x) {
3220 _strategy->visit(x);
3221 }
3222
3223 virtual void visit(SgOmpTargetDataStatement *x) {
3224 _strategy->visit(x);
3225 }
3226
3227 virtual void visit(SgOmpSimdStatement *x) {
3228 _strategy->visit(x);
3229 }
3230
3231 virtual void visit(SgOmpClauseBodyStatement *x) {
3232 _strategy->visit(x);
3233 }
3234
3235 virtual void visit(SgOmpMasterStatement *x) {
3236 _strategy->visit(x);
3237 }
3238
3239 virtual void visit(SgOmpSectionStatement *x) {
3240 _strategy->visit(x);
3241 }
3242
3243 virtual void visit(SgOmpOrderedStatement *x) {
3244 _strategy->visit(x);
3245 }
3246
3247 virtual void visit(SgOmpWorkshareStatement *x) {
3248 _strategy->visit(x);
3249 }
3250
3251 virtual void visit(SgOmpCriticalStatement *x) {
3252 _strategy->visit(x);
3253 }
3254
3255 virtual void visit(SgOmpBodyStatement *x) {
3256 _strategy->visit(x);
3257 }
3258
3259 virtual void visit(SgJavaThrowStatement *x) {
3260 _strategy->visit(x);
3261 }
3262
3263 virtual void visit(SgJavaForEachStatement *x) {
3264 _strategy->visit(x);
3265 }
3266
3267 virtual void visit(SgJavaSynchronizedStatement *x) {
3268 _strategy->visit(x);
3269 }
3270
3271 virtual void visit(SgJavaLabelStatement *x) {
3272 _strategy->visit(x);
3273 }
3274
3275 virtual void visit(SgJavaImportStatement *x) {
3276 _strategy->visit(x);
3277 }
3278
3279 virtual void visit(SgJavaPackageDeclaration *x) {
3280 _strategy->visit(x);
3281 }
3282
3283 virtual void visit(SgJavaPackageStatement *x) {
3284 _strategy->visit(x);
3285 }
3286
3287 virtual void visit(SgAsyncStmt *x) {
3288 _strategy->visit(x);
3289 }
3290
3291 virtual void visit(SgFinishStmt *x) {
3292 _strategy->visit(x);
3293 }
3294
3295 virtual void visit(SgAtStmt *x) {
3296 _strategy->visit(x);
3297 }
3298
3299 virtual void visit(SgAtomicStmt *x) {
3300 _strategy->visit(x);
3301 }
3302
3303 virtual void visit(SgWhenStmt *x) {
3304 _strategy->visit(x);
3305 }
3306
3307 virtual void visit(SgBlockDataStatement *x) {
3308 _strategy->visit(x);
3309 }
3310
3311 virtual void visit(SgImplicitStatement *x) {
3312 _strategy->visit(x);
3313 }
3314
3315 virtual void visit(SgStatementFunctionStatement *x) {
3316 _strategy->visit(x);
3317 }
3318
3319 virtual void visit(SgWhereStatement *x) {
3320 _strategy->visit(x);
3321 }
3322
3323 virtual void visit(SgNullifyStatement *x) {
3324 _strategy->visit(x);
3325 }
3326
3327 virtual void visit(SgEquivalenceStatement *x) {
3328 _strategy->visit(x);
3329 }
3330
3331 virtual void visit(SgDerivedTypeStatement *x) {
3332 _strategy->visit(x);
3333 }
3334
3335 virtual void visit(SgJovialTableStatement *x) {
3336 _strategy->visit(x);
3337 }
3338
3339 virtual void visit(SgAttributeSpecificationStatement *x) {
3340 _strategy->visit(x);
3341 }
3342
3343 virtual void visit(SgAllocateStatement *x) {
3344 _strategy->visit(x);
3345 }
3346
3347 virtual void visit(SgDeallocateStatement *x) {
3348 _strategy->visit(x);
3349 }
3350
3351 virtual void visit(SgContainsStatement *x) {
3352 _strategy->visit(x);
3353 }
3354
3355 virtual void visit(SgSequenceStatement *x) {
3356 _strategy->visit(x);
3357 }
3358
3359 virtual void visit(SgElseWhereStatement *x) {
3360 _strategy->visit(x);
3361 }
3362
3363 virtual void visit(SgArithmeticIfStatement *x) {
3364 _strategy->visit(x);
3365 }
3366
3367 virtual void visit(SgAssignStatement *x) {
3368 _strategy->visit(x);
3369 }
3370
3371 virtual void visit(SgComputedGotoStatement *x) {
3372 _strategy->visit(x);
3373 }
3374
3375 virtual void visit(SgAssignedGotoStatement *x) {
3376 _strategy->visit(x);
3377 }
3378
3379 virtual void visit(SgNamelistStatement *x) {
3380 _strategy->visit(x);
3381 }
3382
3383 virtual void visit(SgImportStatement *x) {
3384 _strategy->visit(x);
3385 }
3386
3387 virtual void visit(SgAssociateStatement *x) {
3388 _strategy->visit(x);
3389 }
3390
3391 virtual void visit(SgFortranIncludeLine *x) {
3392 _strategy->visit(x);
3393 }
3394
3395 virtual void visit(SgNamespaceDeclarationStatement *x) {
3396 _strategy->visit(x);
3397 }
3398
3399 virtual void visit(SgNamespaceAliasDeclarationStatement *x) {
3400 _strategy->visit(x);
3401 }
3402
3403 virtual void visit(SgNamespaceDefinitionStatement *x) {
3404 _strategy->visit(x);
3405 }
3406
3407 virtual void visit(SgUsingDeclarationStatement *x) {
3408 _strategy->visit(x);
3409 }
3410
3411 virtual void visit(SgUsingDirectiveStatement *x) {
3412 _strategy->visit(x);
3413 }
3414
3415 virtual void visit(SgTemplateInstantiationDirectiveStatement *x) {
3416 _strategy->visit(x);
3417 }
3418
3419 virtual void visit(SgStaticAssertionDeclaration *x) {
3420 _strategy->visit(x);
3421 }
3422
3423 virtual void visit(SgTemplateClassDefinition *x) {
3424 _strategy->visit(x);
3425 }
3426
3427 virtual void visit(SgTemplateFunctionDefinition *x) {
3428 _strategy->visit(x);
3429 }
3430
3431 virtual void visit(SgClassDeclaration *x) {
3432 _strategy->visit(x);
3433 }
3434
3435 virtual void visit(SgClassDefinition *x) {
3436 _strategy->visit(x);
3437 }
3438
3439 virtual void visit(SgFunctionDefinition *x) {
3440 _strategy->visit(x);
3441 }
3442
3443 virtual void visit(SgAdaAcceptStmt *x) {
3444 _strategy->visit(x);
3445 }
3446
3447 virtual void visit(SgAdaPackageBody *x) {
3448 _strategy->visit(x);
3449 }
3450
3451 virtual void visit(SgAdaPackageSpec *x) {
3452 _strategy->visit(x);
3453 }
3454
3455 virtual void visit(SgAdaTaskBody *x) {
3456 _strategy->visit(x);
3457 }
3458
3459 virtual void visit(SgAdaTaskSpec *x) {
3460 _strategy->visit(x);
3461 }
3462
3463 virtual void visit(SgAdaProtectedBody *x) {
3464 _strategy->visit(x);
3465 }
3466
3467 virtual void visit(SgAdaProtectedSpec *x) {
3468 _strategy->visit(x);
3469 }
3470
3471 virtual void visit(SgAdaGenericDefn *x) {
3472 _strategy->visit(x);
3473 }
3474
3475 virtual void visit(SgScopeStatement *x) {
3476 _strategy->visit(x);
3477 }
3478
3479 virtual void visit(SgMemberFunctionDeclaration *x) {
3480 _strategy->visit(x);
3481 }
3482
3483 virtual void visit(SgAdaEntryDecl *x) {
3484 _strategy->visit(x);
3485 }
3486
3487 virtual void visit(SgAdaFunctionRenamingDecl *x) {
3488 _strategy->visit(x);
3489 }
3490
3491 virtual void visit(SgFunctionDeclaration *x) {
3492 _strategy->visit(x);
3493 }
3494
3495 virtual void visit(SgIncludeDirectiveStatement *x) {
3496 _strategy->visit(x);
3497 }
3498
3499 virtual void visit(SgDefineDirectiveStatement *x) {
3500 _strategy->visit(x);
3501 }
3502
3503 virtual void visit(SgUndefDirectiveStatement *x) {
3504 _strategy->visit(x);
3505 }
3506
3507 virtual void visit(SgIfdefDirectiveStatement *x) {
3508 _strategy->visit(x);
3509 }
3510
3511 virtual void visit(SgIfndefDirectiveStatement *x) {
3512 _strategy->visit(x);
3513 }
3514
3515 virtual void visit(SgIfDirectiveStatement *x) {
3516 _strategy->visit(x);
3517 }
3518
3519 virtual void visit(SgDeadIfDirectiveStatement *x) {
3520 _strategy->visit(x);
3521 }
3522
3523 virtual void visit(SgElseDirectiveStatement *x) {
3524 _strategy->visit(x);
3525 }
3526
3527 virtual void visit(SgElseifDirectiveStatement *x) {
3528 _strategy->visit(x);
3529 }
3530
3531 virtual void visit(SgEndifDirectiveStatement *x) {
3532 _strategy->visit(x);
3533 }
3534
3535 virtual void visit(SgLineDirectiveStatement *x) {
3536 _strategy->visit(x);
3537 }
3538
3539 virtual void visit(SgWarningDirectiveStatement *x) {
3540 _strategy->visit(x);
3541 }
3542
3543 virtual void visit(SgErrorDirectiveStatement *x) {
3544 _strategy->visit(x);
3545 }
3546
3547 virtual void visit(SgEmptyDirectiveStatement *x) {
3548 _strategy->visit(x);
3549 }
3550
3551 virtual void visit(SgIncludeNextDirectiveStatement *x) {
3552 _strategy->visit(x);
3553 }
3554
3555 virtual void visit(SgIdentDirectiveStatement *x) {
3556 _strategy->visit(x);
3557 }
3558
3559 virtual void visit(SgLinemarkerDirectiveStatement *x) {
3560 _strategy->visit(x);
3561 }
3562
3563 virtual void visit(SgC_PreprocessorDirectiveStatement *x) {
3564 _strategy->visit(x);
3565 }
3566
3567 virtual void visit(SgClinkageStartStatement *x) {
3568 _strategy->visit(x);
3569 }
3570
3571 virtual void visit(SgClinkageEndStatement *x) {
3572 _strategy->visit(x);
3573 }
3574
3575 virtual void visit(SgClinkageDeclarationStatement *x) {
3576 _strategy->visit(x);
3577 }
3578
3579 virtual void visit(SgOmpFlushStatement *x) {
3580 _strategy->visit(x);
3581 }
3582
3583 virtual void visit(SgOmpDeclareSimdStatement *x) {
3584 _strategy->visit(x);
3585 }
3586
3587 virtual void visit(SgOmpBarrierStatement *x) {
3588 _strategy->visit(x);
3589 }
3590
3591 virtual void visit(SgOmpTaskwaitStatement *x) {
3592 _strategy->visit(x);
3593 }
3594
3595 virtual void visit(SgOmpThreadprivateStatement *x) {
3596 _strategy->visit(x);
3597 }
3598
3599 virtual void visit(SgMicrosoftAttributeDeclaration *x) {
3600 _strategy->visit(x);
3601 }
3602
3603 virtual void visit(SgEmptyDeclaration *x) {
3604 _strategy->visit(x);
3605 }
3606
3607 virtual void visit(SgAdaPackageSpecDecl *x) {
3608 _strategy->visit(x);
3609 }
3610
3611 virtual void visit(SgAdaPackageBodyDecl *x) {
3612 _strategy->visit(x);
3613 }
3614
3615 virtual void visit(SgAdaTaskSpecDecl *x) {
3616 _strategy->visit(x);
3617 }
3618
3619 virtual void visit(SgAdaTaskTypeDecl *x) {
3620 _strategy->visit(x);
3621 }
3622
3623 virtual void visit(SgAdaTaskBodyDecl *x) {
3624 _strategy->visit(x);
3625 }
3626
3627 virtual void visit(SgAdaProtectedSpecDecl *x) {
3628 _strategy->visit(x);
3629 }
3630
3631 virtual void visit(SgAdaProtectedTypeDecl *x) {
3632 _strategy->visit(x);
3633 }
3634
3635 virtual void visit(SgAdaProtectedBodyDecl *x) {
3636 _strategy->visit(x);
3637 }
3638
3639 virtual void visit(SgAdaRepresentationClause *x) {
3640 _strategy->visit(x);
3641 }
3642
3643 virtual void visit(SgAdaEnumRepresentationClause *x) {
3644 _strategy->visit(x);
3645 }
3646
3647 virtual void visit(SgAdaAttributeClause *x) {
3648 _strategy->visit(x);
3649 }
3650
3651 virtual void visit(SgAdaComponentClause *x) {
3652 _strategy->visit(x);
3653 }
3654
3655 virtual void visit(SgAdaRenamingDecl *x) {
3656 _strategy->visit(x);
3657 }
3658
3659 virtual void visit(SgAdaGenericDecl *x) {
3660 _strategy->visit(x);
3661 }
3662
3663 virtual void visit(SgAdaGenericInstanceDecl *x) {
3664 _strategy->visit(x);
3665 }
3666
3667 virtual void visit(SgAdaFormalTypeDecl *x) {
3668 _strategy->visit(x);
3669 }
3670
3671 virtual void visit(SgAdaFormalPackageDecl *x) {
3672 _strategy->visit(x);
3673 }
3674
3675 virtual void visit(SgAdaDiscriminatedTypeDecl *x) {
3676 _strategy->visit(x);
3677 }
3678
3679 virtual void visit(SgAdaVariantDecl *x) {
3680 _strategy->visit(x);
3681 }
3682
3683 virtual void visit(SgDeclarationStatement *x) {
3684 _strategy->visit(x);
3685 }
3686
3687 virtual void visit(SgStatement *x) {
3688 _strategy->visit(x);
3689 }
3690
3691 virtual void visit(SgAbsOp *x) {
3692 _strategy->visit(x);
3693 }
3694
3695 virtual void visit(SgActualArgumentExpression *x) {
3696 _strategy->visit(x);
3697 }
3698
3699 virtual void visit(SgAdaAncestorInitializer *x) {
3700 _strategy->visit(x);
3701 }
3702
3703 virtual void visit(SgAdaAttributeExp *x) {
3704 _strategy->visit(x);
3705 }
3706
3707 virtual void visit(SgAdaFloatVal *x) {
3708 _strategy->visit(x);
3709 }
3710
3711 virtual void visit(SgAdaOthersExp *x) {
3712 _strategy->visit(x);
3713 }
3714
3715 virtual void visit(SgAdaProtectedRefExp *x) {
3716 _strategy->visit(x);
3717 }
3718
3719 virtual void visit(SgAdaRenamingRefExp *x) {
3720 _strategy->visit(x);
3721 }
3722
3723 virtual void visit(SgAdaTaskRefExp *x) {
3724 _strategy->visit(x);
3725 }
3726
3727 virtual void visit(SgAdaUnitRefExp *x) {
3728 _strategy->visit(x);
3729 }
3730
3731 virtual void visit(SgAddOp *x) {
3732 _strategy->visit(x);
3733 }
3734
3735 virtual void visit(SgAddressOfOp *x) {
3736 _strategy->visit(x);
3737 }
3738
3739 virtual void visit(SgAggregateInitializer *x) {
3740 _strategy->visit(x);
3741 }
3742
3743 virtual void visit(SgAlignOfOp *x) {
3744 _strategy->visit(x);
3745 }
3746
3747 virtual void visit(SgAndAssignOp *x) {
3748 _strategy->visit(x);
3749 }
3750
3751 virtual void visit(SgAndOp *x) {
3752 _strategy->visit(x);
3753 }
3754
3755 virtual void visit(SgArrowExp *x) {
3756 _strategy->visit(x);
3757 }
3758
3759 virtual void visit(SgArrowStarOp *x) {
3760 _strategy->visit(x);
3761 }
3762
3763 virtual void visit(SgAsmOp *x) {
3764 _strategy->visit(x);
3765 }
3766
3767 virtual void visit(SgAssignInitializer *x) {
3768 _strategy->visit(x);
3769 }
3770
3771 virtual void visit(SgAssignOp *x) {
3772 _strategy->visit(x);
3773 }
3774
3775 virtual void visit(SgAsteriskShapeExp *x) {
3776 _strategy->visit(x);
3777 }
3778
3779 virtual void visit(SgAtExp *x) {
3780 _strategy->visit(x);
3781 }
3782
3783 virtual void visit(SgAtOp *x) {
3784 _strategy->visit(x);
3785 }
3786
3787 virtual void visit(SgAwaitExpression *x) {
3788 _strategy->visit(x);
3789 }
3790
3791 virtual void visit(SgBitAndOp *x) {
3792 _strategy->visit(x);
3793 }
3794
3795 virtual void visit(SgBitComplementOp *x) {
3796 _strategy->visit(x);
3797 }
3798
3799 virtual void visit(SgBitEqvOp *x) {
3800 _strategy->visit(x);
3801 }
3802
3803 virtual void visit(SgBitOrOp *x) {
3804 _strategy->visit(x);
3805 }
3806
3807 virtual void visit(SgBitXorOp *x) {
3808 _strategy->visit(x);
3809 }
3810
3811 virtual void visit(SgBoolValExp *x) {
3812 _strategy->visit(x);
3813 }
3814
3815 virtual void visit(SgBracedInitializer *x) {
3816 _strategy->visit(x);
3817 }
3818
3819 virtual void visit(SgCAFCoExpression *x) {
3820 _strategy->visit(x);
3821 }
3822
3823 virtual void visit(SgCastExp *x) {
3824 _strategy->visit(x);
3825 }
3826
3827 virtual void visit(SgChar16Val *x) {
3828 _strategy->visit(x);
3829 }
3830
3831 virtual void visit(SgChar32Val *x) {
3832 _strategy->visit(x);
3833 }
3834
3835 virtual void visit(SgCharVal *x) {
3836 _strategy->visit(x);
3837 }
3838
3839 virtual void visit(SgChooseExpression *x) {
3840 _strategy->visit(x);
3841 }
3842
3843 virtual void visit(SgClassExp *x) {
3844 _strategy->visit(x);
3845 }
3846
3847 virtual void visit(SgClassNameRefExp *x) {
3848 _strategy->visit(x);
3849 }
3850
3851 virtual void visit(SgColonShapeExp *x) {
3852 _strategy->visit(x);
3853 }
3854
3855 virtual void visit(SgCommaOpExp *x) {
3856 _strategy->visit(x);
3857 }
3858
3859 virtual void visit(SgComplexVal *x) {
3860 _strategy->visit(x);
3861 }
3862
3863 virtual void visit(SgCompoundInitializer *x) {
3864 _strategy->visit(x);
3865 }
3866
3867 virtual void visit(SgCompoundLiteralExp *x) {
3868 _strategy->visit(x);
3869 }
3870
3871 virtual void visit(SgComprehension *x) {
3872 _strategy->visit(x);
3873 }
3874
3875 virtual void visit(SgConcatenationOp *x) {
3876 _strategy->visit(x);
3877 }
3878
3879 virtual void visit(SgConjugateOp *x) {
3880 _strategy->visit(x);
3881 }
3882
3883 virtual void visit(SgConditionalExp *x) {
3884 _strategy->visit(x);
3885 }
3886
3887 virtual void visit(SgConstructorInitializer *x) {
3888 _strategy->visit(x);
3889 }
3890
3891 virtual void visit(SgCudaKernelCallExp *x) {
3892 _strategy->visit(x);
3893 }
3894
3895 virtual void visit(SgCudaKernelExecConfig *x) {
3896 _strategy->visit(x);
3897 }
3898
3899 virtual void visit(SgDeleteExp *x) {
3900 _strategy->visit(x);
3901 }
3902
3903 virtual void visit(SgDesignatedInitializer *x) {
3904 _strategy->visit(x);
3905 }
3906
3907 virtual void visit(SgDictionaryComprehension *x) {
3908 _strategy->visit(x);
3909 }
3910
3911 virtual void visit(SgDictionaryExp *x) {
3912 _strategy->visit(x);
3913 }
3914
3915 virtual void visit(SgDivAssignOp *x) {
3916 _strategy->visit(x);
3917 }
3918
3919 virtual void visit(SgDivideOp *x) {
3920 _strategy->visit(x);
3921 }
3922
3923 virtual void visit(SgDotDotExp *x) {
3924 _strategy->visit(x);
3925 }
3926
3927 virtual void visit(SgDotExp *x) {
3928 _strategy->visit(x);
3929 }
3930
3931 virtual void visit(SgDotStarOp *x) {
3932 _strategy->visit(x);
3933 }
3934
3935 virtual void visit(SgDoubleVal *x) {
3936 _strategy->visit(x);
3937 }
3938
3939 virtual void visit(SgElementwiseAddOp *x) {
3940 _strategy->visit(x);
3941 }
3942
3943 virtual void visit(SgElementwiseDivideOp *x) {
3944 _strategy->visit(x);
3945 }
3946
3947 virtual void visit(SgElementwiseLeftDivideOp *x) {
3948 _strategy->visit(x);
3949 }
3950
3951 virtual void visit(SgElementwiseMultiplyOp *x) {
3952 _strategy->visit(x);
3953 }
3954
3955 virtual void visit(SgElementwisePowerOp *x) {
3956 _strategy->visit(x);
3957 }
3958
3959 virtual void visit(SgElementwiseSubtractOp *x) {
3960 _strategy->visit(x);
3961 }
3962
3963 virtual void visit(SgEnumVal *x) {
3964 _strategy->visit(x);
3965 }
3966
3967 virtual void visit(SgEqualityOp *x) {
3968 _strategy->visit(x);
3969 }
3970
3971 virtual void visit(SgExponentiationAssignOp *x) {
3972 _strategy->visit(x);
3973 }
3974
3975 virtual void visit(SgExponentiationOp *x) {
3976 _strategy->visit(x);
3977 }
3978
3979 virtual void visit(SgExpressionRoot *x) {
3980 _strategy->visit(x);
3981 }
3982
3983 virtual void visit(SgFinishExp *x) {
3984 _strategy->visit(x);
3985 }
3986
3987 virtual void visit(SgFloat128Val *x) {
3988 _strategy->visit(x);
3989 }
3990
3991 virtual void visit(SgFloat80Val *x) {
3992 _strategy->visit(x);
3993 }
3994
3995 virtual void visit(SgFloatVal *x) {
3996 _strategy->visit(x);
3997 }
3998
3999 virtual void visit(SgFoldExpression *x) {
4000 _strategy->visit(x);
4001 }
4002
4003 virtual void visit(SgFunctionParameterRefExp *x) {
4004 _strategy->visit(x);
4005 }
4006
4007 virtual void visit(SgFunctionRefExp *x) {
4008 _strategy->visit(x);
4009 }
4010
4011 virtual void visit(SgGreaterOrEqualOp *x) {
4012 _strategy->visit(x);
4013 }
4014
4015 virtual void visit(SgGreaterThanOp *x) {
4016 _strategy->visit(x);
4017 }
4018
4019 virtual void visit(SgHereExp *x) {
4020 _strategy->visit(x);
4021 }
4022
4023 virtual void visit(SgImagPartOp *x) {
4024 _strategy->visit(x);
4025 }
4026
4027 virtual void visit(SgImpliedDo *x) {
4028 _strategy->visit(x);
4029 }
4030
4031 virtual void visit(SgIntegerDivideAssignOp *x) {
4032 _strategy->visit(x);
4033 }
4034
4035 virtual void visit(SgIntegerDivideOp *x) {
4036 _strategy->visit(x);
4037 }
4038
4039 virtual void visit(SgIntVal *x) {
4040 _strategy->visit(x);
4041 }
4042
4043 virtual void visit(SgIOItemExpression *x) {
4044 _strategy->visit(x);
4045 }
4046
4047 virtual void visit(SgIorAssignOp *x) {
4048 _strategy->visit(x);
4049 }
4050
4051 virtual void visit(SgIsNotOp *x) {
4052 _strategy->visit(x);
4053 }
4054
4055 virtual void visit(SgIsOp *x) {
4056 _strategy->visit(x);
4057 }
4058
4059 virtual void visit(SgJavaInstanceOfOp *x) {
4060 _strategy->visit(x);
4061 }
4062
4063 virtual void visit(SgJavaMarkerAnnotation *x) {
4064 _strategy->visit(x);
4065 }
4066
4067 virtual void visit(SgJavaNormalAnnotation *x) {
4068 _strategy->visit(x);
4069 }
4070
4071 virtual void visit(SgJavaSingleMemberAnnotation *x) {
4072 _strategy->visit(x);
4073 }
4074
4075 virtual void visit(SgJavaTypeExpression *x) {
4076 _strategy->visit(x);
4077 }
4078
4079 virtual void visit(SgJavaUnsignedRshiftAssignOp *x) {
4080 _strategy->visit(x);
4081 }
4082
4083 virtual void visit(SgJavaUnsignedRshiftOp *x) {
4084 _strategy->visit(x);
4085 }
4086
4087 virtual void visit(SgJovialPresetPositionExp *x) {
4088 _strategy->visit(x);
4089 }
4090
4091 virtual void visit(SgJovialTablePresetExp *x) {
4092 _strategy->visit(x);
4093 }
4094
4095 virtual void visit(SgKeyDatumPair *x) {
4096 _strategy->visit(x);
4097 }
4098
4099 virtual void visit(SgLabelRefExp *x) {
4100 _strategy->visit(x);
4101 }
4102
4103 virtual void visit(SgLambdaExp *x) {
4104 _strategy->visit(x);
4105 }
4106
4107 virtual void visit(SgLambdaRefExp *x) {
4108 _strategy->visit(x);
4109 }
4110
4111 virtual void visit(SgLeftDivideOp *x) {
4112 _strategy->visit(x);
4113 }
4114
4115 virtual void visit(SgLessOrEqualOp *x) {
4116 _strategy->visit(x);
4117 }
4118
4119 virtual void visit(SgLessThanOp *x) {
4120 _strategy->visit(x);
4121 }
4122
4123 virtual void visit(SgListComprehension *x) {
4124 _strategy->visit(x);
4125 }
4126
4127 virtual void visit(SgListExp *x) {
4128 _strategy->visit(x);
4129 }
4130
4131 virtual void visit(SgLongDoubleVal *x) {
4132 _strategy->visit(x);
4133 }
4134
4135 virtual void visit(SgLongIntVal *x) {
4136 _strategy->visit(x);
4137 }
4138
4139 virtual void visit(SgLongLongIntVal *x) {
4140 _strategy->visit(x);
4141 }
4142
4143 virtual void visit(SgLshiftAssignOp *x) {
4144 _strategy->visit(x);
4145 }
4146
4147 virtual void visit(SgLshiftOp *x) {
4148 _strategy->visit(x);
4149 }
4150
4151 virtual void visit(SgMagicColonExp *x) {
4152 _strategy->visit(x);
4153 }
4154
4155 virtual void visit(SgMatrixExp *x) {
4156 _strategy->visit(x);
4157 }
4158
4159 virtual void visit(SgMatrixTransposeOp *x) {
4160 _strategy->visit(x);
4161 }
4162
4163 virtual void visit(SgMemberFunctionRefExp *x) {
4164 _strategy->visit(x);
4165 }
4166
4167 virtual void visit(SgMembershipOp *x) {
4168 _strategy->visit(x);
4169 }
4170
4171 virtual void visit(SgMinusAssignOp *x) {
4172 _strategy->visit(x);
4173 }
4174
4175 virtual void visit(SgMinusMinusOp *x) {
4176 _strategy->visit(x);
4177 }
4178
4179 virtual void visit(SgMinusOp *x) {
4180 _strategy->visit(x);
4181 }
4182
4183 virtual void visit(SgModAssignOp *x) {
4184 _strategy->visit(x);
4185 }
4186
4187 virtual void visit(SgModOp *x) {
4188 _strategy->visit(x);
4189 }
4190
4191 virtual void visit(SgMultAssignOp *x) {
4192 _strategy->visit(x);
4193 }
4194
4195 virtual void visit(SgMultiplyOp *x) {
4196 _strategy->visit(x);
4197 }
4198
4199 virtual void visit(SgNaryBooleanOp *x) {
4200 _strategy->visit(x);
4201 }
4202
4203 virtual void visit(SgNaryComparisonOp *x) {
4204 _strategy->visit(x);
4205 }
4206
4207 virtual void visit(SgNewExp *x) {
4208 _strategy->visit(x);
4209 }
4210
4211 virtual void visit(SgNoexceptOp *x) {
4212 _strategy->visit(x);
4213 }
4214
4215 virtual void visit(SgNonMembershipOp *x) {
4216 _strategy->visit(x);
4217 }
4218
4219 virtual void visit(SgNonrealRefExp *x) {
4220 _strategy->visit(x);
4221 }
4222
4223 virtual void visit(SgNotOp *x) {
4224 _strategy->visit(x);
4225 }
4226
4227 virtual void visit(SgNotEqualOp *x) {
4228 _strategy->visit(x);
4229 }
4230
4231 virtual void visit(SgNullExpression *x) {
4232 _strategy->visit(x);
4233 }
4234
4235 virtual void visit(SgNullptrValExp *x) {
4236 _strategy->visit(x);
4237 }
4238
4239 virtual void visit(SgOrOp *x) {
4240 _strategy->visit(x);
4241 }
4242
4243 virtual void visit(SgPlusAssignOp *x) {
4244 _strategy->visit(x);
4245 }
4246
4247 virtual void visit(SgPlusPlusOp *x) {
4248 _strategy->visit(x);
4249 }
4250
4251 virtual void visit(SgPntrArrRefExp *x) {
4252 _strategy->visit(x);
4253 }
4254
4255 virtual void visit(SgPointerAssignOp *x) {
4256 _strategy->visit(x);
4257 }
4258
4259 virtual void visit(SgPointerDerefExp *x) {
4260 _strategy->visit(x);
4261 }
4262
4263 virtual void visit(SgPowerOp *x) {
4264 _strategy->visit(x);
4265 }
4266
4267 virtual void visit(SgPseudoDestructorRefExp *x) {
4268 _strategy->visit(x);
4269 }
4270
4271 virtual void visit(SgRangeExp *x) {
4272 _strategy->visit(x);
4273 }
4274
4275 virtual void visit(SgRealPartOp *x) {
4276 _strategy->visit(x);
4277 }
4278
4279 virtual void visit(SgRefExp *x) {
4280 _strategy->visit(x);
4281 }
4282
4283 virtual void visit(SgRemOp *x) {
4284 _strategy->visit(x);
4285 }
4286
4287 virtual void visit(SgReplicationOp *x) {
4288 _strategy->visit(x);
4289 }
4290
4291 virtual void visit(SgRshiftAssignOp *x) {
4292 _strategy->visit(x);
4293 }
4294
4295 virtual void visit(SgRshiftOp *x) {
4296 _strategy->visit(x);
4297 }
4298
4299 virtual void visit(SgScopeOp *x) {
4300 _strategy->visit(x);
4301 }
4302
4303 virtual void visit(SgSetComprehension *x) {
4304 _strategy->visit(x);
4305 }
4306
4307 virtual void visit(SgShortVal *x) {
4308 _strategy->visit(x);
4309 }
4310
4311 virtual void visit(SgSizeOfOp *x) {
4312 _strategy->visit(x);
4313 }
4314
4315 virtual void visit(SgSpaceshipOp *x) {
4316 _strategy->visit(x);
4317 }
4318
4319 virtual void visit(SgStatementExpression *x) {
4320 _strategy->visit(x);
4321 }
4322
4323 virtual void visit(SgStringConversion *x) {
4324 _strategy->visit(x);
4325 }
4326
4327 virtual void visit(SgStringVal *x) {
4328 _strategy->visit(x);
4329 }
4330
4331 virtual void visit(SgSubscriptExpression *x) {
4332 _strategy->visit(x);
4333 }
4334
4335 virtual void visit(SgSubtractOp *x) {
4336 _strategy->visit(x);
4337 }
4338
4339 virtual void visit(SgSuperExp *x) {
4340 _strategy->visit(x);
4341 }
4342
4343 virtual void visit(SgTemplateFunctionRefExp *x) {
4344 _strategy->visit(x);
4345 }
4346
4347 virtual void visit(SgTemplateMemberFunctionRefExp *x) {
4348 _strategy->visit(x);
4349 }
4350
4351 virtual void visit(SgTemplateParameterVal *x) {
4352 _strategy->visit(x);
4353 }
4354
4355 virtual void visit(SgThisExp *x) {
4356 _strategy->visit(x);
4357 }
4358
4359 virtual void visit(SgThrowOp *x) {
4360 _strategy->visit(x);
4361 }
4362
4363 virtual void visit(SgTupleExp *x) {
4364 _strategy->visit(x);
4365 }
4366
4367 virtual void visit(SgTypeExpression *x) {
4368 _strategy->visit(x);
4369 }
4370
4371 virtual void visit(SgTypeIdOp *x) {
4372 _strategy->visit(x);
4373 }
4374
4375 virtual void visit(SgTypeTraitBuiltinOperator *x) {
4376 _strategy->visit(x);
4377 }
4378
4379 virtual void visit(SgUnaryAddOp *x) {
4380 _strategy->visit(x);
4381 }
4382
4383 virtual void visit(SgUnknownArrayOrFunctionReference *x) {
4384 _strategy->visit(x);
4385 }
4386
4387 virtual void visit(SgUnsignedCharVal *x) {
4388 _strategy->visit(x);
4389 }
4390
4391 virtual void visit(SgUnsignedIntVal *x) {
4392 _strategy->visit(x);
4393 }
4394
4395 virtual void visit(SgUnsignedLongLongIntVal *x) {
4396 _strategy->visit(x);
4397 }
4398
4399 virtual void visit(SgUnsignedLongVal *x) {
4400 _strategy->visit(x);
4401 }
4402
4403 virtual void visit(SgUnsignedShortVal *x) {
4404 _strategy->visit(x);
4405 }
4406
4407 virtual void visit(SgUpcBlocksizeofExpression *x) {
4408 _strategy->visit(x);
4409 }
4410
4411 virtual void visit(SgUpcElemsizeofExpression *x) {
4412 _strategy->visit(x);
4413 }
4414
4415 virtual void visit(SgUpcLocalsizeofExpression *x) {
4416 _strategy->visit(x);
4417 }
4418
4419 virtual void visit(SgUpcMythread *x) {
4420 _strategy->visit(x);
4421 }
4422
4423 virtual void visit(SgUpcThreads *x) {
4424 _strategy->visit(x);
4425 }
4426
4427 virtual void visit(SgUserDefinedBinaryOp *x) {
4428 _strategy->visit(x);
4429 }
4430
4431 virtual void visit(SgUserDefinedUnaryOp *x) {
4432 _strategy->visit(x);
4433 }
4434
4435 virtual void visit(SgVarArgCopyOp *x) {
4436 _strategy->visit(x);
4437 }
4438
4439 virtual void visit(SgVarArgEndOp *x) {
4440 _strategy->visit(x);
4441 }
4442
4443 virtual void visit(SgVarArgOp *x) {
4444 _strategy->visit(x);
4445 }
4446
4447 virtual void visit(SgVarArgStartOneOperandOp *x) {
4448 _strategy->visit(x);
4449 }
4450
4451 virtual void visit(SgVarArgStartOp *x) {
4452 _strategy->visit(x);
4453 }
4454
4455 virtual void visit(SgVariantExpression *x) {
4456 _strategy->visit(x);
4457 }
4458
4459 virtual void visit(SgVarRefExp *x) {
4460 _strategy->visit(x);
4461 }
4462
4463 virtual void visit(SgVoidVal *x) {
4464 _strategy->visit(x);
4465 }
4466
4467 virtual void visit(SgWcharVal *x) {
4468 _strategy->visit(x);
4469 }
4470
4471 virtual void visit(SgXorAssignOp *x) {
4472 _strategy->visit(x);
4473 }
4474
4475 virtual void visit(SgYieldExpression *x) {
4476 _strategy->visit(x);
4477 }
4478
4479 virtual void visit(SgCompoundAssignOp *x) {
4480 _strategy->visit(x);
4481 }
4482
4483 virtual void visit(SgElementwiseOp *x) {
4484 _strategy->visit(x);
4485 }
4486
4487 virtual void visit(SgBinaryOp *x) {
4488 _strategy->visit(x);
4489 }
4490
4491 virtual void visit(SgFunctionCallExp *x) {
4492 _strategy->visit(x);
4493 }
4494
4495 virtual void visit(SgCallExpression *x) {
4496 _strategy->visit(x);
4497 }
4498
4499 virtual void visit(SgExprListExp *x) {
4500 _strategy->visit(x);
4501 }
4502
4503 virtual void visit(SgInitializer *x) {
4504 _strategy->visit(x);
4505 }
4506
4507 virtual void visit(SgJavaAnnotation *x) {
4508 _strategy->visit(x);
4509 }
4510
4511 virtual void visit(SgNaryOp *x) {
4512 _strategy->visit(x);
4513 }
4514
4515 virtual void visit(SgUnaryOp *x) {
4516 _strategy->visit(x);
4517 }
4518
4519 virtual void visit(SgValueExp *x) {
4520 _strategy->visit(x);
4521 }
4522
4523 virtual void visit(SgExpression *x) {
4524 _strategy->visit(x);
4525 }
4526
4527 virtual void visit(SgTemplateVariableSymbol *x) {
4528 _strategy->visit(x);
4529 }
4530
4531 virtual void visit(SgVariableSymbol *x) {
4532 _strategy->visit(x);
4533 }
4534
4535 virtual void visit(SgFunctionTypeSymbol *x) {
4536 _strategy->visit(x);
4537 }
4538
4539 virtual void visit(SgTemplateClassSymbol *x) {
4540 _strategy->visit(x);
4541 }
4542
4543 virtual void visit(SgClassSymbol *x) {
4544 _strategy->visit(x);
4545 }
4546
4547 virtual void visit(SgTemplateSymbol *x) {
4548 _strategy->visit(x);
4549 }
4550
4551 virtual void visit(SgEnumSymbol *x) {
4552 _strategy->visit(x);
4553 }
4554
4555 virtual void visit(SgEnumFieldSymbol *x) {
4556 _strategy->visit(x);
4557 }
4558
4559 virtual void visit(SgTemplateTypedefSymbol *x) {
4560 _strategy->visit(x);
4561 }
4562
4563 virtual void visit(SgTypedefSymbol *x) {
4564 _strategy->visit(x);
4565 }
4566
4567 virtual void visit(SgTemplateFunctionSymbol *x) {
4568 _strategy->visit(x);
4569 }
4570
4571 virtual void visit(SgTemplateMemberFunctionSymbol *x) {
4572 _strategy->visit(x);
4573 }
4574
4575 virtual void visit(SgLabelSymbol *x) {
4576 _strategy->visit(x);
4577 }
4578
4579 virtual void visit(SgJavaLabelSymbol *x) {
4580 _strategy->visit(x);
4581 }
4582
4583 virtual void visit(SgDefaultSymbol *x) {
4584 _strategy->visit(x);
4585 }
4586
4587 virtual void visit(SgNamespaceSymbol *x) {
4588 _strategy->visit(x);
4589 }
4590
4591 virtual void visit(SgIntrinsicSymbol *x) {
4592 _strategy->visit(x);
4593 }
4594
4595 virtual void visit(SgModuleSymbol *x) {
4596 _strategy->visit(x);
4597 }
4598
4599 virtual void visit(SgInterfaceSymbol *x) {
4600 _strategy->visit(x);
4601 }
4602
4603 virtual void visit(SgCommonSymbol *x) {
4604 _strategy->visit(x);
4605 }
4606
4607 virtual void visit(SgRenameSymbol *x) {
4608 _strategy->visit(x);
4609 }
4610
4611 virtual void visit(SgAdaInheritedFunctionSymbol *x) {
4612 _strategy->visit(x);
4613 }
4614
4615 virtual void visit(SgMemberFunctionSymbol *x) {
4616 _strategy->visit(x);
4617 }
4618
4619 virtual void visit(SgFunctionSymbol *x) {
4620 _strategy->visit(x);
4621 }
4622
4623 virtual void visit(SgAsmBinaryAddressSymbol *x) {
4624 _strategy->visit(x);
4625 }
4626
4627 virtual void visit(SgAsmBinaryDataSymbol *x) {
4628 _strategy->visit(x);
4629 }
4630
4631 virtual void visit(SgAliasSymbol *x) {
4632 _strategy->visit(x);
4633 }
4634
4635 virtual void visit(SgNonrealSymbol *x) {
4636 _strategy->visit(x);
4637 }
4638
4639 virtual void visit(SgAdaPackageSymbol *x) {
4640 _strategy->visit(x);
4641 }
4642
4643 virtual void visit(SgAdaTaskSymbol *x) {
4644 _strategy->visit(x);
4645 }
4646
4647 virtual void visit(SgAdaProtectedSymbol *x) {
4648 _strategy->visit(x);
4649 }
4650
4651 virtual void visit(SgAdaGenericSymbol *x) {
4652 _strategy->visit(x);
4653 }
4654
4655 virtual void visit(SgAdaGenericInstanceSymbol *x) {
4656 _strategy->visit(x);
4657 }
4658
4659 virtual void visit(SgAdaFormalPackageSymbol *x) {
4660 _strategy->visit(x);
4661 }
4662
4663 virtual void visit(SgAdaRenamingSymbol *x) {
4664 _strategy->visit(x);
4665 }
4666
4667 virtual void visit(SgSymbol *x) {
4668 _strategy->visit(x);
4669 }
4670
4671 virtual void visit(SgAsmX86Instruction *x) {
4672 _strategy->visit(x);
4673 }
4674
4675 virtual void visit(SgAsmVoidType *x) {
4676 _strategy->visit(x);
4677 }
4678
4679 virtual void visit(SgAsmVectorType *x) {
4680 _strategy->visit(x);
4681 }
4682
4683 virtual void visit(SgAsmUserInstruction *x) {
4684 _strategy->visit(x);
4685 }
4686
4687 virtual void visit(SgAsmUnaryUnsignedExtend *x) {
4688 _strategy->visit(x);
4689 }
4690
4691 virtual void visit(SgAsmUnaryTruncate *x) {
4692 _strategy->visit(x);
4693 }
4694
4695 virtual void visit(SgAsmUnarySignedExtend *x) {
4696 _strategy->visit(x);
4697 }
4698
4699 virtual void visit(SgAsmUnaryRrx *x) {
4700 _strategy->visit(x);
4701 }
4702
4703 virtual void visit(SgAsmUnaryPlus *x) {
4704 _strategy->visit(x);
4705 }
4706
4707 virtual void visit(SgAsmUnaryMinus *x) {
4708 _strategy->visit(x);
4709 }
4710
4711 virtual void visit(SgAsmUnaryExpression *x) {
4712 _strategy->visit(x);
4713 }
4714
4715 virtual void visit(SgAsmSynthesizedFieldDeclaration *x) {
4716 _strategy->visit(x);
4717 }
4718
4719 virtual void visit(SgAsmSynthesizedDataStructureDeclaration *x) {
4720 _strategy->visit(x);
4721 }
4722
4723 virtual void visit(SgAsmStringStorage *x) {
4724 _strategy->visit(x);
4725 }
4726
4727 virtual void visit(SgAsmStoredString *x) {
4728 _strategy->visit(x);
4729 }
4730
4731 virtual void visit(SgAsmStaticData *x) {
4732 _strategy->visit(x);
4733 }
4734
4735 virtual void visit(SgAsmStackExpression *x) {
4736 _strategy->visit(x);
4737 }
4738
4739 virtual void visit(SgAsmRiscOperation *x) {
4740 _strategy->visit(x);
4741 }
4742
4743 virtual void visit(SgAsmRegisterNames *x) {
4744 _strategy->visit(x);
4745 }
4746
4747 virtual void visit(SgAsmPowerpcInstruction *x) {
4748 _strategy->visit(x);
4749 }
4750
4751 virtual void visit(SgAsmPointerType *x) {
4752 _strategy->visit(x);
4753 }
4754
4755 virtual void visit(SgAsmPEStringSection *x) {
4756 _strategy->visit(x);
4757 }
4758
4759 virtual void visit(SgAsmPESectionTable *x) {
4760 _strategy->visit(x);
4761 }
4762
4763 virtual void visit(SgAsmPESectionTableEntry *x) {
4764 _strategy->visit(x);
4765 }
4766
4767 virtual void visit(SgAsmPERVASizePairList *x) {
4768 _strategy->visit(x);
4769 }
4770
4771 virtual void visit(SgAsmPERVASizePair *x) {
4772 _strategy->visit(x);
4773 }
4774
4775 virtual void visit(SgAsmPEImportSection *x) {
4776 _strategy->visit(x);
4777 }
4778
4779 virtual void visit(SgAsmPEImportItemList *x) {
4780 _strategy->visit(x);
4781 }
4782
4783 virtual void visit(SgAsmPEImportItem *x) {
4784 _strategy->visit(x);
4785 }
4786
4787 virtual void visit(SgAsmPEImportDirectoryList *x) {
4788 _strategy->visit(x);
4789 }
4790
4791 virtual void visit(SgAsmPEImportDirectory *x) {
4792 _strategy->visit(x);
4793 }
4794
4795 virtual void visit(SgAsmPEFileHeader *x) {
4796 _strategy->visit(x);
4797 }
4798
4799 virtual void visit(SgAsmPEExportSection *x) {
4800 _strategy->visit(x);
4801 }
4802
4803 virtual void visit(SgAsmPESection *x) {
4804 _strategy->visit(x);
4805 }
4806
4807 virtual void visit(SgAsmPEExportEntryList *x) {
4808 _strategy->visit(x);
4809 }
4810
4811 virtual void visit(SgAsmPEExportEntry *x) {
4812 _strategy->visit(x);
4813 }
4814
4815 virtual void visit(SgAsmPEExportDirectory *x) {
4816 _strategy->visit(x);
4817 }
4818
4819 virtual void visit(SgAsmOperandList *x) {
4820 _strategy->visit(x);
4821 }
4822
4823 virtual void visit(SgAsmNullInstruction *x) {
4824 _strategy->visit(x);
4825 }
4826
4827 virtual void visit(SgAsmNEStringTable *x) {
4828 _strategy->visit(x);
4829 }
4830
4831 virtual void visit(SgAsmNESectionTable *x) {
4832 _strategy->visit(x);
4833 }
4834
4835 virtual void visit(SgAsmNESectionTableEntry *x) {
4836 _strategy->visit(x);
4837 }
4838
4839 virtual void visit(SgAsmNESection *x) {
4840 _strategy->visit(x);
4841 }
4842
4843 virtual void visit(SgAsmNERelocTable *x) {
4844 _strategy->visit(x);
4845 }
4846
4847 virtual void visit(SgAsmNERelocEntry *x) {
4848 _strategy->visit(x);
4849 }
4850
4851 virtual void visit(SgAsmNENameTable *x) {
4852 _strategy->visit(x);
4853 }
4854
4855 virtual void visit(SgAsmNEModuleTable *x) {
4856 _strategy->visit(x);
4857 }
4858
4859 virtual void visit(SgAsmNEFileHeader *x) {
4860 _strategy->visit(x);
4861 }
4862
4863 virtual void visit(SgAsmNEEntryTable *x) {
4864 _strategy->visit(x);
4865 }
4866
4867 virtual void visit(SgAsmNEEntryPoint *x) {
4868 _strategy->visit(x);
4869 }
4870
4871 virtual void visit(SgAsmMipsInstruction *x) {
4872 _strategy->visit(x);
4873 }
4874
4875 virtual void visit(SgAsmMemoryReferenceExpression *x) {
4876 _strategy->visit(x);
4877 }
4878
4879 virtual void visit(SgAsmM68kInstruction *x) {
4880 _strategy->visit(x);
4881 }
4882
4883 virtual void visit(SgAsmLESectionTable *x) {
4884 _strategy->visit(x);
4885 }
4886
4887 virtual void visit(SgAsmLESectionTableEntry *x) {
4888 _strategy->visit(x);
4889 }
4890
4891 virtual void visit(SgAsmLESection *x) {
4892 _strategy->visit(x);
4893 }
4894
4895 virtual void visit(SgAsmLERelocTable *x) {
4896 _strategy->visit(x);
4897 }
4898
4899 virtual void visit(SgAsmLEPageTable *x) {
4900 _strategy->visit(x);
4901 }
4902
4903 virtual void visit(SgAsmLEPageTableEntry *x) {
4904 _strategy->visit(x);
4905 }
4906
4907 virtual void visit(SgAsmLENameTable *x) {
4908 _strategy->visit(x);
4909 }
4910
4911 virtual void visit(SgAsmLEFileHeader *x) {
4912 _strategy->visit(x);
4913 }
4914
4915 virtual void visit(SgAsmLEEntryTable *x) {
4916 _strategy->visit(x);
4917 }
4918
4919 virtual void visit(SgAsmLEEntryPoint *x) {
4920 _strategy->visit(x);
4921 }
4922
4923 virtual void visit(SgAsmJvmStackMapVerificationType *x) {
4924 _strategy->visit(x);
4925 }
4926
4927 virtual void visit(SgAsmJvmStackMapTable *x) {
4928 _strategy->visit(x);
4929 }
4930
4931 virtual void visit(SgAsmJvmStackMapFrame *x) {
4932 _strategy->visit(x);
4933 }
4934
4935 virtual void visit(SgAsmJvmSourceFile *x) {
4936 _strategy->visit(x);
4937 }
4938
4939 virtual void visit(SgAsmJvmSignature *x) {
4940 _strategy->visit(x);
4941 }
4942
4943 virtual void visit(SgAsmJvmNestMembers *x) {
4944 _strategy->visit(x);
4945 }
4946
4947 virtual void visit(SgAsmJvmNestHost *x) {
4948 _strategy->visit(x);
4949 }
4950
4951 virtual void visit(SgAsmJvmModuleMainClass *x) {
4952 _strategy->visit(x);
4953 }
4954
4955 virtual void visit(SgAsmJvmMethodTable *x) {
4956 _strategy->visit(x);
4957 }
4958
4959 virtual void visit(SgAsmJvmMethodParameters *x) {
4960 _strategy->visit(x);
4961 }
4962
4963 virtual void visit(SgAsmJvmMethodParametersEntry *x) {
4964 _strategy->visit(x);
4965 }
4966
4967 virtual void visit(SgAsmJvmMethod *x) {
4968 _strategy->visit(x);
4969 }
4970
4971 virtual void visit(SgAsmJvmLocalVariableTypeTable *x) {
4972 _strategy->visit(x);
4973 }
4974
4975 virtual void visit(SgAsmJvmLocalVariableTypeEntry *x) {
4976 _strategy->visit(x);
4977 }
4978
4979 virtual void visit(SgAsmJvmLocalVariableTable *x) {
4980 _strategy->visit(x);
4981 }
4982
4983 virtual void visit(SgAsmJvmLocalVariableEntry *x) {
4984 _strategy->visit(x);
4985 }
4986
4987 virtual void visit(SgAsmJvmLineNumberTable *x) {
4988 _strategy->visit(x);
4989 }
4990
4991 virtual void visit(SgAsmJvmLineNumberEntry *x) {
4992 _strategy->visit(x);
4993 }
4994
4995 virtual void visit(SgAsmJvmInstruction *x) {
4996 _strategy->visit(x);
4997 }
4998
4999 virtual void visit(SgAsmJvmInnerClasses *x) {
5000 _strategy->visit(x);
5001 }
5002
5003 virtual void visit(SgAsmJvmInnerClassesEntry *x) {
5004 _strategy->visit(x);
5005 }
5006
5007 virtual void visit(SgAsmJvmFileHeader *x) {
5008 _strategy->visit(x);
5009 }
5010
5011 virtual void visit(SgAsmJvmFieldTable *x) {
5012 _strategy->visit(x);
5013 }
5014
5015 virtual void visit(SgAsmJvmField *x) {
5016 _strategy->visit(x);
5017 }
5018
5019 virtual void visit(SgAsmJvmExceptionTable *x) {
5020 _strategy->visit(x);
5021 }
5022
5023 virtual void visit(SgAsmJvmExceptions *x) {
5024 _strategy->visit(x);
5025 }
5026
5027 virtual void visit(SgAsmJvmExceptionHandler *x) {
5028 _strategy->visit(x);
5029 }
5030
5031 virtual void visit(SgAsmJvmEnclosingMethod *x) {
5032 _strategy->visit(x);
5033 }
5034
5035 virtual void visit(SgAsmJvmConstantValue *x) {
5036 _strategy->visit(x);
5037 }
5038
5039 virtual void visit(SgAsmJvmConstantPool *x) {
5040 _strategy->visit(x);
5041 }
5042
5043 virtual void visit(SgAsmJvmConstantPoolEntry *x) {
5044 _strategy->visit(x);
5045 }
5046
5047 virtual void visit(SgAsmJvmCodeAttribute *x) {
5048 _strategy->visit(x);
5049 }
5050
5051 virtual void visit(SgAsmJvmClass *x) {
5052 _strategy->visit(x);
5053 }
5054
5055 virtual void visit(SgAsmJvmBootstrapMethods *x) {
5056 _strategy->visit(x);
5057 }
5058
5059 virtual void visit(SgAsmJvmBootstrapMethod *x) {
5060 _strategy->visit(x);
5061 }
5062
5063 virtual void visit(SgAsmJvmAttributeTable *x) {
5064 _strategy->visit(x);
5065 }
5066
5067 virtual void visit(SgAsmJvmAttribute *x) {
5068 _strategy->visit(x);
5069 }
5070
5071 virtual void visit(SgAsmJvmNode *x) {
5072 _strategy->visit(x);
5073 }
5074
5075 virtual void visit(SgAsmInterpretationList *x) {
5076 _strategy->visit(x);
5077 }
5078
5079 virtual void visit(SgAsmInterpretation *x) {
5080 _strategy->visit(x);
5081 }
5082
5083 virtual void visit(SgAsmIntegerValueExpression *x) {
5084 _strategy->visit(x);
5085 }
5086
5087 virtual void visit(SgAsmIntegerType *x) {
5088 _strategy->visit(x);
5089 }
5090
5091 virtual void visit(SgAsmInstructionList *x) {
5092 _strategy->visit(x);
5093 }
5094
5095 virtual void visit(SgAsmIndirectRegisterExpression *x) {
5096 _strategy->visit(x);
5097 }
5098
5099 virtual void visit(SgAsmGenericSymbolList *x) {
5100 _strategy->visit(x);
5101 }
5102
5103 virtual void visit(SgAsmGenericSectionList *x) {
5104 _strategy->visit(x);
5105 }
5106
5107 virtual void visit(SgAsmGenericHeaderList *x) {
5108 _strategy->visit(x);
5109 }
5110
5111 virtual void visit(SgAsmGenericFormat *x) {
5112 _strategy->visit(x);
5113 }
5114
5115 virtual void visit(SgAsmGenericFileList *x) {
5116 _strategy->visit(x);
5117 }
5118
5119 virtual void visit(SgAsmGenericFile *x) {
5120 _strategy->visit(x);
5121 }
5122
5123 virtual void visit(SgAsmGenericDLLList *x) {
5124 _strategy->visit(x);
5125 }
5126
5127 virtual void visit(SgAsmGenericDLL *x) {
5128 _strategy->visit(x);
5129 }
5130
5131 virtual void visit(SgAsmFunction *x) {
5132 _strategy->visit(x);
5133 }
5134
5135 virtual void visit(SgAsmSynthesizedDeclaration *x) {
5136 _strategy->visit(x);
5137 }
5138
5139 virtual void visit(SgAsmFloatValueExpression *x) {
5140 _strategy->visit(x);
5141 }
5142
5143 virtual void visit(SgAsmFloatType *x) {
5144 _strategy->visit(x);
5145 }
5146
5147 virtual void visit(SgAsmScalarType *x) {
5148 _strategy->visit(x);
5149 }
5150
5151 virtual void visit(SgAsmType *x) {
5152 _strategy->visit(x);
5153 }
5154
5155 virtual void visit(SgAsmExprListExp *x) {
5156 _strategy->visit(x);
5157 }
5158
5159 virtual void visit(SgAsmElfSymverSection *x) {
5160 _strategy->visit(x);
5161 }
5162
5163 virtual void visit(SgAsmElfSymverNeededSection *x) {
5164 _strategy->visit(x);
5165 }
5166
5167 virtual void visit(SgAsmElfSymverNeededEntryList *x) {
5168 _strategy->visit(x);
5169 }
5170
5171 virtual void visit(SgAsmElfSymverNeededEntry *x) {
5172 _strategy->visit(x);
5173 }
5174
5175 virtual void visit(SgAsmElfSymverNeededAuxList *x) {
5176 _strategy->visit(x);
5177 }
5178
5179 virtual void visit(SgAsmElfSymverNeededAux *x) {
5180 _strategy->visit(x);
5181 }
5182
5183 virtual void visit(SgAsmElfSymverEntryList *x) {
5184 _strategy->visit(x);
5185 }
5186
5187 virtual void visit(SgAsmElfSymverEntry *x) {
5188 _strategy->visit(x);
5189 }
5190
5191 virtual void visit(SgAsmElfSymverDefinedSection *x) {
5192 _strategy->visit(x);
5193 }
5194
5195 virtual void visit(SgAsmElfSymverDefinedEntryList *x) {
5196 _strategy->visit(x);
5197 }
5198
5199 virtual void visit(SgAsmElfSymverDefinedEntry *x) {
5200 _strategy->visit(x);
5201 }
5202
5203 virtual void visit(SgAsmElfSymverDefinedAuxList *x) {
5204 _strategy->visit(x);
5205 }
5206
5207 virtual void visit(SgAsmElfSymverDefinedAux *x) {
5208 _strategy->visit(x);
5209 }
5210
5211 virtual void visit(SgAsmElfSymbolSection *x) {
5212 _strategy->visit(x);
5213 }
5214
5215 virtual void visit(SgAsmElfSymbolList *x) {
5216 _strategy->visit(x);
5217 }
5218
5219 virtual void visit(SgAsmElfSymbol *x) {
5220 _strategy->visit(x);
5221 }
5222
5223 virtual void visit(SgAsmElfStrtab *x) {
5224 _strategy->visit(x);
5225 }
5226
5227 virtual void visit(SgAsmElfStringSection *x) {
5228 _strategy->visit(x);
5229 }
5230
5231 virtual void visit(SgAsmElfSegmentTable *x) {
5232 _strategy->visit(x);
5233 }
5234
5235 virtual void visit(SgAsmElfSegmentTableEntryList *x) {
5236 _strategy->visit(x);
5237 }
5238
5239 virtual void visit(SgAsmElfSegmentTableEntry *x) {
5240 _strategy->visit(x);
5241 }
5242
5243 virtual void visit(SgAsmElfSectionTable *x) {
5244 _strategy->visit(x);
5245 }
5246
5247 virtual void visit(SgAsmElfSectionTableEntry *x) {
5248 _strategy->visit(x);
5249 }
5250
5251 virtual void visit(SgAsmElfRelocSection *x) {
5252 _strategy->visit(x);
5253 }
5254
5255 virtual void visit(SgAsmElfRelocEntryList *x) {
5256 _strategy->visit(x);
5257 }
5258
5259 virtual void visit(SgAsmElfRelocEntry *x) {
5260 _strategy->visit(x);
5261 }
5262
5263 virtual void visit(SgAsmElfNoteSection *x) {
5264 _strategy->visit(x);
5265 }
5266
5267 virtual void visit(SgAsmElfNoteEntryList *x) {
5268 _strategy->visit(x);
5269 }
5270
5271 virtual void visit(SgAsmElfNoteEntry *x) {
5272 _strategy->visit(x);
5273 }
5274
5275 virtual void visit(SgAsmElfFileHeader *x) {
5276 _strategy->visit(x);
5277 }
5278
5279 virtual void visit(SgAsmElfEHFrameSection *x) {
5280 _strategy->visit(x);
5281 }
5282
5283 virtual void visit(SgAsmElfEHFrameEntryFDList *x) {
5284 _strategy->visit(x);
5285 }
5286
5287 virtual void visit(SgAsmElfEHFrameEntryFD *x) {
5288 _strategy->visit(x);
5289 }
5290
5291 virtual void visit(SgAsmElfEHFrameEntryCIList *x) {
5292 _strategy->visit(x);
5293 }
5294
5295 virtual void visit(SgAsmElfEHFrameEntryCI *x) {
5296 _strategy->visit(x);
5297 }
5298
5299 virtual void visit(SgAsmElfDynamicSection *x) {
5300 _strategy->visit(x);
5301 }
5302
5303 virtual void visit(SgAsmElfSection *x) {
5304 _strategy->visit(x);
5305 }
5306
5307 virtual void visit(SgAsmElfDynamicEntryList *x) {
5308 _strategy->visit(x);
5309 }
5310
5311 virtual void visit(SgAsmElfDynamicEntry *x) {
5312 _strategy->visit(x);
5313 }
5314
5315 virtual void visit(SgAsmDwarfWithStmt *x) {
5316 _strategy->visit(x);
5317 }
5318
5319 virtual void visit(SgAsmDwarfVolatileType *x) {
5320 _strategy->visit(x);
5321 }
5322
5323 virtual void visit(SgAsmDwarfVariantPart *x) {
5324 _strategy->visit(x);
5325 }
5326
5327 virtual void visit(SgAsmDwarfVariant *x) {
5328 _strategy->visit(x);
5329 }
5330
5331 virtual void visit(SgAsmDwarfVariable *x) {
5332 _strategy->visit(x);
5333 }
5334
5335 virtual void visit(SgAsmDwarfUpcStrictType *x) {
5336 _strategy->visit(x);
5337 }
5338
5339 virtual void visit(SgAsmDwarfUpcSharedType *x) {
5340 _strategy->visit(x);
5341 }
5342
5343 virtual void visit(SgAsmDwarfUpcRelaxedType *x) {
5344 _strategy->visit(x);
5345 }
5346
5347 virtual void visit(SgAsmDwarfUnspecifiedType *x) {
5348 _strategy->visit(x);
5349 }
5350
5351 virtual void visit(SgAsmDwarfUnspecifiedParameters *x) {
5352 _strategy->visit(x);
5353 }
5354
5355 virtual void visit(SgAsmDwarfUnknownConstruct *x) {
5356 _strategy->visit(x);
5357 }
5358
5359 virtual void visit(SgAsmDwarfUnionType *x) {
5360 _strategy->visit(x);
5361 }
5362
5363 virtual void visit(SgAsmDwarfTypedef *x) {
5364 _strategy->visit(x);
5365 }
5366
5367 virtual void visit(SgAsmDwarfTryBlock *x) {
5368 _strategy->visit(x);
5369 }
5370
5371 virtual void visit(SgAsmDwarfThrownType *x) {
5372 _strategy->visit(x);
5373 }
5374
5375 virtual void visit(SgAsmDwarfTemplateValueParameter *x) {
5376 _strategy->visit(x);
5377 }
5378
5379 virtual void visit(SgAsmDwarfTemplateTypeParameter *x) {
5380 _strategy->visit(x);
5381 }
5382
5383 virtual void visit(SgAsmDwarfSubroutineType *x) {
5384 _strategy->visit(x);
5385 }
5386
5387 virtual void visit(SgAsmDwarfSubrangeType *x) {
5388 _strategy->visit(x);
5389 }
5390
5391 virtual void visit(SgAsmDwarfSubprogram *x) {
5392 _strategy->visit(x);
5393 }
5394
5395 virtual void visit(SgAsmDwarfStructureType *x) {
5396 _strategy->visit(x);
5397 }
5398
5399 virtual void visit(SgAsmDwarfStringType *x) {
5400 _strategy->visit(x);
5401 }
5402
5403 virtual void visit(SgAsmDwarfSharedType *x) {
5404 _strategy->visit(x);
5405 }
5406
5407 virtual void visit(SgAsmDwarfSetType *x) {
5408 _strategy->visit(x);
5409 }
5410
5411 virtual void visit(SgAsmDwarfRestrictType *x) {
5412 _strategy->visit(x);
5413 }
5414
5415 virtual void visit(SgAsmDwarfReferenceType *x) {
5416 _strategy->visit(x);
5417 }
5418
5419 virtual void visit(SgAsmDwarfPtrToMemberType *x) {
5420 _strategy->visit(x);
5421 }
5422
5423 virtual void visit(SgAsmDwarfPointerType *x) {
5424 _strategy->visit(x);
5425 }
5426
5427 virtual void visit(SgAsmDwarfPartialUnit *x) {
5428 _strategy->visit(x);
5429 }
5430
5431 virtual void visit(SgAsmDwarfPackedType *x) {
5432 _strategy->visit(x);
5433 }
5434
5435 virtual void visit(SgAsmDwarfNamespace *x) {
5436 _strategy->visit(x);
5437 }
5438
5439 virtual void visit(SgAsmDwarfNamelistItem *x) {
5440 _strategy->visit(x);
5441 }
5442
5443 virtual void visit(SgAsmDwarfNamelist *x) {
5444 _strategy->visit(x);
5445 }
5446
5447 virtual void visit(SgAsmDwarfMutableType *x) {
5448 _strategy->visit(x);
5449 }
5450
5451 virtual void visit(SgAsmDwarfModule *x) {
5452 _strategy->visit(x);
5453 }
5454
5455 virtual void visit(SgAsmDwarfMember *x) {
5456 _strategy->visit(x);
5457 }
5458
5459 virtual void visit(SgAsmDwarfMacroList *x) {
5460 _strategy->visit(x);
5461 }
5462
5463 virtual void visit(SgAsmDwarfMacro *x) {
5464 _strategy->visit(x);
5465 }
5466
5467 virtual void visit(SgAsmDwarfLineList *x) {
5468 _strategy->visit(x);
5469 }
5470
5471 virtual void visit(SgAsmDwarfLine *x) {
5472 _strategy->visit(x);
5473 }
5474
5475 virtual void visit(SgAsmDwarfLexicalBlock *x) {
5476 _strategy->visit(x);
5477 }
5478
5479 virtual void visit(SgAsmDwarfLabel *x) {
5480 _strategy->visit(x);
5481 }
5482
5483 virtual void visit(SgAsmDwarfInterfaceType *x) {
5484 _strategy->visit(x);
5485 }
5486
5487 virtual void visit(SgAsmDwarfInlinedSubroutine *x) {
5488 _strategy->visit(x);
5489 }
5490
5491 virtual void visit(SgAsmDwarfInheritance *x) {
5492 _strategy->visit(x);
5493 }
5494
5495 virtual void visit(SgAsmDwarfImportedUnit *x) {
5496 _strategy->visit(x);
5497 }
5498
5499 virtual void visit(SgAsmDwarfImportedModule *x) {
5500 _strategy->visit(x);
5501 }
5502
5503 virtual void visit(SgAsmDwarfImportedDeclaration *x) {
5504 _strategy->visit(x);
5505 }
5506
5507 virtual void visit(SgAsmDwarfFunctionTemplate *x) {
5508 _strategy->visit(x);
5509 }
5510
5511 virtual void visit(SgAsmDwarfFriend *x) {
5512 _strategy->visit(x);
5513 }
5514
5515 virtual void visit(SgAsmDwarfFormatLabel *x) {
5516 _strategy->visit(x);
5517 }
5518
5519 virtual void visit(SgAsmDwarfFormalParameter *x) {
5520 _strategy->visit(x);
5521 }
5522
5523 virtual void visit(SgAsmDwarfFileType *x) {
5524 _strategy->visit(x);
5525 }
5526
5527 virtual void visit(SgAsmDwarfEnumerator *x) {
5528 _strategy->visit(x);
5529 }
5530
5531 virtual void visit(SgAsmDwarfEnumerationType *x) {
5532 _strategy->visit(x);
5533 }
5534
5535 virtual void visit(SgAsmDwarfEntryPoint *x) {
5536 _strategy->visit(x);
5537 }
5538
5539 virtual void visit(SgAsmDwarfDwarfProcedure *x) {
5540 _strategy->visit(x);
5541 }
5542
5543 virtual void visit(SgAsmDwarfConstType *x) {
5544 _strategy->visit(x);
5545 }
5546
5547 virtual void visit(SgAsmDwarfConstructList *x) {
5548 _strategy->visit(x);
5549 }
5550
5551 virtual void visit(SgAsmDwarfConstant *x) {
5552 _strategy->visit(x);
5553 }
5554
5555 virtual void visit(SgAsmDwarfCondition *x) {
5556 _strategy->visit(x);
5557 }
5558
5559 virtual void visit(SgAsmDwarfCompilationUnitList *x) {
5560 _strategy->visit(x);
5561 }
5562
5563 virtual void visit(SgAsmDwarfCompilationUnit *x) {
5564 _strategy->visit(x);
5565 }
5566
5567 virtual void visit(SgAsmDwarfCommonInclusion *x) {
5568 _strategy->visit(x);
5569 }
5570
5571 virtual void visit(SgAsmDwarfCommonBlock *x) {
5572 _strategy->visit(x);
5573 }
5574
5575 virtual void visit(SgAsmDwarfClassType *x) {
5576 _strategy->visit(x);
5577 }
5578
5579 virtual void visit(SgAsmDwarfClassTemplate *x) {
5580 _strategy->visit(x);
5581 }
5582
5583 virtual void visit(SgAsmDwarfCatchBlock *x) {
5584 _strategy->visit(x);
5585 }
5586
5587 virtual void visit(SgAsmDwarfBaseType *x) {
5588 _strategy->visit(x);
5589 }
5590
5591 virtual void visit(SgAsmDwarfArrayType *x) {
5592 _strategy->visit(x);
5593 }
5594
5595 virtual void visit(SgAsmDwarfAccessDeclaration *x) {
5596 _strategy->visit(x);
5597 }
5598
5599 virtual void visit(SgAsmDwarfConstruct *x) {
5600 _strategy->visit(x);
5601 }
5602
5603 virtual void visit(SgAsmDwarfInformation *x) {
5604 _strategy->visit(x);
5605 }
5606
5607 virtual void visit(SgAsmDOSFileHeader *x) {
5608 _strategy->visit(x);
5609 }
5610
5611 virtual void visit(SgAsmGenericHeader *x) {
5612 _strategy->visit(x);
5613 }
5614
5615 virtual void visit(SgAsmDOSExtendedHeader *x) {
5616 _strategy->visit(x);
5617 }
5618
5619 virtual void visit(SgAsmDirectRegisterExpression *x) {
5620 _strategy->visit(x);
5621 }
5622
5623 virtual void visit(SgAsmRegisterReferenceExpression *x) {
5624 _strategy->visit(x);
5625 }
5626
5627 virtual void visit(SgAsmControlFlagsExpression *x) {
5628 _strategy->visit(x);
5629 }
5630
5631 virtual void visit(SgAsmConstantExpression *x) {
5632 _strategy->visit(x);
5633 }
5634
5635 virtual void visit(SgAsmValueExpression *x) {
5636 _strategy->visit(x);
5637 }
5638
5639 virtual void visit(SgAsmCommonSubExpression *x) {
5640 _strategy->visit(x);
5641 }
5642
5643 virtual void visit(SgAsmCoffSymbolTable *x) {
5644 _strategy->visit(x);
5645 }
5646
5647 virtual void visit(SgAsmCoffSymbolList *x) {
5648 _strategy->visit(x);
5649 }
5650
5651 virtual void visit(SgAsmCoffSymbol *x) {
5652 _strategy->visit(x);
5653 }
5654
5655 virtual void visit(SgAsmGenericSymbol *x) {
5656 _strategy->visit(x);
5657 }
5658
5659 virtual void visit(SgAsmCoffStrtab *x) {
5660 _strategy->visit(x);
5661 }
5662
5663 virtual void visit(SgAsmGenericStrtab *x) {
5664 _strategy->visit(x);
5665 }
5666
5667 virtual void visit(SgAsmCliHeader *x) {
5668 _strategy->visit(x);
5669 }
5670
5671 virtual void visit(SgAsmGenericSection *x) {
5672 _strategy->visit(x);
5673 }
5674
5675 virtual void visit(SgAsmCilUint8Heap *x) {
5676 _strategy->visit(x);
5677 }
5678
5679 virtual void visit(SgAsmCilUint32Heap *x) {
5680 _strategy->visit(x);
5681 }
5682
5683 virtual void visit(SgAsmCilTypeSpecTable *x) {
5684 _strategy->visit(x);
5685 }
5686
5687 virtual void visit(SgAsmCilTypeSpec *x) {
5688 _strategy->visit(x);
5689 }
5690
5691 virtual void visit(SgAsmCilTypeRefTable *x) {
5692 _strategy->visit(x);
5693 }
5694
5695 virtual void visit(SgAsmCilTypeRef *x) {
5696 _strategy->visit(x);
5697 }
5698
5699 virtual void visit(SgAsmCilTypeDefTable *x) {
5700 _strategy->visit(x);
5701 }
5702
5703 virtual void visit(SgAsmCilTypeDef *x) {
5704 _strategy->visit(x);
5705 }
5706
5707 virtual void visit(SgAsmCilStandAloneSigTable *x) {
5708 _strategy->visit(x);
5709 }
5710
5711 virtual void visit(SgAsmCilStandAloneSig *x) {
5712 _strategy->visit(x);
5713 }
5714
5715 virtual void visit(SgAsmCilPropertyTable *x) {
5716 _strategy->visit(x);
5717 }
5718
5719 virtual void visit(SgAsmCilPropertyMapTable *x) {
5720 _strategy->visit(x);
5721 }
5722
5723 virtual void visit(SgAsmCilPropertyMap *x) {
5724 _strategy->visit(x);
5725 }
5726
5727 virtual void visit(SgAsmCilProperty *x) {
5728 _strategy->visit(x);
5729 }
5730
5731 virtual void visit(SgAsmCilParamTable *x) {
5732 _strategy->visit(x);
5733 }
5734
5735 virtual void visit(SgAsmCilParam *x) {
5736 _strategy->visit(x);
5737 }
5738
5739 virtual void visit(SgAsmCilNestedClassTable *x) {
5740 _strategy->visit(x);
5741 }
5742
5743 virtual void visit(SgAsmCilNestedClass *x) {
5744 _strategy->visit(x);
5745 }
5746
5747 virtual void visit(SgAsmCilModuleTable *x) {
5748 _strategy->visit(x);
5749 }
5750
5751 virtual void visit(SgAsmCilModuleRefTable *x) {
5752 _strategy->visit(x);
5753 }
5754
5755 virtual void visit(SgAsmCilModuleRef *x) {
5756 _strategy->visit(x);
5757 }
5758
5759 virtual void visit(SgAsmCilModule *x) {
5760 _strategy->visit(x);
5761 }
5762
5763 virtual void visit(SgAsmCilMethodSpecTable *x) {
5764 _strategy->visit(x);
5765 }
5766
5767 virtual void visit(SgAsmCilMethodSpec *x) {
5768 _strategy->visit(x);
5769 }
5770
5771 virtual void visit(SgAsmCilMethodSemanticsTable *x) {
5772 _strategy->visit(x);
5773 }
5774
5775 virtual void visit(SgAsmCilMethodSemantics *x) {
5776 _strategy->visit(x);
5777 }
5778
5779 virtual void visit(SgAsmCilMethodImplTable *x) {
5780 _strategy->visit(x);
5781 }
5782
5783 virtual void visit(SgAsmCilMethodImpl *x) {
5784 _strategy->visit(x);
5785 }
5786
5787 virtual void visit(SgAsmCilMethodDefTable *x) {
5788 _strategy->visit(x);
5789 }
5790
5791 virtual void visit(SgAsmCilMethodDef *x) {
5792 _strategy->visit(x);
5793 }
5794
5795 virtual void visit(SgAsmCilMethodData *x) {
5796 _strategy->visit(x);
5797 }
5798
5799 virtual void visit(SgAsmCilMetadataRoot *x) {
5800 _strategy->visit(x);
5801 }
5802
5803 virtual void visit(SgAsmCilMetadataHeap *x) {
5804 _strategy->visit(x);
5805 }
5806
5807 virtual void visit(SgAsmCilMemberRefTable *x) {
5808 _strategy->visit(x);
5809 }
5810
5811 virtual void visit(SgAsmCilMemberRef *x) {
5812 _strategy->visit(x);
5813 }
5814
5815 virtual void visit(SgAsmCilManifestResourceTable *x) {
5816 _strategy->visit(x);
5817 }
5818
5819 virtual void visit(SgAsmCilManifestResource *x) {
5820 _strategy->visit(x);
5821 }
5822
5823 virtual void visit(SgAsmCilInterfaceImplTable *x) {
5824 _strategy->visit(x);
5825 }
5826
5827 virtual void visit(SgAsmCilInterfaceImpl *x) {
5828 _strategy->visit(x);
5829 }
5830
5831 virtual void visit(SgAsmCilInstruction *x) {
5832 _strategy->visit(x);
5833 }
5834
5835 virtual void visit(SgAsmCilImplMapTable *x) {
5836 _strategy->visit(x);
5837 }
5838
5839 virtual void visit(SgAsmCilImplMap *x) {
5840 _strategy->visit(x);
5841 }
5842
5843 virtual void visit(SgAsmCilGenericParamTable *x) {
5844 _strategy->visit(x);
5845 }
5846
5847 virtual void visit(SgAsmCilGenericParam *x) {
5848 _strategy->visit(x);
5849 }
5850
5851 virtual void visit(SgAsmCilGenericParamConstraintTable *x) {
5852 _strategy->visit(x);
5853 }
5854
5855 virtual void visit(SgAsmCilGenericParamConstraint *x) {
5856 _strategy->visit(x);
5857 }
5858
5859 virtual void visit(SgAsmCilFileTable *x) {
5860 _strategy->visit(x);
5861 }
5862
5863 virtual void visit(SgAsmCilFile *x) {
5864 _strategy->visit(x);
5865 }
5866
5867 virtual void visit(SgAsmCilFieldTable *x) {
5868 _strategy->visit(x);
5869 }
5870
5871 virtual void visit(SgAsmCilFieldRVATable *x) {
5872 _strategy->visit(x);
5873 }
5874
5875 virtual void visit(SgAsmCilFieldRVA *x) {
5876 _strategy->visit(x);
5877 }
5878
5879 virtual void visit(SgAsmCilFieldMarshalTable *x) {
5880 _strategy->visit(x);
5881 }
5882
5883 virtual void visit(SgAsmCilFieldMarshal *x) {
5884 _strategy->visit(x);
5885 }
5886
5887 virtual void visit(SgAsmCilFieldLayoutTable *x) {
5888 _strategy->visit(x);
5889 }
5890
5891 virtual void visit(SgAsmCilFieldLayout *x) {
5892 _strategy->visit(x);
5893 }
5894
5895 virtual void visit(SgAsmCilField *x) {
5896 _strategy->visit(x);
5897 }
5898
5899 virtual void visit(SgAsmCilExportedTypeTable *x) {
5900 _strategy->visit(x);
5901 }
5902
5903 virtual void visit(SgAsmCilExportedType *x) {
5904 _strategy->visit(x);
5905 }
5906
5907 virtual void visit(SgAsmCilExceptionData *x) {
5908 _strategy->visit(x);
5909 }
5910
5911 virtual void visit(SgAsmCilEventTable *x) {
5912 _strategy->visit(x);
5913 }
5914
5915 virtual void visit(SgAsmCilEventMapTable *x) {
5916 _strategy->visit(x);
5917 }
5918
5919 virtual void visit(SgAsmCilEventMap *x) {
5920 _strategy->visit(x);
5921 }
5922
5923 virtual void visit(SgAsmCilEvent *x) {
5924 _strategy->visit(x);
5925 }
5926
5927 virtual void visit(SgAsmCilDeclSecurityTable *x) {
5928 _strategy->visit(x);
5929 }
5930
5931 virtual void visit(SgAsmCilDeclSecurity *x) {
5932 _strategy->visit(x);
5933 }
5934
5935 virtual void visit(SgAsmCilDataStream *x) {
5936 _strategy->visit(x);
5937 }
5938
5939 virtual void visit(SgAsmCilCustomAttributeTable *x) {
5940 _strategy->visit(x);
5941 }
5942
5943 virtual void visit(SgAsmCilCustomAttribute *x) {
5944 _strategy->visit(x);
5945 }
5946
5947 virtual void visit(SgAsmCilConstantTable *x) {
5948 _strategy->visit(x);
5949 }
5950
5951 virtual void visit(SgAsmCilConstant *x) {
5952 _strategy->visit(x);
5953 }
5954
5955 virtual void visit(SgAsmCilClassLayoutTable *x) {
5956 _strategy->visit(x);
5957 }
5958
5959 virtual void visit(SgAsmCilClassLayout *x) {
5960 _strategy->visit(x);
5961 }
5962
5963 virtual void visit(SgAsmCilAssemblyTable *x) {
5964 _strategy->visit(x);
5965 }
5966
5967 virtual void visit(SgAsmCilAssemblyRefTable *x) {
5968 _strategy->visit(x);
5969 }
5970
5971 virtual void visit(SgAsmCilAssemblyRefProcessorTable *x) {
5972 _strategy->visit(x);
5973 }
5974
5975 virtual void visit(SgAsmCilAssemblyRefProcessor *x) {
5976 _strategy->visit(x);
5977 }
5978
5979 virtual void visit(SgAsmCilAssemblyRefOSTable *x) {
5980 _strategy->visit(x);
5981 }
5982
5983 virtual void visit(SgAsmCilAssemblyRefOS *x) {
5984 _strategy->visit(x);
5985 }
5986
5987 virtual void visit(SgAsmCilAssemblyRef *x) {
5988 _strategy->visit(x);
5989 }
5990
5991 virtual void visit(SgAsmCilAssemblyProcessorTable *x) {
5992 _strategy->visit(x);
5993 }
5994
5995 virtual void visit(SgAsmCilAssemblyProcessor *x) {
5996 _strategy->visit(x);
5997 }
5998
5999 virtual void visit(SgAsmCilAssemblyOSTable *x) {
6000 _strategy->visit(x);
6001 }
6002
6003 virtual void visit(SgAsmCilAssemblyOS *x) {
6004 _strategy->visit(x);
6005 }
6006
6007 virtual void visit(SgAsmCilAssembly *x) {
6008 _strategy->visit(x);
6009 }
6010
6011 virtual void visit(SgAsmCilMetadata *x) {
6012 _strategy->visit(x);
6013 }
6014
6015 virtual void visit(SgAsmCilNode *x) {
6016 _strategy->visit(x);
6017 }
6018
6019 virtual void visit(SgAsmByteOrder *x) {
6020 _strategy->visit(x);
6021 }
6022
6023 virtual void visit(SgAsmBlock *x) {
6024 _strategy->visit(x);
6025 }
6026
6027 virtual void visit(SgAsmBinarySubtract *x) {
6028 _strategy->visit(x);
6029 }
6030
6031 virtual void visit(SgAsmBinaryRor *x) {
6032 _strategy->visit(x);
6033 }
6034
6035 virtual void visit(SgAsmBinaryPreupdate *x) {
6036 _strategy->visit(x);
6037 }
6038
6039 virtual void visit(SgAsmBinaryPostupdate *x) {
6040 _strategy->visit(x);
6041 }
6042
6043 virtual void visit(SgAsmBinaryMultiply *x) {
6044 _strategy->visit(x);
6045 }
6046
6047 virtual void visit(SgAsmBinaryMsl *x) {
6048 _strategy->visit(x);
6049 }
6050
6051 virtual void visit(SgAsmBinaryMod *x) {
6052 _strategy->visit(x);
6053 }
6054
6055 virtual void visit(SgAsmBinaryLsr *x) {
6056 _strategy->visit(x);
6057 }
6058
6059 virtual void visit(SgAsmBinaryLsl *x) {
6060 _strategy->visit(x);
6061 }
6062
6063 virtual void visit(SgAsmBinaryDivide *x) {
6064 _strategy->visit(x);
6065 }
6066
6067 virtual void visit(SgAsmBinaryConcat *x) {
6068 _strategy->visit(x);
6069 }
6070
6071 virtual void visit(SgAsmBinaryAsr *x) {
6072 _strategy->visit(x);
6073 }
6074
6075 virtual void visit(SgAsmBinaryAdd *x) {
6076 _strategy->visit(x);
6077 }
6078
6079 virtual void visit(SgAsmBinaryExpression *x) {
6080 _strategy->visit(x);
6081 }
6082
6083 virtual void visit(SgAsmBasicString *x) {
6084 _strategy->visit(x);
6085 }
6086
6087 virtual void visit(SgAsmGenericString *x) {
6088 _strategy->visit(x);
6089 }
6090
6091 virtual void visit(SgAsmExecutableFileFormat *x) {
6092 _strategy->visit(x);
6093 }
6094
6095 virtual void visit(SgAsmInstruction *x) {
6096 _strategy->visit(x);
6097 }
6098
6099 virtual void visit(SgAsmStatement *x) {
6100 _strategy->visit(x);
6101 }
6102
6103 virtual void visit(SgAsmAarch32Coprocessor *x) {
6104 _strategy->visit(x);
6105 }
6106
6107 virtual void visit(SgAsmExpression *x) {
6108 _strategy->visit(x);
6109 }
6110
6111 virtual void visit(SgAsmNode *x) {
6112 _strategy->visit(x);
6113 }
6114
6115 virtual void visit(SgCommonBlockObject *x) {
6116 _strategy->visit(x);
6117 }
6118
6119 virtual void visit(SgInitializedName *x) {
6120 _strategy->visit(x);
6121 }
6122
6123 virtual void visit(SgLambdaCapture *x) {
6124 _strategy->visit(x);
6125 }
6126
6127 virtual void visit(SgLambdaCaptureList *x) {
6128 _strategy->visit(x);
6129 }
6130
6131 virtual void visit(SgJavaMemberValuePair *x) {
6132 _strategy->visit(x);
6133 }
6134
6135 virtual void visit(SgOmpOrderedClause *x) {
6136 _strategy->visit(x);
6137 }
6138
6139 virtual void visit(SgOmpNowaitClause *x) {
6140 _strategy->visit(x);
6141 }
6142
6143 virtual void visit(SgOmpBeginClause *x) {
6144 _strategy->visit(x);
6145 }
6146
6147 virtual void visit(SgOmpEndClause *x) {
6148 _strategy->visit(x);
6149 }
6150
6151 virtual void visit(SgOmpUntiedClause *x) {
6152 _strategy->visit(x);
6153 }
6154
6155 virtual void visit(SgOmpMergeableClause *x) {
6156 _strategy->visit(x);
6157 }
6158
6159 virtual void visit(SgOmpDefaultClause *x) {
6160 _strategy->visit(x);
6161 }
6162
6163 virtual void visit(SgOmpAtomicClause *x) {
6164 _strategy->visit(x);
6165 }
6166
6167 virtual void visit(SgOmpProcBindClause *x) {
6168 _strategy->visit(x);
6169 }
6170
6171 virtual void visit(SgOmpInbranchClause *x) {
6172 _strategy->visit(x);
6173 }
6174
6175 virtual void visit(SgOmpNotinbranchClause *x) {
6176 _strategy->visit(x);
6177 }
6178
6179 virtual void visit(SgOmpCollapseClause *x) {
6180 _strategy->visit(x);
6181 }
6182
6183 virtual void visit(SgOmpIfClause *x) {
6184 _strategy->visit(x);
6185 }
6186
6187 virtual void visit(SgOmpFinalClause *x) {
6188 _strategy->visit(x);
6189 }
6190
6191 virtual void visit(SgOmpPriorityClause *x) {
6192 _strategy->visit(x);
6193 }
6194
6195 virtual void visit(SgOmpNumThreadsClause *x) {
6196 _strategy->visit(x);
6197 }
6198
6199 virtual void visit(SgOmpDeviceClause *x) {
6200 _strategy->visit(x);
6201 }
6202
6203 virtual void visit(SgOmpSafelenClause *x) {
6204 _strategy->visit(x);
6205 }
6206
6207 virtual void visit(SgOmpSimdlenClause *x) {
6208 _strategy->visit(x);
6209 }
6210
6211 virtual void visit(SgOmpExpressionClause *x) {
6212 _strategy->visit(x);
6213 }
6214
6215 virtual void visit(SgOmpCopyprivateClause *x) {
6216 _strategy->visit(x);
6217 }
6218
6219 virtual void visit(SgOmpPrivateClause *x) {
6220 _strategy->visit(x);
6221 }
6222
6223 virtual void visit(SgOmpFirstprivateClause *x) {
6224 _strategy->visit(x);
6225 }
6226
6227 virtual void visit(SgOmpSharedClause *x) {
6228 _strategy->visit(x);
6229 }
6230
6231 virtual void visit(SgOmpCopyinClause *x) {
6232 _strategy->visit(x);
6233 }
6234
6235 virtual void visit(SgOmpLastprivateClause *x) {
6236 _strategy->visit(x);
6237 }
6238
6239 virtual void visit(SgOmpReductionClause *x) {
6240 _strategy->visit(x);
6241 }
6242
6243 virtual void visit(SgOmpDependClause *x) {
6244 _strategy->visit(x);
6245 }
6246
6247 virtual void visit(SgOmpMapClause *x) {
6248 _strategy->visit(x);
6249 }
6250
6251 virtual void visit(SgOmpLinearClause *x) {
6252 _strategy->visit(x);
6253 }
6254
6255 virtual void visit(SgOmpUniformClause *x) {
6256 _strategy->visit(x);
6257 }
6258
6259 virtual void visit(SgOmpAlignedClause *x) {
6260 _strategy->visit(x);
6261 }
6262
6263 virtual void visit(SgOmpVariablesClause *x) {
6264 _strategy->visit(x);
6265 }
6266
6267 virtual void visit(SgOmpScheduleClause *x) {
6268 _strategy->visit(x);
6269 }
6270
6271 virtual void visit(SgOmpClause *x) {
6272 _strategy->visit(x);
6273 }
6274
6275 virtual void visit(SgRenamePair *x) {
6276 _strategy->visit(x);
6277 }
6278
6279 virtual void visit(SgInterfaceBody *x) {
6280 _strategy->visit(x);
6281 }
6282
6283 virtual void visit(SgHeaderFileBody *x) {
6284 _strategy->visit(x);
6285 }
6286
6287 virtual void visit(SgAdaRangeConstraint *x) {
6288 _strategy->visit(x);
6289 }
6290
6291 virtual void visit(SgAdaIndexConstraint *x) {
6292 _strategy->visit(x);
6293 }
6294
6295 virtual void visit(SgAdaDigitsConstraint *x) {
6296 _strategy->visit(x);
6297 }
6298
6299 virtual void visit(SgAdaDeltaConstraint *x) {
6300 _strategy->visit(x);
6301 }
6302
6303 virtual void visit(SgAdaDiscriminantConstraint *x) {
6304 _strategy->visit(x);
6305 }
6306
6307 virtual void visit(SgAdaNullConstraint *x) {
6308 _strategy->visit(x);
6309 }
6310
6311 virtual void visit(SgAdaTypeConstraint *x) {
6312 _strategy->visit(x);
6313 }
6314
6315 virtual void visit(SgLocatedNodeSupport *x) {
6316 _strategy->visit(x);
6317 }
6318
6319 virtual void visit(SgToken *x) {
6320 _strategy->visit(x);
6321 }
6322
6323 virtual void visit(SgLocatedNode *x) {
6324 _strategy->visit(x);
6325 }
6326
6327 virtual void visit(SgNode *x) {
6328 _strategy->visit(x);
6329 }
6330};
6331
6332#endif // SWIG
6333#endif // include-once
Strategy pattern applied to visitors.
void setStrategy(ROSE_VisitorPattern *strategy)
Allows the strategy to be set dynamically.
ROSE_VisitorPattern * _strategy
Strategy to process a node, can be set dynamically.
Operand referencing a Co-processor.
String associated with a binary file.
Expression that adds two operands.
Expression that performs an arithmetic, sign-bit preserving right shift.
Expression that concatenates two values to form a wider value.
Expression that divides the first operand by the second.
Base class for binary expressions.
Expression that performs a logical left shift operation.
Expression that performs a logical, sign-bit non-preserving right shift.
Expression that returns the remainder when dividing the first operand by the second.
Expression that performs a logical left shift operation filling low-order bits with one.
Expression that multiplies two operands.
Expression that represents an update to a storage location.
Expression that represents an update to a storage location.
Expression that performs a right rotate.
Expression that subtracts the second operand from the first.
Instruction basic block.
Byte order specification.
CIL AssemblyOS tables.
CIL AssemblyOS node (II.22.3).
CIL AssemblyProcessor tables.
CIL AssemblyProcessor node (II.22.4).
CIL AssemblyRefOS tables.
CIL AssemblyRefOS node (II.22.6).
CIL AssemblyRefProcessor tables.
CIL AssemblyRefProcessor node (II.22.7).
CIL AssemblyRef tables.
CIL AssemblyRef node (II.22.5).
CIL Assembly tables.
CIL Assembly node (II.22.2).
CIL ClassLayout tables.
CIL ClassLayout node (II.22.8).
CIL Constant tables.
CIL Constant node (II.22.9).
CIL CustomAttribute tables.
CIL CustomAttribute node (II.22.10).
Base class for CIL branch of binary analysis IR nodes.
CIL DeclSecurity tables.
CIL DeclSecurity node (II.22.11).
CIL EventMap tables.
CIL EventMap node (II.22.12).
CIL Event node (II.22.13).
Property class representing CIL Exception clauses (II.25.4.6).
CIL ExportedType tables.
CIL ExportedType node (II.22.14).
CIL FieldLayout tables.
CIL FieldLayout node (II.22.16).
CIL FieldMarshal tables.
CIL FieldMarshal node (II.22.17).
CIL FieldRVA tables.
CIL FieldRVA node (II.22.18).
CIL Field node (II.22.15).
CIL File node (II.22.19).
CIL GenericParamConstraint tables.
CIL GenericParamConstraint node (II.22.21).
CIL GenericParam tables.
CIL GenericParam node (II.22.20).
CIL ImplMap tables.
CIL ImplMap node (II.22.22).
CIL InterfaceImpl tables.
CIL InterfaceImpl node (II.22.23).
CIL ManifestResource tables.
CIL ManifestResource node (II.22.24).
CIL MemberRef tables.
CIL MemberRef node (II.22.25).
CIL SgAsmCilMetadataHeap node.
CIL SgAsmCilMetadataRoot.
Base class for CIL branch of binary analysis IR nodes.
Property class representing CIL Extra Sections (II.25.4.5).
CIL MethodDef tables.
CIL MethodDef node (II.22.26).
CIL MethodImpl tables.
CIL MethodImpl node (II.22.27).
CIL MethodSemantics tables.
CIL MethodSemantics node (II.22.28).
CIL MethodSpec tables.
CIL MethodSpec node (II.22.29).
CIL ModuleRef tables.
CIL ModuleRef node (II.22.31).
CIL Module node (II.22.30).
CIL NestedClass tables.
CIL NestedClass node (II.22.32).
Base class for CIL branch of binary analysis IR nodes.
CIL Param node (II.22.33).
CIL PropertyMap tables.
CIL PropertyMap node (II.22.35).
CIL Property tables.
CIL Property node (II.22.34).
CIL StandAloneSig tables.
CIL StandAloneSig node (II.22.36).
CIL TypeDef tables.
CIL TypeDef node (II.22.37).
CIL TypeRef tables.
CIL TypeRef node (II.22.38).
CIL TypeSpec tables.
CIL TypeSpec node (II.22.39).
Base class for CIL branch of binary analysis IR nodes.
Base class for CIL branch of binary analysis IR nodes.
CIL Managed Code section.
COFF symbol string table.
List of COFF symbols.
Base class for constants.
Represents the file header for DOS executables.
Expression representing a machine register.
List of dynamic linking section entries.
One entry from the dynamic linking table.
ELF section containing dynamic linking information.
List of ELF EH frame CI entries.
ELF error handling frame entry, common information entry.
List of ELF error handling frame descriptor entries.
ELF error handling frame entry frame description entry.
Represents an ELF EH frame section.
Represents the file header of an ELF binary container.
Node to hold list of ELF note entries.
One entry of an ELF notes table.
List of ELF relocation entries.
One entry of an ELF relocation table.
Represents an ELF relocation section.
Represents one entry in an ELF section table.
Represents an ELF section table.
Base class for ELF file sections.
Represents one entry of a segment table.
Represents an ELF segment table.
ELF string table section.
ELF string table.
ELF file section containing symbols.
Represents a single ELF symbol.
List of symbol version aux entries.
Auxiliary data for an ELF Symbol Version.
List of entries for the ELF symbol version definition table.
One entry from an ELF symbol version definition table.
The GNU symbol version definitions.
List of entries from a symbol version table.
Entry in an ELF symbol version table.
Hods a list of symbol version aux entries.
Auxiliary info for needed symbol version.
List of symbol version needed entries.
One entry of the ELF symbol version needed table.
GNU symbol version requirements table.
The ELF symbol version table.
Base class for many binary analysis nodes.
List of expression nodes.
Base class for expressions.
Floating point types.
Represents a synthesized function.
List of pointers to other nodes.
Base class for dynamically linked library information.
List of AST file node pointers.
Base class for binary files.
Basic information about an executable container.
List of generic file headers.
Base class for container file headers.
List of pointers to file sections.
Contiguous region of a file.
Base class for strings related to binary specimens.
Base class for string tables.
Node to hold a list of symbol node pointers.
Registers accessed indirectly.
List of SgAsmInstruction nodes.
Base class for machine instructions.
Base class for integer values.
Represents an interpretation of a binary container.
Represents a JVM attribute_info table/array.
Base class for a JVM attribute.
The BootstrapMethods attribute is a variable-length attribute in the attributes table of a ClassFile ...
Represents an entry in a JVM constant pool.
Represents an JVM constant pool.
JVM ConstantValue attribute.
JVM EnclosingMethod attribute.
Represents a JVM exception_info table/array.
JVM Exceptions attribute.
Represents a JVM field_info table/array.
Represents the file header of an JVM binary container.
A JVM InnerClasses attribute array entry.
Represents a JVM InnerClasses attribute.
Represents one JVS machine instruction.
JVM LineNumberTable attribute.
JVM LocalVariableEntry.
JVM LocalVariableTable attribute.
JVM LocalVariableTypeEntry.
JVM LocalVariableTypeTable attribute.
JVM MethodParametersEntry.
JVM MethodParameters attribute.
Represents a JVM method_info table/array.
JVM ModuleMainClass attribute.
JVM NestHost attribute.
JVM NestMembers attribute.
Base class for JVM branch of binary analysis IR nodes.
JVM Signature attribute.
JVM SourceFile attribute.
Represents a frame in a stack map table.
The StackMapTable attribute is a variable-length attribute in the attributes table of a Code attribut...
Represents an entry in a stack map table.
Reference to memory locations.
Represents one MIPS machine instruction.
Base class for all binary analysis IR nodes.
List of operands for an instruction.
List of pointers to other AST nodes.
Export file section.
Windows PE file header.
A list of PE Import Directories.
One import directory per library.
A list of imported items.
A single imported object.
Portable Executable Import Section.
List of SgAsmPERVASizePair AST nodes.
Base class for PE sections.
Represents one PowerPC machine instruction.
An ordered list of registers.
Base class for references to a machine register.
Static representation of instruction semantics.
Base class for scalar types.
Base class for references to a machine register.
Base class for statement-like subclasses.
Represents static data in an executable.
This class represents the concept of a C Assembler statement.
Strings stored in an ELF or PE container.
Strings stored in an ELF or PE container.
Declaration-like nodes that encapsulate multiple instructions.
Base class for synthesized declarations.
Base class for binary types.
Base class for unary expressions.
Expression represting negation.
Expression representing a (no-op) unary plus operation.
Expression representing sign extending.
Expression representing truncation.
Expression representing unsigned extending.
Instructions defined at runtime.
Base class for values.
Base class for vector types.
A type that doesn't represent any data.
Represents one Intel x86 machine instruction.
This class represents the rhs of a variable declaration which includes an optional assignment (e....
This class represents the concept of a block (not a basic block from control flow analysis).
This class represents the notion of a binary operator. It is derived from a SgExpression because oper...
This class represents a boolean value (expression value).
This class represents the notion of a break statement (typically used in a switch statment).
This class represents the concept of a generic call expression.
This class represents the concept of a C and C++ case option (used within a switch statement).
This class represents a cast of one type to another.
This class represents the concept of a catch within a try-catch construct used in C++ exception handl...
This class represents the concept of a C++ sequence of catch statements.
This class represents the concept of a class declaration statement. It includes the concept of an ins...
This class represents the concept of a class definition in C++.
This class represents the concept of a C++ expression built from a class name.
This class represents the concept of a class name within the compiler.
This class represents the concept of a C style extern "C" declaration. But such information (linkage)...
This class represents the concept of a C trinary conditional expression (e.g. "test ?...
This class represents the call of a class constructor to initialize a variable. For example "Foo foo;...
This class represents the concept of a C or C++ continue statement.
This class represents the concept of a contructor initializer list (used in constructor (member funct...
This class represents modifiers for SgDeclaration (declaration statements).
This class represents the concept of a declaration statement.
This class represents the concept of a C or C++ default case within a switch statement.
This class represents the concept of a C++ call to the delete operator.
This class represents a directory within a projects file structure of files and directories.
This class represents the concept of a do-while statement.
This class represents the notion of an value (expression value).
This class represents the concept of an enum declaration.
This class represents the concept of the dynamic execution of a string, file, or code object....
This class represents the concept of a C and C++ expression list.
This class represents the concept of a C or C++ statement which contains a expression.
This class represents the notion of an expression. Expressions are derived from SgLocatedNodes,...
This class represents a source file for a project (which may contian many source files and or directo...
This class represents the notion of an value (expression value).
This class represents the variable declaration or variable initialization withn a for loop.
This class represents the concept of a for loop.
This class represents the concept of a C++ function call (which is an expression).
This class represents the concept of a function declaration statement.
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope,...
This class represents the concept of a declaration list.
This class represents the function being called and must be assembled in the SgFunctionCall with the ...
This class represents the concept of a name and a type. It may be renamed in the future to SgTypeSymb...
This class represents the function type table (stores all function types so that they can be shared i...
This class represents a type for all functions.
This class represents the concept of a namespace definition.
This class represents the concept of a C or C++ goto statement.
This class represents the concept of an "if" construct.
This class represents the notion of a declared variable.
This class represents the notion of an initializer for a variable declaration or expression in a func...
This class represents the physical disequality (often called pointer disequality) operator for langua...
This class represents the physical equality (often called pointer equality) operator for languages th...
This class represents the concept of a C or C++ label statement.
This class represents a lambda expression.
This class represents a list display.
This class represents the notion of an expression or statement which has a position within the source...
This class represents the notion of an value (expression value).
This class represents the concept of a member function declaration statement.
This class represents the member function being called and must be assembled in the SgFunctionCall wi...
This class represents the numeric negation of a value. Not to be confused with SgSubtractOp.
This class is not used in ROSE, but is intended to represent a list of SgModifierTypes (similar to th...
This class represents the base class of a number of IR nodes define modifiers within the C++ grammar.
This class represents strings within the IR nodes.
This class represents the concept of a C++ namespace alias declaration statement.
This class represents the concept of a C++ namespace declaration.
This class represents the concept of a namespace definition.
This class represents the concept of a namespace name within the compiler.
This class represents the notion of an n-ary boolean operation. This node is intended for use with Py...
This class represents the notion of an n-ary comparison operation. This node is intended for use with...
This class represents the notion of an n-ary operator. This node is intended for use with Python.
This class represents the concept of a C++ call to the new operator.
This class represents the base class for all IR nodes within Sage III.
This class represents an object used to initialize the unparsing.
This class represents a Fortran pointer assignment. It is not some weird compound assignment operator...
This class represents the concept of a C Assembler statement (untested).
This class represents a source project, with a list of SgFile objects and global information about th...
This class represents the concept of a 'global' stmt in Python.
This class represents a OLD concept of the structure require for qualified names when they were in th...
This class represents a OLD concept of the structure require for qualified names when they were in th...
This class represents the "&" operator (applied to any lvalue).
This class represents the concept of a C Assembler statement (untested).
This class was part of CC++ support from a long time ago.
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope,...
This class represents the "sizeof()" operator (applied to any type).
This class is part of the older CC++ concept. It is not a part of C or C++ (this IR node is not used ...
This class represents the GNU extension "statement expression" (thus is non-standard C and C++).
This class represents the notion of a statement.
This class is intended to be a wrapper around SgStatements, allowing them to exist in scopes that onl...
This class represents modifiers specific to storage.
This class represents the conversion of an arbitrary expression to a string. This node is intended fo...
This class represents the base class of a numbr of IR nodes that don't otherwise fit into the existin...
This class represents the concept of a switch.
This class represents the symbol tables used in both SgScopeStatement and the SgFunctionTypeSymbolTab...
This class represents the concept of a name within the compiler.
This class represents template argument within the use of a template to build an instantiation.
This class represents the concept of a template declaration.
This class represents the concept of an instantiated class template.
This class represents the concept of a class definition in C++.
This class represents the concept of a C++ template instantiation directive.
This class represents the concept of an instantiation of function template.
This class represents the concept of an instantiation of member function template or a member functio...
This class represents the "this" operator (can be applied to any member data).
This class represents the C++ throw expression (handled as a unary operator).
This class represents the concept of try statement within the try-catch support for exception handlin...
This class represents a tuple display.
This class represents a C99 complex type.
This class represents a default type used for some IR nodes (see below).
This class represents a C99 complex type.
This class represents a string type used for SgStringVal IR node.
This class represents the base class for all types.
This class represents the notion of a typedef declaration.
This class represents a list of associated typedefs for the SgType IR nodes which reference this list...
This class represents the notion of a unary operator. It is derived from a SgExpression because opera...
This class represents the concept of a C++ using declaration.
This class represents the concept of a C++ using directive.
This class represents the notion of an value (expression value).
This class represents the variable refernece in expressions.
This class represents the concept of a C or C++ variable declaration.
This class represents the definition (initialization) of a variable.
This class represents the concept of a variable name within the compiler (a shared container for the ...
This class represents the concept of a do-while statement.
This class represents the location of the code associated with the IR node in the original source cod...
virtual R & getResult()
Return the result of the visitor's computation.
R _result
Result of a visit method.
virtual const R & getResult() const
Return the result of the visitor's computation.