ROSE  0.11.2.0
sageGeneric.h
Go to the documentation of this file.
1 #ifndef _SAGEGENERIC_H
2 
3 #define _SAGEGENERIC_H 1
4 
11 
12 // note: the comments are right aligned to support code-blocks doxygen 1.3.X :)
13 
14 #include <stdexcept>
15 
16 #if __cplusplus >= 201103L
17 #include <type_traits>
18 #endif
19 
20 #if !defined(NDEBUG)
21 #include <typeinfo>
22 #include <iostream>
23 #include <sstream>
24 #endif /* NDEBUG */
25 
26 
27 #define WITH_BINARY_ANALYSIS 0
28 
29 // #include "Cxx_Grammar.h"
30 
31 // DQ (10/5/2014): We can't include this here.
32 // #include "rose.h"
33 
34 #define SG_UNEXPECTED_NODE(X) (sg::unexpected_node(X, __FILE__, __LINE__))
35 #define SG_DEREF(X) (sg::deref(X, __FILE__, __LINE__))
36 #define SG_ASSERT_TYPE(SAGENODE, N) (sg::assert_sage_type<SAGENODE>(N, __FILE__, __LINE__))
37 #define SG_ERROR_IF(COND, MSG) (sg::report_error_if(COND, MSG, __FILE__, __LINE__))
38 
39 namespace sg
40 {
41  //
42  // non sage specific utilities
43 
46  template <class T>
47  static inline
48  void unused(const T&) {}
49 
51  template <class T1, class T2>
52  struct ConstLike
53  {
54  typedef T2 type;
55  };
56 
57  template <class T1, class T2>
58  struct ConstLike<const T1, T2>
59  {
60  typedef const T2 type;
61  };
62 
63  //
64  // error reporting
65 
67  template <class T, class E>
68  static inline
69  T conv(const E& el)
70  {
71  T res;
72 #if !defined(NDEBUG)
73  std::stringstream s;
74 
75  s << el;
76  s >> res;
77 #endif /* NDEBUG */
78  return res;
79  }
80 
81  static inline
82  void report_error(std::string desc, const char* file = 0, size_t ln = 0)
83  {
84  if (file)
85  {
86  const std::string at(" at ");
87  const std::string sep(" : ");
88  const std::string num(conv<std::string>(ln));
89 
90  desc = desc + at + file + sep + num;
91  }
92 
93  std::cerr << desc << std::endl;
94  throw std::logic_error(desc);
95  }
96 
97  static inline
98  void report_error_if(bool iserror, const std::string& desc, const char* file = 0, size_t ln = 0)
99  {
100  if (!iserror) return;
101 
102  report_error(desc, file, ln);
103  }
104 
106  template <class T>
107  T& deref(T* ptr, const char* file = 0, size_t ln = 0)
108  {
109  report_error_if(!ptr, "null dereference ", file, ln);
110  return *ptr;
111  }
112 
113  static inline
114  void unexpected_node(const SgNode& n, const char* file = 0, size_t ln = 0)
115  {
116  static const std::string msg = "unexpected node-type: ";
117 
118  report_error(msg + typeid(n).name(), file, ln);
119  }
120 
131  template <class _ReturnType>
133  {
134  typedef _ReturnType ReturnType;
136 
138  : res()
139  {}
140 
141  explicit
142  DispatchHandler(const ReturnType& defaultval)
143  : res(defaultval)
144  {}
145 
146  operator ReturnType() const { return res; }
147 
148  protected:
149  ReturnType res;
150  };
151 
152 
153  //
154  // Sage query functions
155 
157  template <class SageNode>
158  static inline
159  SageNode& assume_sage_type(SgNode& n)
160  {
161  return static_cast<SageNode&>(n);
162  }
163 
166  template <class SageNode>
167  static inline
168  const SageNode& assume_sage_type(const SgNode& n)
169  {
170  return static_cast<const SageNode&>(n);
171  }
172 
173 #define GEN_VISIT(X) \
174  void visit(X * n) { rv.handle(*n); }
175 
176  template <class RoseVisitor>
178  {
179 
180 #if __cplusplus >= 201103L
181  // rvalue ctor
182  VisitDispatcher(RoseVisitor&& rosevisitor, std::false_type)
183  : rv(std::move(rosevisitor))
184  {}
185 
186  // lvalue ctor
187  VisitDispatcher(const RoseVisitor& rosevisitor, std::true_type)
188  : rv(rosevisitor)
189  {}
190 #else
191  explicit
192  VisitDispatcher(const RoseVisitor& rosevisitor)
193  : rv(rosevisitor)
194  {}
195 #endif
196 
197  GEN_VISIT(SgAccessModifier)
198  GEN_VISIT(SgActualArgumentExpression)
199  GEN_VISIT(SgAbsOp)
200  GEN_VISIT(SgAdaAccessType)
201  GEN_VISIT(SgAdaAcceptStmt)
202  GEN_VISIT(SgAdaEntryDecl)
203  GEN_VISIT(SgAdaExitStmt)
204  GEN_VISIT(SgAdaFloatType)
205  GEN_VISIT(SgAdaFloatVal)
206  GEN_VISIT(SgAdaLoopStmt)
207  GEN_VISIT(SgAdaPackageBody)
208  GEN_VISIT(SgAdaPackageBodyDecl)
209  GEN_VISIT(SgAdaPackageSpec)
210  GEN_VISIT(SgAdaPackageSpecDecl)
211  GEN_VISIT(SgAdaPackageSymbol)
212  GEN_VISIT(SgAdaRangeConstraint)
213  GEN_VISIT(SgAdaRenamingDecl)
214  GEN_VISIT(SgAdaSubtype)
215  GEN_VISIT(SgAdaTaskBody)
216  GEN_VISIT(SgAdaTaskBodyDecl)
217  GEN_VISIT(SgAdaTaskSpec)
218  GEN_VISIT(SgAdaTaskSpecDecl)
219  GEN_VISIT(SgAdaTaskRefExp)
220  GEN_VISIT(SgAdaTaskType)
221  GEN_VISIT(SgAdaTaskTypeDecl)
222  GEN_VISIT(SgAdaTypeConstraint)
223  GEN_VISIT(SgAddOp)
224  GEN_VISIT(SgAddressOfOp)
225  GEN_VISIT(SgAggregateInitializer)
226  GEN_VISIT(SgAliasSymbol)
227  GEN_VISIT(SgAllocateStatement)
228  GEN_VISIT(SgAndAssignOp)
229  GEN_VISIT(SgAndOp)
230  GEN_VISIT(SgArithmeticIfStatement)
231  GEN_VISIT(SgArrayType)
232  GEN_VISIT(SgArrowExp)
233  GEN_VISIT(SgArrowStarOp)
234  GEN_VISIT(SgAssertStmt)
235  GEN_VISIT(SgAssignInitializer)
236  GEN_VISIT(SgAssignOp)
237  GEN_VISIT(SgAssignStatement)
238  GEN_VISIT(SgAssignedGotoStatement)
239  GEN_VISIT(SgAssociateStatement)
240  GEN_VISIT(SgAsteriskShapeExp)
241  GEN_VISIT(SgAttribute)
243  GEN_VISIT(SgAutoType)
244  GEN_VISIT(SgBackspaceStatement)
245  GEN_VISIT(SgBaseClass)
246  GEN_VISIT(SgExpBaseClass)
247  GEN_VISIT(SgBaseClassModifier)
248  GEN_VISIT(SgBasicBlock)
249  GEN_VISIT(SgBidirectionalGraph)
250  GEN_VISIT(SgBinaryOp)
251  GEN_VISIT(SgBitAndOp)
252  GEN_VISIT(SgBitAttribute)
253  GEN_VISIT(SgBitComplementOp)
254  GEN_VISIT(SgBitEqvOp)
255  GEN_VISIT(SgBitOrOp)
256  GEN_VISIT(SgBitXorOp)
257  GEN_VISIT(SgBlockDataStatement)
258  GEN_VISIT(SgBoolValExp)
259  GEN_VISIT(SgBreakStmt)
260  GEN_VISIT(SgBracedInitializer)
262  GEN_VISIT(SgCaseOptionStmt)
263  GEN_VISIT(SgCastExp)
264  GEN_VISIT(SgCatchOptionStmt)
265  GEN_VISIT(SgCatchStatementSeq)
266  GEN_VISIT(SgCharVal)
267  GEN_VISIT(SgChar16Val)
268  GEN_VISIT(SgChar32Val)
269  GEN_VISIT(SgClassDecl_attr)
270  GEN_VISIT(SgClassDeclaration)
271  GEN_VISIT(SgClassDefinition)
272  GEN_VISIT(SgClassNameRefExp)
273  GEN_VISIT(SgClassSymbol)
274  GEN_VISIT(SgClassType)
276  GEN_VISIT(SgClinkageEndStatement)
277  GEN_VISIT(SgClinkageStartStatement)
278  GEN_VISIT(SgCloseStatement)
279  GEN_VISIT(SgColonShapeExp)
280  GEN_VISIT(SgCommaOpExp)
281  GEN_VISIT(SgCommonBlock)
282  GEN_VISIT(SgCommonBlockObject)
283  GEN_VISIT(SgCommonSymbol)
284  GEN_VISIT(SgComplexVal)
285  GEN_VISIT(SgComprehension)
286  GEN_VISIT(SgCompoundAssignOp)
287  GEN_VISIT(SgCompoundInitializer)
288  GEN_VISIT(SgCompoundLiteralExp)
289  GEN_VISIT(SgComputedGotoStatement)
290  GEN_VISIT(SgConcatenationOp)
291  GEN_VISIT(SgConditionalExp)
292  GEN_VISIT(SgConjugateOp)
293  GEN_VISIT(SgConstVolatileModifier)
294  GEN_VISIT(SgConstructorInitializer)
295  GEN_VISIT(SgContainsStatement)
296  GEN_VISIT(SgContinueStmt)
297  GEN_VISIT(SgCtorInitializerList)
298  GEN_VISIT(SgDataStatementGroup)
299  GEN_VISIT(SgDataStatementObject)
300  GEN_VISIT(SgDataStatementValue)
301  GEN_VISIT(SgDeadIfDirectiveStatement)
302  GEN_VISIT(SgDeallocateStatement)
303  GEN_VISIT(SgDeclarationModifier)
304  GEN_VISIT(SgDeclarationScope)
305  GEN_VISIT(SgDeclarationStatement)
306  GEN_VISIT(SgDeclType)
307  GEN_VISIT(SgDefaultOptionStmt)
308  GEN_VISIT(SgDefaultSymbol)
309  GEN_VISIT(SgDefineDirectiveStatement)
310  GEN_VISIT(SgDeleteExp)
311  GEN_VISIT(SgDerivedTypeStatement)
312  GEN_VISIT(SgDesignatedInitializer)
313  GEN_VISIT(SgDictionaryComprehension)
314  GEN_VISIT(SgDictionaryExp)
315  GEN_VISIT(SgDimensionObject)
316  GEN_VISIT(SgDirectory)
317  GEN_VISIT(SgDirectoryList)
318  GEN_VISIT(SgDivAssignOp)
319  GEN_VISIT(SgDivideOp)
320  GEN_VISIT(SgDoWhileStmt)
321  GEN_VISIT(SgDotExp)
322  GEN_VISIT(SgDotStarOp)
323  GEN_VISIT(SgDoubleVal)
324  GEN_VISIT(SgElaboratedTypeModifier)
325  GEN_VISIT(SgElementwiseOp)
326  GEN_VISIT(SgElementwiseAddOp)
327  GEN_VISIT(SgElementwiseDivideOp)
328  GEN_VISIT(SgElementwiseLeftDivideOp)
329  GEN_VISIT(SgElementwiseMultiplyOp)
330  GEN_VISIT(SgElementwisePowerOp)
331  GEN_VISIT(SgElementwiseSubtractOp)
332  GEN_VISIT(SgElseDirectiveStatement)
333  GEN_VISIT(SgElseWhereStatement)
334  GEN_VISIT(SgElseifDirectiveStatement)
335  GEN_VISIT(SgEmptyDeclaration)
336  GEN_VISIT(SgEmptyDirectiveStatement)
337  GEN_VISIT(SgEndfileStatement)
338  GEN_VISIT(SgEndifDirectiveStatement)
339  GEN_VISIT(SgEntryStatement)
340  GEN_VISIT(SgEnumDeclaration)
341  GEN_VISIT(SgEnumFieldSymbol)
342  GEN_VISIT(SgEnumSymbol)
343  GEN_VISIT(SgEnumType)
344  GEN_VISIT(SgEnumVal)
345  GEN_VISIT(SgEqualityOp)
346  GEN_VISIT(SgEquivalenceStatement)
347  GEN_VISIT(SgErrorDirectiveStatement)
348  GEN_VISIT(SgExecStatement)
349  GEN_VISIT(SgExponentiationOp)
350  GEN_VISIT(SgExponentiationAssignOp)
351  GEN_VISIT(SgExprListExp)
352  GEN_VISIT(SgExprStatement)
353  GEN_VISIT(SgExpression)
354  GEN_VISIT(SgExpressionRoot)
355  GEN_VISIT(SgFile)
356  GEN_VISIT(SgFileList)
357  GEN_VISIT(SgFloatVal)
358  GEN_VISIT(SgFloat128Val)
359  GEN_VISIT(SgFloat80Val)
360  GEN_VISIT(SgFlushStatement)
361  GEN_VISIT(SgForAllStatement)
362  GEN_VISIT(SgForInitStatement)
363  GEN_VISIT(SgForStatement)
364  GEN_VISIT(SgFormatItem)
365  GEN_VISIT(SgFormatItemList)
366  GEN_VISIT(SgFormatStatement)
367  GEN_VISIT(SgFortranDo)
368  GEN_VISIT(SgFortranIncludeLine)
369  GEN_VISIT(SgFortranNonblockedDo)
370  GEN_VISIT(SgFuncDecl_attr)
371  GEN_VISIT(SgFunctionCallExp)
372  GEN_VISIT(SgFunctionDeclaration)
373  GEN_VISIT(SgFunctionDefinition)
374  GEN_VISIT(SgFunctionParameterScope)
375  GEN_VISIT(SgFunctionModifier)
376  GEN_VISIT(SgFunctionParameterList)
377  GEN_VISIT(SgFunctionParameterRefExp)
378  GEN_VISIT(SgFunctionParameterTypeList)
379  GEN_VISIT(SgFunctionRefExp)
380  GEN_VISIT(SgFunctionSymbol)
381  GEN_VISIT(SgFunctionType)
382  GEN_VISIT(SgFunctionTypeSymbol)
383  GEN_VISIT(SgFunctionTypeTable)
384  GEN_VISIT(SgTypeTable)
385  GEN_VISIT(SgGlobal)
386  GEN_VISIT(SgGotoStatement)
387  GEN_VISIT(SgGraph)
388  GEN_VISIT(SgGraphEdge)
389  GEN_VISIT(SgGraphEdgeList)
390  GEN_VISIT(SgGraphNode)
391  GEN_VISIT(SgGraphNodeList)
392  GEN_VISIT(SgGreaterOrEqualOp)
393  GEN_VISIT(SgGreaterThanOp)
394  GEN_VISIT(SgIOItemExpression)
395  GEN_VISIT(SgIOStatement)
396  GEN_VISIT(SgIdentDirectiveStatement)
397  GEN_VISIT(SgIfDirectiveStatement)
398  GEN_VISIT(SgIfStmt)
399  GEN_VISIT(SgIfdefDirectiveStatement)
400  GEN_VISIT(SgIfndefDirectiveStatement)
401  GEN_VISIT(SgImageControlStatement)
402  GEN_VISIT(SgImagPartOp)
403  GEN_VISIT(SgImplicitStatement)
404  GEN_VISIT(SgImpliedDo)
405  GEN_VISIT(SgImportStatement)
406  GEN_VISIT(SgIncidenceDirectedGraph)
407  GEN_VISIT(SgIncidenceUndirectedGraph)
408  GEN_VISIT(SgIncludeDirectiveStatement)
409  GEN_VISIT(SgIncludeFile)
411  GEN_VISIT(SgInitializedName)
412  GEN_VISIT(SgInitializer)
413  GEN_VISIT(SgInquireStatement)
415  GEN_VISIT(SgIntVal)
416  GEN_VISIT(SgIntegerDivideOp)
417  GEN_VISIT(SgIntegerDivideAssignOp)
418  GEN_VISIT(SgInterfaceBody)
419  GEN_VISIT(SgHeaderFileBody)
420  GEN_VISIT(SgHeaderFileReport)
421  GEN_VISIT(SgInterfaceStatement)
422  GEN_VISIT(SgInterfaceSymbol)
423  GEN_VISIT(SgIntrinsicSymbol)
424  GEN_VISIT(SgIsOp)
425  GEN_VISIT(SgIsNotOp)
426  GEN_VISIT(SgIorAssignOp)
427  GEN_VISIT(SgJovialBitType)
428  GEN_VISIT(SgJovialTableType)
429  GEN_VISIT(SgJovialCompoolStatement)
430  GEN_VISIT(SgJovialForThenStatement)
431  GEN_VISIT(SgJovialDefineDeclaration)
432  GEN_VISIT(SgJovialDirectiveStatement)
433  GEN_VISIT(SgJovialOverlayDeclaration)
434  GEN_VISIT(SgJovialTableStatement)
435  GEN_VISIT(SgKeyDatumPair)
436  GEN_VISIT(SgCudaKernelExecConfig)
437  GEN_VISIT(SgCudaKernelCallExp)
438  GEN_VISIT(SgLabelRefExp)
439  GEN_VISIT(SgLabelStatement)
440  GEN_VISIT(SgJavaLabelStatement)
441  GEN_VISIT(SgLabelSymbol)
442  GEN_VISIT(SgJavaLabelSymbol)
443  GEN_VISIT(SgLambdaCapture)
444  GEN_VISIT(SgLambdaCaptureList)
445  GEN_VISIT(SgLambdaExp)
446  GEN_VISIT(SgLambdaRefExp)
447  GEN_VISIT(SgLeftDivideOp)
448  GEN_VISIT(SgLessOrEqualOp)
449  GEN_VISIT(SgLessThanOp)
450  GEN_VISIT(SgLineDirectiveStatement)
452  GEN_VISIT(SgLinkageModifier)
453  GEN_VISIT(SgListComprehension)
454  GEN_VISIT(SgListExp)
455  GEN_VISIT(SgLocatedNode)
456  GEN_VISIT(SgLocatedNodeSupport)
457  GEN_VISIT(SgLongDoubleVal)
458  GEN_VISIT(SgLongIntVal)
459  GEN_VISIT(SgLongLongIntVal)
460  GEN_VISIT(SgLshiftAssignOp)
461  GEN_VISIT(SgLshiftOp)
462  GEN_VISIT(SgMagicColonExp)
463  GEN_VISIT(SgMatrixExp)
464  GEN_VISIT(SgMatrixTransposeOp)
465  GEN_VISIT(SgMatlabForStatement)
466  GEN_VISIT(SgMemberFunctionDeclaration)
467  GEN_VISIT(SgMemberFunctionRefExp)
468  GEN_VISIT(SgMemberFunctionSymbol)
469  GEN_VISIT(SgMemberFunctionType)
470  GEN_VISIT(SgMembershipOp)
472  GEN_VISIT(SgMinusAssignOp)
473  GEN_VISIT(SgMinusMinusOp)
474  GEN_VISIT(SgMinusOp)
475  GEN_VISIT(SgModAssignOp)
476  GEN_VISIT(SgModOp)
477  GEN_VISIT(SgModifier)
478  GEN_VISIT(SgModifierNodes)
479  GEN_VISIT(SgModifierType)
480  GEN_VISIT(SgModuleStatement)
481  GEN_VISIT(SgModuleSymbol)
482  GEN_VISIT(SgMultAssignOp)
483  GEN_VISIT(SgMultiplyOp)
484  GEN_VISIT(SgName)
485  GEN_VISIT(SgNameGroup)
486  GEN_VISIT(SgNamedType)
487  GEN_VISIT(SgNamelistStatement)
491  GEN_VISIT(SgNamespaceSymbol)
492  GEN_VISIT(SgNaryOp)
493  GEN_VISIT(SgNaryBooleanOp)
494  GEN_VISIT(SgNaryComparisonOp)
495  GEN_VISIT(SgNewExp)
496  GEN_VISIT(SgNode)
497  GEN_VISIT(SgNoexceptOp)
498  GEN_VISIT(SgNotEqualOp)
499  GEN_VISIT(SgNotOp)
500  GEN_VISIT(SgNonMembershipOp)
501  GEN_VISIT(SgNonrealDecl)
502  GEN_VISIT(SgNonrealRefExp)
503  GEN_VISIT(SgNonrealSymbol)
504  GEN_VISIT(SgNonrealType)
505  GEN_VISIT(SgNonrealBaseClass)
506  GEN_VISIT(SgNullExpression)
507  GEN_VISIT(SgNullptrValExp)
508  GEN_VISIT(SgNullStatement)
509  GEN_VISIT(SgNullifyStatement)
510  GEN_VISIT(SgOmpAtomicStatement)
511  GEN_VISIT(SgOmpBarrierStatement)
512  GEN_VISIT(SgOmpCriticalStatement)
513  GEN_VISIT(SgOmpClauseBodyStatement)
514  GEN_VISIT(SgOmpBodyStatement)
515  GEN_VISIT(SgOmpDoStatement)
516  GEN_VISIT(SgOmpFlushStatement)
517  GEN_VISIT(SgOmpDeclareSimdStatement)
518  GEN_VISIT(SgOmpForStatement)
519  GEN_VISIT(SgOmpForSimdStatement)
520  GEN_VISIT(SgOmpMasterStatement)
521  GEN_VISIT(SgOmpOrderedStatement)
522  GEN_VISIT(SgOmpParallelStatement)
523  GEN_VISIT(SgOmpSectionStatement)
524  GEN_VISIT(SgOmpSectionsStatement)
525  GEN_VISIT(SgOmpSingleStatement)
526  GEN_VISIT(SgOmpTaskStatement)
527  GEN_VISIT(SgOmpTaskwaitStatement)
528  GEN_VISIT(SgOmpThreadprivateStatement)
529  GEN_VISIT(SgOmpWorkshareStatement)
530  GEN_VISIT(SgOmpTargetStatement)
531  GEN_VISIT(SgOmpTargetDataStatement)
532  GEN_VISIT(SgOmpSimdStatement)
533  GEN_VISIT(SgOmpClause)
534  GEN_VISIT(SgOmpBeginClause)
535  GEN_VISIT(SgOmpCollapseClause)
536  GEN_VISIT(SgOmpCopyinClause)
537  GEN_VISIT(SgOmpCopyprivateClause)
538  GEN_VISIT(SgOmpDefaultClause)
539  GEN_VISIT(SgOmpEndClause)
540  GEN_VISIT(SgOmpExpressionClause)
541  GEN_VISIT(SgOmpFirstprivateClause)
542  GEN_VISIT(SgOmpIfClause)
543  GEN_VISIT(SgOmpFinalClause)
544  GEN_VISIT(SgOmpPriorityClause)
545  GEN_VISIT(SgOmpDeviceClause)
546  GEN_VISIT(SgOmpLastprivateClause)
547  GEN_VISIT(SgOmpNowaitClause)
548  GEN_VISIT(SgOmpNumThreadsClause)
549  GEN_VISIT(SgOmpOrderedClause)
550  GEN_VISIT(SgOmpPrivateClause)
551  GEN_VISIT(SgOmpReductionClause)
552  GEN_VISIT(SgOmpScheduleClause)
553  GEN_VISIT(SgOmpSharedClause)
554  GEN_VISIT(SgOmpUntiedClause)
555  GEN_VISIT(SgOmpMergeableClause)
556  GEN_VISIT(SgOmpVariablesClause)
557  GEN_VISIT(SgOmpMapClause)
558  GEN_VISIT(SgOmpSafelenClause)
559  GEN_VISIT(SgOmpSimdlenClause)
560  GEN_VISIT(SgOmpLinearClause)
561  GEN_VISIT(SgOmpUniformClause)
562  GEN_VISIT(SgOmpAlignedClause)
563  GEN_VISIT(SgOmpProcBindClause)
564  GEN_VISIT(SgOmpAtomicClause)
565  GEN_VISIT(SgOmpInbranchClause)
566  GEN_VISIT(SgOmpNotinbranchClause)
567  GEN_VISIT(SgOmpDependClause)
568  GEN_VISIT(SgOpenclAccessModeModifier)
569  GEN_VISIT(SgOpenStatement)
570  GEN_VISIT(SgOptions)
571  GEN_VISIT(SgOrOp)
572  GEN_VISIT(SgParameterStatement)
574  GEN_VISIT(SgPartialFunctionType)
575  GEN_VISIT(SgPassStatement)
576  GEN_VISIT(SgPlusAssignOp)
577  GEN_VISIT(SgPlusPlusOp)
578  GEN_VISIT(SgPntrArrRefExp)
579  GEN_VISIT(SgPointerAssignOp)
580  GEN_VISIT(SgPointerDerefExp)
581  GEN_VISIT(SgPointerMemberType)
582  GEN_VISIT(SgPointerType)
583  GEN_VISIT(SgPowerOp)
584  GEN_VISIT(SgPragma)
585  GEN_VISIT(SgPragmaDeclaration)
586  GEN_VISIT(SgPrintStatement)
587  GEN_VISIT(SgProcedureHeaderStatement)
588  GEN_VISIT(SgProgramHeaderStatement)
589  GEN_VISIT(SgProject)
590  GEN_VISIT(SgPseudoDestructorRefExp)
591  GEN_VISIT(SgPythonGlobalStmt)
592  GEN_VISIT(SgPythonPrintStmt)
593  GEN_VISIT(SgQualifiedName)
594  GEN_VISIT(SgQualifiedNameType)
595  GEN_VISIT(SgRangeExp)
596  GEN_VISIT(SgRangeBasedForStatement)
597  GEN_VISIT(SgReadStatement)
598  GEN_VISIT(SgRealPartOp)
599  GEN_VISIT(SgRefExp)
600  GEN_VISIT(SgReferenceType)
601  GEN_VISIT(SgRemOp)
602  GEN_VISIT(SgRenamePair)
603  GEN_VISIT(SgRenameSymbol)
604  GEN_VISIT(SgReplicationOp)
605  GEN_VISIT(SgReturnStmt)
606  GEN_VISIT(SgRewindStatement)
607  GEN_VISIT(SgRshiftAssignOp)
608  GEN_VISIT(SgRshiftOp)
609  GEN_VISIT(SgRvalueReferenceType)
611  GEN_VISIT(SgJavaUnsignedRshiftOp)
612  GEN_VISIT(SgScopeOp)
613  GEN_VISIT(SgScopeStatement)
614  GEN_VISIT(SgSequenceStatement)
615  GEN_VISIT(SgSetComprehension)
616  GEN_VISIT(SgShortVal)
617  GEN_VISIT(SgSizeOfOp)
618  GEN_VISIT(SgAlignOfOp)
619  GEN_VISIT(SgJavaInstanceOfOp)
620  GEN_VISIT(SgSourceFile)
621  GEN_VISIT(SgSpawnStmt)
622  GEN_VISIT(SgSyncAllStatement)
623  GEN_VISIT(SgSyncImagesStatement)
624  GEN_VISIT(SgSyncMemoryStatement)
625  GEN_VISIT(SgSyncTeamStatement)
626  GEN_VISIT(SgLockStatement)
627  GEN_VISIT(SgUnlockStatement)
628  GEN_VISIT(SgJavaThrowStatement)
629  GEN_VISIT(SgJavaForEachStatement)
630  GEN_VISIT(SgJavaSynchronizedStatement)
631  GEN_VISIT(SgJavaParameterizedType)
632  GEN_VISIT(SgJavaWildcardType)
633  GEN_VISIT(SgProcessControlStatement)
634  GEN_VISIT(SgSpecialFunctionModifier)
635  GEN_VISIT(SgStatement)
637  GEN_VISIT(SgStmtDeclarationStatement)
638  GEN_VISIT(SgStatementExpression)
640  GEN_VISIT(SgStorageModifier)
641  GEN_VISIT(SgStringConversion)
643  GEN_VISIT(SgStringVal)
644  GEN_VISIT(SgStructureModifier)
645  GEN_VISIT(SgSubscriptExpression)
646  GEN_VISIT(SgSubtractOp)
647  GEN_VISIT(SgSupport)
648  GEN_VISIT(SgSwitchStatement)
649  GEN_VISIT(SgSymbol)
650  GEN_VISIT(SgSymbolTable)
651  GEN_VISIT(SgTemplateArgument)
652  GEN_VISIT(SgTemplateArgumentList)
653  GEN_VISIT(SgTemplateDeclaration)
654  GEN_VISIT(SgTemplateClassDeclaration)
655  GEN_VISIT(SgTemplateClassSymbol)
657  GEN_VISIT(SgTemplateFunctionRefExp)
658  GEN_VISIT(SgTemplateFunctionSymbol)
663  GEN_VISIT(SgTemplateTypedefSymbol)
665  GEN_VISIT(SgTemplateVariableSymbol)
666  GEN_VISIT(SgTemplateClassDefinition)
668  GEN_VISIT(SgTemplateInstantiationDecl)
669  GEN_VISIT(SgTemplateInstantiationDefn)
674  GEN_VISIT(SgTemplateParameter)
675  GEN_VISIT(SgTemplateParameterVal)
676  GEN_VISIT(SgTemplateParameterList)
677  GEN_VISIT(SgTemplateSymbol)
678  GEN_VISIT(SgTemplateType)
679  GEN_VISIT(SgThisExp)
680  GEN_VISIT(SgTypeTraitBuiltinOperator)
681  GEN_VISIT(SgSuperExp)
682  GEN_VISIT(SgThrowOp)
683  GEN_VISIT(SgToken)
684  GEN_VISIT(SgTryStmt)
685  GEN_VISIT(SgTupleExp)
686  GEN_VISIT(SgType)
687  GEN_VISIT(SgTypeBool)
688  GEN_VISIT(SgTypeChar)
689  GEN_VISIT(SgTypeChar16)
690  GEN_VISIT(SgTypeChar32)
691  GEN_VISIT(SgTypeComplex)
692  GEN_VISIT(SgTypeDefault)
693  GEN_VISIT(SgTypeExpression)
694  GEN_VISIT(SgTypeLabel)
695  GEN_VISIT(SgTypeDouble)
696  GEN_VISIT(SgTypeEllipse)
697  GEN_VISIT(SgTypeFixed)
698  GEN_VISIT(SgTypeFloat)
699  GEN_VISIT(SgTypeFloat128)
700  GEN_VISIT(SgTypeFloat80)
701  GEN_VISIT(SgTypeGlobalVoid)
702  GEN_VISIT(SgTypeIdOp)
703  GEN_VISIT(SgTypeImaginary)
704  GEN_VISIT(SgTypeInt)
705  GEN_VISIT(SgTypeLong)
706  GEN_VISIT(SgTypeLongDouble)
707  GEN_VISIT(SgTypeLongLong)
708  GEN_VISIT(SgTypeModifier)
709  GEN_VISIT(SgTypeMatrix)
710  GEN_VISIT(SgTypeTuple)
711  GEN_VISIT(SgTypeNullptr)
712  GEN_VISIT(SgTypeOfType)
713  GEN_VISIT(SgTypeShort)
714  GEN_VISIT(SgTypeSigned128bitInteger)
715  GEN_VISIT(SgTypeSignedChar)
716  GEN_VISIT(SgTypeSignedInt)
717  GEN_VISIT(SgTypeSignedLong)
718  GEN_VISIT(SgTypeSignedLongLong)
719  GEN_VISIT(SgTypeSignedShort)
720  GEN_VISIT(SgTypeString)
721  GEN_VISIT(SgTypeUnknown)
722  GEN_VISIT(SgTypeUnsigned128bitInteger)
723  GEN_VISIT(SgTypeUnsignedChar)
724  GEN_VISIT(SgTypeUnsignedInt)
725  GEN_VISIT(SgTypeUnsignedLong)
726  GEN_VISIT(SgTypeUnsignedLongLong)
727  GEN_VISIT(SgTypeUnsignedShort)
728  GEN_VISIT(SgTypeVoid)
729  GEN_VISIT(SgTypeWchar)
730  GEN_VISIT(SgTypedefDeclaration)
731  GEN_VISIT(SgTypedefSeq)
732  GEN_VISIT(SgTypedefSymbol)
733  GEN_VISIT(SgTypedefType)
734  GEN_VISIT(SgUPC_AccessModifier)
735  GEN_VISIT(SgUnaryAddOp)
736  GEN_VISIT(SgUnaryOp)
737  GEN_VISIT(SgUndefDirectiveStatement)
738  GEN_VISIT(SgUndirectedGraphEdge)
740  GEN_VISIT(SgUnknownFile)
741  GEN_VISIT(SgUnparse_Info)
742  GEN_VISIT(SgUnsignedCharVal)
743  GEN_VISIT(SgUnsignedIntVal)
744  GEN_VISIT(SgUnsignedLongLongIntVal)
745  GEN_VISIT(SgUnsignedLongVal)
746  GEN_VISIT(SgUnsignedShortVal)
747  GEN_VISIT(SgUntypedNode)
748  GEN_VISIT(SgUntypedExpression)
749  GEN_VISIT(SgUntypedUnaryOperator)
750  GEN_VISIT(SgUntypedBinaryOperator)
751  GEN_VISIT(SgUntypedValueExpression)
754  GEN_VISIT(SgUntypedOtherExpression)
755  GEN_VISIT(SgUntypedNamedExpression)
756  GEN_VISIT(SgUntypedNullExpression)
757  GEN_VISIT(SgUntypedExprListExpression)
759  GEN_VISIT(SgUntypedStatement)
760  GEN_VISIT(SgUntypedLabelStatement)
761  GEN_VISIT(SgUntypedNamedStatement)
763  GEN_VISIT(SgUntypedBlockStatement)
765  GEN_VISIT(SgUntypedForAllStatement)
768  GEN_VISIT(SgUntypedOtherStatement)
769  GEN_VISIT(SgUntypedUseStatement)
772  GEN_VISIT(SgUntypedEnumDeclaration)
773  GEN_VISIT(SgUntypedInitializedName)
774  GEN_VISIT(SgUntypedName)
779  GEN_VISIT(SgUntypedTypedefDeclaration)
784  GEN_VISIT(SgUntypedNullDeclaration)
785  GEN_VISIT(SgUntypedNullStatement)
786  GEN_VISIT(SgUntypedIfStatement)
787  GEN_VISIT(SgUntypedCaseStatement)
788  GEN_VISIT(SgUntypedLoopStatement)
789  GEN_VISIT(SgUntypedWhileStatement)
790  GEN_VISIT(SgUntypedForStatement)
791  GEN_VISIT(SgUntypedExitStatement)
792  GEN_VISIT(SgUntypedGotoStatement)
794  GEN_VISIT(SgUntypedReturnStatement)
796  GEN_VISIT(SgUntypedStopStatement)
797  GEN_VISIT(SgUntypedAcceptStatement)
798  GEN_VISIT(SgUntypedEntryCallStatement)
799  GEN_VISIT(SgUntypedRequeueStatement)
807  GEN_VISIT(SgUntypedAbortStatement)
808  GEN_VISIT(SgUntypedRaiseStatement)
809  GEN_VISIT(SgUntypedCodeStatement)
811  GEN_VISIT(SgUntypedToken)
812  GEN_VISIT(SgUntypedTokenPair)
813  GEN_VISIT(SgUntypedType)
814  GEN_VISIT(SgUntypedArrayType)
815  GEN_VISIT(SgUntypedTableType)
816  GEN_VISIT(SgUntypedAttribute)
817  GEN_VISIT(SgUntypedFile)
818  GEN_VISIT(SgUntypedScope)
819  GEN_VISIT(SgUntypedFunctionScope)
820  GEN_VISIT(SgUntypedModuleScope)
821  GEN_VISIT(SgUntypedGlobalScope)
822  GEN_VISIT(SgUntypedModuleDeclaration)
827  GEN_VISIT(SgUntypedPackageDeclaration)
830  GEN_VISIT(SgUntypedTaskDeclaration)
831  GEN_VISIT(SgUntypedUnitDeclaration)
832  GEN_VISIT(SgUntypedStatementList)
836  GEN_VISIT(SgUntypedNameList)
837  GEN_VISIT(SgUntypedTokenList)
838  GEN_VISIT(SgUntypedTokenPairList)
839  GEN_VISIT(SgUpcBarrierStatement)
840  GEN_VISIT(SgUpcBlocksizeofExpression)
841  GEN_VISIT(SgUpcElemsizeofExpression)
842  GEN_VISIT(SgUpcFenceStatement)
843  GEN_VISIT(SgUpcForAllStatement)
844  GEN_VISIT(SgUpcLocalsizeofExpression)
845  GEN_VISIT(SgUpcMythread)
846  GEN_VISIT(SgUpcNotifyStatement)
847  GEN_VISIT(SgUpcThreads)
848  GEN_VISIT(SgUpcWaitStatement)
849  GEN_VISIT(SgUseStatement)
850  GEN_VISIT(SgUserDefinedBinaryOp)
851  GEN_VISIT(SgUserDefinedUnaryOp)
852  GEN_VISIT(SgUsingDeclarationStatement)
853  GEN_VISIT(SgUsingDirectiveStatement)
854  GEN_VISIT(SgValueExp)
855  GEN_VISIT(SgVarArgCopyOp)
856  GEN_VISIT(SgVarArgEndOp)
857  GEN_VISIT(SgVarArgOp)
858  GEN_VISIT(SgVarArgStartOneOperandOp)
859  GEN_VISIT(SgVarArgStartOp)
860  GEN_VISIT(SgVarRefExp)
861  GEN_VISIT(SgVariableDeclaration)
862  GEN_VISIT(SgVariableDefinition)
863  GEN_VISIT(SgVariableSymbol)
864  GEN_VISIT(SgVariantExpression)
865  GEN_VISIT(SgVariantStatement)
866  GEN_VISIT(SgVoidVal)
867  GEN_VISIT(SgWaitStatement)
868  GEN_VISIT(SgWarningDirectiveStatement)
869  GEN_VISIT(SgWithStatement)
870  GEN_VISIT(SgWcharVal)
871  GEN_VISIT(SgWhereStatement)
872  GEN_VISIT(SgWhileStmt)
873  GEN_VISIT(SgWriteStatement)
874  GEN_VISIT(SgXorAssignOp)
875  GEN_VISIT(SgYieldExpression)
876  GEN_VISIT(Sg_File_Info)
877  GEN_VISIT(SgTypeCAFTeam)
878  GEN_VISIT(SgCAFWithTeamStatement)
879  GEN_VISIT(SgCAFCoExpression)
880  GEN_VISIT(SgCallExpression)
881  GEN_VISIT(SgTypeCrayPointer)
882  GEN_VISIT(SgJavaImportStatement)
883  GEN_VISIT(SgJavaPackageDeclaration)
884  GEN_VISIT(SgJavaPackageStatement)
885  GEN_VISIT(SgJavaImportStatementList)
886  GEN_VISIT(SgJavaClassDeclarationList)
887  GEN_VISIT(SgJavaMemberValuePair)
888  GEN_VISIT(SgJavaAnnotation)
889  GEN_VISIT(SgJavaMarkerAnnotation)
891  GEN_VISIT(SgJavaNormalAnnotation)
892  GEN_VISIT(SgJavaTypeExpression)
893  GEN_VISIT(SgJavaQualifiedType)
894  GEN_VISIT(SgClassExp)
895  GEN_VISIT(SgJavaUnionType)
896  GEN_VISIT(SgJavaParameterType)
897  GEN_VISIT(SgAsyncStmt)
898  GEN_VISIT(SgFinishStmt)
899  GEN_VISIT(SgAtStmt)
900  GEN_VISIT(SgAtomicStmt)
901  GEN_VISIT(SgWhenStmt)
902  GEN_VISIT(SgAtExp)
903  GEN_VISIT(SgFinishExp)
904  GEN_VISIT(SgHereExp)
905  GEN_VISIT(SgDotDotExp)
906 
907  /*
908  GEN_VISIT(SgAsmArm64AtOperand)
909  GEN_VISIT(SgAsmArm64CImmediateOperand)
910  GEN_VISIT(SgAsmArm64Instruction)
911  GEN_VISIT(SgAsmArm64PrefetchOperand)
912  GEN_VISIT(SgAsmArm64SysMoveOperand)
913  GEN_VISIT(SgAsmBasicString)
914  GEN_VISIT(SgAsmBinaryAdd)
915  GEN_VISIT(SgAsmBinaryAddPostupdate)
916  GEN_VISIT(SgAsmBinaryAddPreupdate)
917  GEN_VISIT(SgAsmBinaryAsr)
918  GEN_VISIT(SgAsmBinaryDivide)
919  GEN_VISIT(SgAsmBinaryExpression)
920  GEN_VISIT(SgAsmBinaryLsl)
921  GEN_VISIT(SgAsmBinaryLsr)
922  GEN_VISIT(SgAsmBinaryMod)
923  GEN_VISIT(SgAsmBinaryMsl)
924  GEN_VISIT(SgAsmBinaryMultiply)
925  GEN_VISIT(SgAsmBinaryRor)
926  GEN_VISIT(SgAsmBinarySubtract)
927  GEN_VISIT(SgAsmBinarySubtractPostupdate)
928  GEN_VISIT(SgAsmBinarySubtractPreupdate)
929  GEN_VISIT(SgAsmBlock)
930  GEN_VISIT(SgAsmCoffStrtab)
931  GEN_VISIT(SgAsmCoffSymbol)
932  GEN_VISIT(SgAsmCoffSymbolList)
933  GEN_VISIT(SgAsmCoffSymbolTable)
934  GEN_VISIT(SgAsmCommonSubExpression)
935  GEN_VISIT(SgAsmControlFlagsExpression)
936  GEN_VISIT(SgAsmConstantExpression)
937  GEN_VISIT(SgAsmDOSExtendedHeader)
938  GEN_VISIT(SgAsmDOSFileHeader)
939  GEN_VISIT(SgAsmSynthesizedDataStructureDeclaration)
940  GEN_VISIT(SgAsmSynthesizedDeclaration)
941  GEN_VISIT(SgAsmDirectRegisterExpression)
942  GEN_VISIT(SgAsmDwarfAccessDeclaration)
943  GEN_VISIT(SgAsmDwarfArrayType)
944  GEN_VISIT(SgAsmDwarfBaseType)
945  GEN_VISIT(SgAsmDwarfCatchBlock)
946  GEN_VISIT(SgAsmDwarfClassTemplate)
947  GEN_VISIT(SgAsmDwarfClassType)
948  GEN_VISIT(SgAsmDwarfCommonBlock)
949  GEN_VISIT(SgAsmDwarfCommonInclusion)
950  GEN_VISIT(SgAsmDwarfCompilationUnit)
951  GEN_VISIT(SgAsmDwarfCompilationUnitList)
952  GEN_VISIT(SgAsmDwarfCondition)
953  GEN_VISIT(SgAsmDwarfConstType)
954  GEN_VISIT(SgAsmDwarfConstant)
955  GEN_VISIT(SgAsmDwarfConstruct)
956  GEN_VISIT(SgAsmDwarfConstructList)
957  GEN_VISIT(SgAsmDwarfDwarfProcedure)
958  GEN_VISIT(SgAsmDwarfEntryPoint)
959  GEN_VISIT(SgAsmDwarfEnumerationType)
960  GEN_VISIT(SgAsmDwarfEnumerator)
961  GEN_VISIT(SgAsmDwarfFileType)
962  GEN_VISIT(SgAsmDwarfFormalParameter)
963  GEN_VISIT(SgAsmDwarfFormatLabel)
964  GEN_VISIT(SgAsmDwarfFriend)
965  GEN_VISIT(SgAsmDwarfFunctionTemplate)
966  GEN_VISIT(SgAsmDwarfImportedDeclaration)
967  GEN_VISIT(SgAsmDwarfImportedModule)
968  GEN_VISIT(SgAsmDwarfImportedUnit)
969  GEN_VISIT(SgAsmDwarfInformation)
970  GEN_VISIT(SgAsmDwarfInheritance)
971  GEN_VISIT(SgAsmDwarfInlinedSubroutine)
972  GEN_VISIT(SgAsmDwarfInterfaceType)
973  GEN_VISIT(SgAsmDwarfLabel)
974  GEN_VISIT(SgAsmDwarfLexicalBlock)
975  GEN_VISIT(SgAsmDwarfLine)
976  GEN_VISIT(SgAsmDwarfLineList)
977  GEN_VISIT(SgAsmDwarfMacro)
978  GEN_VISIT(SgAsmDwarfMacroList)
979  GEN_VISIT(SgAsmDwarfMember)
980  GEN_VISIT(SgAsmDwarfModule)
981  GEN_VISIT(SgAsmDwarfMutableType)
982  GEN_VISIT(SgAsmDwarfNamelist)
983  GEN_VISIT(SgAsmDwarfNamelistItem)
984  GEN_VISIT(SgAsmDwarfNamespace)
985  GEN_VISIT(SgAsmDwarfPackedType)
986  GEN_VISIT(SgAsmDwarfPartialUnit)
987  GEN_VISIT(SgAsmDwarfPointerType)
988  GEN_VISIT(SgAsmDwarfPtrToMemberType)
989  GEN_VISIT(SgAsmDwarfReferenceType)
990  GEN_VISIT(SgAsmDwarfRestrictType)
991  GEN_VISIT(SgAsmDwarfSetType)
992  GEN_VISIT(SgAsmDwarfSharedType)
993  GEN_VISIT(SgAsmDwarfStringType)
994  GEN_VISIT(SgAsmDwarfStructureType)
995  GEN_VISIT(SgAsmDwarfSubprogram)
996  GEN_VISIT(SgAsmDwarfSubrangeType)
997  GEN_VISIT(SgAsmDwarfSubroutineType)
998  GEN_VISIT(SgAsmDwarfTemplateTypeParameter)
999  GEN_VISIT(SgAsmDwarfTemplateValueParameter)
1000  GEN_VISIT(SgAsmDwarfThrownType)
1001  GEN_VISIT(SgAsmDwarfTryBlock)
1002  GEN_VISIT(SgAsmDwarfTypedef)
1003  GEN_VISIT(SgAsmDwarfUnionType)
1004  GEN_VISIT(SgAsmDwarfUnknownConstruct)
1005  GEN_VISIT(SgAsmDwarfUnspecifiedParameters)
1006  GEN_VISIT(SgAsmDwarfUnspecifiedType)
1007  GEN_VISIT(SgAsmDwarfUpcRelaxedType)
1008  GEN_VISIT(SgAsmDwarfUpcSharedType)
1009  GEN_VISIT(SgAsmDwarfUpcStrictType)
1010  GEN_VISIT(SgAsmDwarfVariable)
1011  GEN_VISIT(SgAsmDwarfVariant)
1012  GEN_VISIT(SgAsmDwarfVariantPart)
1013  GEN_VISIT(SgAsmDwarfVolatileType)
1014  GEN_VISIT(SgAsmDwarfWithStmt)
1015  GEN_VISIT(SgAsmElfDynamicEntry)
1016  GEN_VISIT(SgAsmElfDynamicEntryList)
1017  GEN_VISIT(SgAsmElfDynamicSection)
1018  GEN_VISIT(SgAsmElfEHFrameEntryCI)
1019  GEN_VISIT(SgAsmElfEHFrameEntryCIList)
1020  GEN_VISIT(SgAsmElfEHFrameEntryFD)
1021  GEN_VISIT(SgAsmElfEHFrameEntryFDList)
1022  GEN_VISIT(SgAsmElfEHFrameSection)
1023  GEN_VISIT(SgAsmElfFileHeader)
1024  GEN_VISIT(SgAsmElfNoteEntry)
1025  GEN_VISIT(SgAsmElfNoteEntryList)
1026  GEN_VISIT(SgAsmElfNoteSection)
1027  GEN_VISIT(SgAsmElfRelocEntry)
1028  GEN_VISIT(SgAsmElfRelocEntryList)
1029  GEN_VISIT(SgAsmElfRelocSection)
1030  GEN_VISIT(SgAsmElfSection)
1031  GEN_VISIT(SgAsmElfSectionTable)
1032  GEN_VISIT(SgAsmElfSectionTableEntry)
1033  GEN_VISIT(SgAsmElfSegmentTable)
1034  GEN_VISIT(SgAsmElfSegmentTableEntry)
1035  GEN_VISIT(SgAsmElfSegmentTableEntryList)
1036  GEN_VISIT(SgAsmElfStringSection)
1037  GEN_VISIT(SgAsmElfStrtab)
1038  GEN_VISIT(SgAsmElfSymbol)
1039  GEN_VISIT(SgAsmElfSymbolList)
1040  GEN_VISIT(SgAsmElfSymbolSection)
1041  GEN_VISIT(SgAsmElfSymverDefinedAux)
1042  GEN_VISIT(SgAsmElfSymverDefinedAuxList)
1043  GEN_VISIT(SgAsmElfSymverDefinedEntry)
1044  GEN_VISIT(SgAsmElfSymverDefinedEntryList)
1045  GEN_VISIT(SgAsmElfSymverDefinedSection)
1046  GEN_VISIT(SgAsmElfSymverEntry)
1047  GEN_VISIT(SgAsmElfSymverEntryList)
1048  GEN_VISIT(SgAsmElfSymverNeededAux)
1049  GEN_VISIT(SgAsmElfSymverNeededAuxList)
1050  GEN_VISIT(SgAsmElfSymverNeededEntry)
1051  GEN_VISIT(SgAsmElfSymverNeededEntryList)
1052  GEN_VISIT(SgAsmElfSymverNeededSection)
1053  GEN_VISIT(SgAsmElfSymverSection)
1054  GEN_VISIT(SgAsmExecutableFileFormat)
1055  GEN_VISIT(SgAsmExprListExp)
1056  GEN_VISIT(SgAsmExpression)
1057  GEN_VISIT(SgAsmSynthesizedFieldDeclaration)
1058  GEN_VISIT(SgAsmFloatType)
1059  GEN_VISIT(SgAsmFloatValueExpression)
1060  GEN_VISIT(SgAsmFunction)
1061  GEN_VISIT(SgAsmGenericDLL)
1062  GEN_VISIT(SgAsmGenericDLLList)
1063  GEN_VISIT(SgAsmGenericFile)
1064  GEN_VISIT(SgAsmGenericFileList)
1065  GEN_VISIT(SgAsmGenericFormat)
1066  GEN_VISIT(SgAsmGenericHeader)
1067  GEN_VISIT(SgAsmGenericHeaderList)
1068  GEN_VISIT(SgAsmGenericSection)
1069  GEN_VISIT(SgAsmGenericSectionList)
1070  GEN_VISIT(SgAsmGenericString)
1071  GEN_VISIT(SgAsmGenericStrtab)
1072  GEN_VISIT(SgAsmGenericSymbol)
1073  GEN_VISIT(SgAsmGenericSymbolList)
1074  GEN_VISIT(SgAsmIndirectRegisterExpression)
1075  GEN_VISIT(SgAsmInstruction)
1076  GEN_VISIT(SgAsmIntegerValueExpression)
1077  GEN_VISIT(SgAsmIntegerType)
1078  GEN_VISIT(SgAsmInterpretation)
1079  GEN_VISIT(SgAsmInterpretationList)
1080  GEN_VISIT(SgAsmLEEntryPoint)
1081  GEN_VISIT(SgAsmLEEntryTable)
1082  GEN_VISIT(SgAsmLEFileHeader)
1083  GEN_VISIT(SgAsmLENameTable)
1084  GEN_VISIT(SgAsmLEPageTable)
1085  GEN_VISIT(SgAsmLEPageTableEntry)
1086  GEN_VISIT(SgAsmLERelocTable)
1087  GEN_VISIT(SgAsmLESection)
1088  GEN_VISIT(SgAsmLESectionTable)
1089  GEN_VISIT(SgAsmLESectionTableEntry)
1090  GEN_VISIT(SgAsmM68kInstruction)
1091  GEN_VISIT(SgAsmMemoryReferenceExpression)
1092  GEN_VISIT(SgAsmMipsInstruction)
1093  GEN_VISIT(SgAsmNEEntryPoint)
1094  GEN_VISIT(SgAsmNEEntryTable)
1095  GEN_VISIT(SgAsmNEFileHeader)
1096  GEN_VISIT(SgAsmNEModuleTable)
1097  GEN_VISIT(SgAsmNENameTable)
1098  GEN_VISIT(SgAsmNERelocEntry)
1099  GEN_VISIT(SgAsmNERelocTable)
1100  GEN_VISIT(SgAsmNESection)
1101  GEN_VISIT(SgAsmNESectionTable)
1102  GEN_VISIT(SgAsmNESectionTableEntry)
1103  GEN_VISIT(SgAsmNEStringTable)
1104  GEN_VISIT(SgAsmNode)
1105  GEN_VISIT(SgAsmOp)
1106  GEN_VISIT(SgAsmOperandList)
1107  GEN_VISIT(SgAsmPEExportDirectory)
1108  GEN_VISIT(SgAsmPEExportEntry)
1109  GEN_VISIT(SgAsmPEExportEntryList)
1110  GEN_VISIT(SgAsmPEExportSection)
1111  GEN_VISIT(SgAsmPEFileHeader)
1112  GEN_VISIT(SgAsmPEImportDirectory)
1113  GEN_VISIT(SgAsmPEImportDirectoryList)
1114  GEN_VISIT(SgAsmPEImportItem)
1115  GEN_VISIT(SgAsmPEImportItemList)
1116  GEN_VISIT(SgAsmPEImportSection)
1117  GEN_VISIT(SgAsmPERVASizePair)
1118  GEN_VISIT(SgAsmPERVASizePairList)
1119  GEN_VISIT(SgAsmPESection)
1120  GEN_VISIT(SgAsmPESectionTable)
1121  GEN_VISIT(SgAsmPESectionTableEntry)
1122  GEN_VISIT(SgAsmPEStringSection)
1123  GEN_VISIT(SgAsmPowerpcInstruction)
1124  GEN_VISIT(SgAsmRegisterNames)
1125  GEN_VISIT(SgAsmRegisterReferenceExpression)
1126  GEN_VISIT(SgAsmRiscOperation)
1127  GEN_VISIT(SgAsmScalarType)
1128  GEN_VISIT(SgAsmStatement)
1129  GEN_VISIT(SgAsmStaticData)
1130  GEN_VISIT(SgAsmStmt)
1131  GEN_VISIT(SgAsmStoredString)
1132  GEN_VISIT(SgAsmStringStorage)
1133  GEN_VISIT(SgAsmType)
1134  GEN_VISIT(SgAsmUnaryExpression)
1135  GEN_VISIT(SgAsmUnaryMinus)
1136  GEN_VISIT(SgAsmUnaryPlus)
1137  GEN_VISIT(SgAsmUnaryRrx)
1138  GEN_VISIT(SgAsmUnarySignedExtend)
1139  GEN_VISIT(SgAsmUnaryUnsignedExtend)
1140  GEN_VISIT(SgAsmUnaryTruncate)
1141  GEN_VISIT(SgAsmValueExpression)
1142  GEN_VISIT(SgAsmVectorType)
1143  GEN_VISIT(SgAsmX86Instruction)
1144  GEN_VISIT(SgAsmBinaryAddressSymbol)
1145  GEN_VISIT(SgAsmBinaryDataSymbol)
1146  GEN_VISIT(SgBinaryComposite)
1147  *
1148  GEN_VISIT(SgComprehensionList)
1149 
1150  GEN_VISIT(SgDirectedGraph)
1151  GEN_VISIT(SgDirectedGraphEdge)
1152  GEN_VISIT(SgDirectedGraphNode)
1153 
1154  GEN_VISIT(SgUnknownMemberFunctionType)
1155 
1156  */
1157 
1158  RoseVisitor rv;
1159  };
1160 
1161 #undef GEN_VISIT
1162 
1163 
1164 
1165 #if __cplusplus >= 201103L
1166  template <class RoseVisitor>
1167  inline
1168  typename std::remove_const<typename std::remove_reference<RoseVisitor>::type>::type
1169  _dispatch(RoseVisitor&& rv, SgNode* n)
1170  {
1171  typedef typename std::remove_reference<RoseVisitor>::type RoseVisitorNoref;
1172  typedef typename std::remove_const<RoseVisitorNoref>::type RoseHandler;
1173 
1174  ROSE_ASSERT(n);
1175 
1176  VisitDispatcher<RoseHandler> vis( std::forward<RoseVisitor>(rv),
1177  std::is_lvalue_reference<RoseVisitor>()
1178  );
1179 
1180  n->accept(vis);
1181  return std::move(vis).rv;
1182  }
1183 #else
1184  template <class RoseVisitor>
1185  inline
1186  RoseVisitor
1187  _dispatch(const RoseVisitor& rv, SgNode* n)
1188  {
1189  ROSE_ASSERT(n);
1190 
1191  VisitDispatcher<RoseVisitor> vis(rv);
1192 
1193  n->accept(vis);
1194  return vis.rv;
1195  }
1196 #endif
1197 
1198 
1254 #if 0
1255 #endif
1266 
1267 #if __cplusplus >= 201103L
1268  template <class RoseVisitor>
1269  inline
1270  typename std::remove_const<typename std::remove_reference<RoseVisitor>::type>::type
1271  dispatch(RoseVisitor&& rv, SgNode* n)
1272  {
1273  //~ return std::move(rv);
1274  return _dispatch(std::forward<RoseVisitor>(rv), n);
1275  }
1276 
1277  template <class RoseVisitor>
1278  inline
1279  typename std::remove_const<typename std::remove_reference<RoseVisitor>::type>::type
1280  dispatch(RoseVisitor&& rv, const SgNode* n)
1281  {
1282  //~ return std::move(rv);
1283  return _dispatch(std::forward<RoseVisitor>(rv), const_cast<SgNode*>(n));
1284  }
1285 #else
1286  template <class RoseVisitor>
1287  inline
1288  RoseVisitor
1289  dispatch(const RoseVisitor& rv, SgNode* n)
1290  {
1291  return _dispatch(rv, n);
1292  }
1293 
1295  template <class RoseVisitor>
1296  inline
1297  RoseVisitor
1298  dispatch(const RoseVisitor& rv, const SgNode* n)
1299  {
1300  return _dispatch(rv, const_cast<SgNode*>(n));
1301  }
1302 #endif /* c++11 */
1303 
1313  template <class SageNode>
1315  {
1316  void handle(SageNode&) {}
1317  };
1318 
1326  template <class AncestorNode, class QualSgNode>
1327  struct AncestorTypeFinder : DefaultHandler<const SgProject>
1328  {
1330  typedef std::pair<AncestorNode*, QualSgNode*> Pair;
1331 
1332  Pair res;
1333 
1335  : Base(), res(NULL, NULL)
1336  {}
1337 
1338  // handling of const SgProject is outsourced to DefaultHandler
1339  // thus, AncestorNode = const SgProject does not cause conflicts
1340  using Base::handle;
1341 
1342  void handle(QualSgNode& n) { res.second = n.get_parent(); }
1343  void handle(AncestorNode& n) { res.first = &n; }
1344 
1345  operator Pair() const { return res; }
1346  };
1347 
1350  template <class AncestorNode, class QualSgNode>
1351  AncestorNode* _ancestor(QualSgNode& n)
1352  {
1353  typedef AncestorTypeFinder<AncestorNode, QualSgNode> AncestorFinder;
1354 
1355  typename AncestorFinder::Pair res(NULL, n.get_parent());
1356 
1357  while (res.second != NULL)
1358  {
1359  res = (typename AncestorFinder::Pair) sg::dispatch(AncestorFinder(), res.second);
1360  }
1361 
1362  return res.first;
1363  }
1364 
1376  template <class AncestorNode>
1377  AncestorNode* ancestor(SgNode* n)
1378  {
1379  if (n == NULL) return NULL;
1380 
1381  return _ancestor<AncestorNode>(*n);
1382  }
1383 
1385  template <class AncestorNode>
1386  const AncestorNode* ancestor(const SgNode* n)
1387  {
1388  if (n == NULL) return NULL;
1389 
1390  return _ancestor<const AncestorNode>(*n);
1391  }
1392 
1394  template <class AncestorNode>
1395  AncestorNode& ancestor(SgNode& n)
1396  {
1397  AncestorNode* res = _ancestor<AncestorNode>(n);
1398 
1399  ROSE_ASSERT(res);
1400  return *res;
1401  }
1402 
1404  template <class AncestorNode>
1405  const AncestorNode& ancestor(const SgNode& n)
1406  {
1407  const AncestorNode* res = _ancestor<const AncestorNode>(n);
1408 
1409  ROSE_ASSERT(res);
1410  return *res;
1411  }
1412 
1414  template <class SageNode>
1415  struct TypeRecoveryHandler
1416  {
1417  typedef typename ConstLike<SageNode, SgNode>::type SgBaseNode;
1418 
1419  TypeRecoveryHandler(const char* f = 0, size_t ln = 0)
1420  : res(NULL), loc(f), loc_ln(ln)
1421  {}
1422 
1423 #if __cplusplus >= 201103L
1424  TypeRecoveryHandler(TypeRecoveryHandler&&) = default;
1425 
1426  TypeRecoveryHandler() = delete;
1427  TypeRecoveryHandler(const TypeRecoveryHandler&) = delete;
1428  TypeRecoveryHandler& operator=(const TypeRecoveryHandler&) = delete;
1429  TypeRecoveryHandler& operator=(TypeRecoveryHandler&&) = delete;
1430 
1431  operator SageNode* ()&& { return res; }
1432 #else
1433  operator SageNode* () { return res; }
1434 #endif /* C++ */
1435 
1436  void handle(SgBaseNode& n) { unexpected_node(n, loc, loc_ln); }
1437  void handle(SageNode& n) { res = &n; }
1438 
1439  SageNode* res;
1440  const char* loc;
1441  size_t loc_ln;
1442  };
1443 
1444 
1453  template <class SageNode>
1454  SageNode* assert_sage_type(SgNode* n, const char* f = 0, size_t ln = 0)
1455  {
1456  return sg::dispatch(TypeRecoveryHandler<SageNode>(f, ln), n);
1457  }
1458 
1459  template <class SageNode>
1460  const SageNode* assert_sage_type(const SgNode* n, const char* f = 0, size_t ln = 0)
1461  {
1462  return sg::dispatch(TypeRecoveryHandler<const SageNode>(f, ln), n);
1463  }
1464 
1465  template <class SageNode>
1466  SageNode& assert_sage_type(SgNode& n, const char* f = 0, size_t ln = 0)
1467  {
1468  return *sg::dispatch(TypeRecoveryHandler<SageNode>(f, ln), &n);
1469  }
1470 
1471  template <class SageNode>
1472  const SageNode& assert_sage_type(const SgNode& n, const char* f = 0, size_t ln = 0)
1473  {
1474  return *sg::dispatch(TypeRecoveryHandler<const SageNode>(f, ln), &n);
1475  }
1477 
1480  static inline
1481  void swap_parent(SgNode* lhs, SgNode* rhs)
1482  {
1483  SgNode* tmp = lhs->get_parent();
1484 
1485  lhs->set_parent(rhs->get_parent());
1486  rhs->set_parent(tmp);
1487  }
1488 
1492  static inline
1493  void swap_parent(void*, void*) {}
1494 
1502  template <class SageNode, class SageChild>
1503  void swap_child(SageNode& lhs, SageNode& rhs, SageChild* (SageNode::*getter) () const, void (SageNode::*setter) (SageChild*))
1504  {
1505  SageChild* lhs_child = (lhs.*getter)();
1506  SageChild* rhs_child = (rhs.*getter)();
1507  ROSE_ASSERT(lhs_child && rhs_child);
1508 
1509  (lhs.*setter)(rhs_child);
1510  (rhs.*setter)(lhs_child);
1511 
1512  swap_parent(lhs_child, rhs_child);
1513  }
1514 
1515 
1518  template <class SageNode>
1520  {
1521  typedef void (*TransformHandlerFn)(SageNode*);
1522 
1523  explicit
1524  TraversalFunction(TransformHandlerFn fun)
1525  : fn(fun)
1526  {}
1527 
1528  void handle(SgNode&) { /* ignore */ }
1529  void handle(SageNode& n) { fn(&n); }
1530 
1531  TransformHandlerFn fn;
1532  };
1533 
1536  template <class SageNode>
1537  static inline
1539  createTraversalFunction(void (* fn)(SageNode*))
1540  {
1541  return TraversalFunction<SageNode>(fn);
1542  }
1543 
1544  //
1545  // function type extractor
1546  // see https://stackoverflow.com/questions/28033251/can-you-extract-types-from-template-parameter-function-signature
1547 
1548 
1549  template <class GVisitor>
1551  {
1552  explicit
1553  TraversalClass(GVisitor gv)
1554  : gvisitor(gv)
1555  //~ : gvisitor(std::move(gv))
1556  {}
1557 
1558  void visit(SgNode* n)
1559  {
1560  gvisitor = sg::dispatch(gvisitor, n);
1561  }
1562 
1563  // GVisitor&& visitor() { return std::move(gvisitor); }
1564  GVisitor visitor() { return gvisitor; }
1565 
1566  GVisitor gvisitor;
1567  };
1568 
1569 
1570 
1577  template <class F>
1578  static inline
1579  F
1580  forAllNodes(F fn, SgNode* root, AstSimpleProcessing::Order order = postorder)
1581  {
1582  ROSE_ASSERT(root);
1583 
1584  TraversalClass<F> tt(fn);
1585  //~ TraversalClass<F> tt(std::move(fn));
1586 
1587  tt.traverse(root, order);
1588  return tt.visitor();
1589  }
1590 
1591  template <class SageNode>
1592  static inline
1593  void
1594  forAllNodes(void (*fn)(SageNode*), SgNode* root, AstSimpleProcessing::Order order = postorder)
1595  {
1596  forAllNodes(createTransformExecutor(fn), root, order);
1597  }
1598 
1599 #if !defined(NDEBUG)
1600  static inline
1601  std::string nodeType(const SgNode& n)
1602  {
1603  return typeid(n).name();
1604  }
1605 
1606  static inline
1607  std::string nodeType(const SgNode* n)
1608  {
1609  if (n == NULL) return "<null>";
1610 
1611  return nodeType(*n);
1612  }
1613 #endif
1614 
1615  template <class GVisitor>
1617  {
1618 #if __cplusplus >= 201103L
1619  explicit
1620  DispatchHelper(GVisitor gv, SgNode* p)
1621  : gvisitor(std::move(gv)), parent(p), cnt(0)
1622  {}
1623 #else
1624  explicit
1625  DispatchHelper(GVisitor gv, SgNode* p)
1626  : gvisitor(gv), parent(p), cnt(0)
1627  {}
1628 #endif /* C++11 */
1629 
1630  void operator()(SgNode* n)
1631  {
1632  ++cnt;
1633 
1634 #if 0
1635  if (n == NULL)
1636  {
1637  std::cerr << "succ(" << nodeType(parent) << ", " << cnt << ") is null" << std::endl;
1638  return;
1639  }
1640 #endif
1641 
1642 #if __cplusplus >= 201103L
1643  if (n != NULL) gvisitor = sg::dispatch(std::move(gvisitor), n);
1644 #else
1645  if (n != NULL) gvisitor = sg::dispatch(gvisitor, n);
1646 #endif /* C++11 */
1647  }
1648 
1649 #if __cplusplus >= 201103L
1650  operator GVisitor()&& { return std::move(gvisitor); }
1651 #else
1652  operator GVisitor() { return gvisitor; }
1653 #endif /* C++11 */
1654 
1655  GVisitor gvisitor;
1656  SgNode* parent;
1657  size_t cnt;
1658  };
1659 
1660 
1661  template <class GVisitor>
1662  static inline
1664  dispatchHelper(GVisitor gv, SgNode* parent = NULL)
1665  {
1666 #if __cplusplus >= 201103L
1667  return DispatchHelper<GVisitor>(std::move(gv), parent);
1668 #else
1669  return DispatchHelper<GVisitor>(gv, parent);
1670 #endif /* C++11 */
1671  }
1672 
1673 
1674  template <class GVisitor>
1675  static inline
1676  GVisitor traverseChildren(GVisitor gv, SgNode& n)
1677  {
1678  std::vector<SgNode*> successors = n.get_traversalSuccessorContainer();
1679 
1680 #if __cplusplus >= 201103L
1681  return std::for_each(successors.begin(), successors.end(), dispatchHelper(std::move(gv), &n));
1682 #else
1683  return std::for_each(successors.begin(), successors.end(), dispatchHelper(gv, &n));
1684 #endif /* C++11 */
1685  }
1686 
1687  template <class GVisitor>
1688  static inline
1689  GVisitor traverseChildren(GVisitor gv, SgNode* n)
1690  {
1691  return traverseChildren(gv, sg::deref(n));
1692  }
1693 }
1694 #endif /* _SAGEGENERIC_H */
This class represents modifiers for SgDeclaration (declaration statements).
This class represents the notion of an initializer for a variable declaration or expression in a func...
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope, etc.).
This class represents the concept of a C++ template instantiation directive.
This class represents the concept of an instantiation of member function template or a member functio...
This class represents the concept of a class declaration statement. It includes the concept of an ins...
This class represents the concept of a declaration list.
This class represents a boolean value (expression value).
This class represents a OLD concept of the structure require for qualified names when they were in th...
This class represents the notion of an n-ary comparison operation. This node is intended for use with...
This class represents the concept of an instantiated class template.
This class represents the notion of an value (expression value).
This class represents the concept of a C or C++ goto statement.
This class represents the concept of the dynamic execution of a string, file, or code object...
This class represents the concept of a C or C++ statement which contains a expression.
This class represents the notion of a binary operator. It is derived from a SgExpression because oper...
This class represents a source file for a project (which may contian many source files and or directo...
This class represents the variable declaration or variable initialization withn a for loop...
This class represents the concept of a C++ sequence of catch statements.
This class represents the notion of a unary operator. It is derived from a SgExpression because opera...
This class represents the GNU extension "statement expression" (thus is non-standard C and C++)...
Class for traversing the AST.
This class represents the C++ throw expression (handled as a unary operator).
This class represents the rhs of a variable declaration which includes an optional assignment (e...
This class represents the concept of a C++ using directive.
This class represents the base class for all types.
This class represents the concept of a do-while statement.
This class represents a Fortran pointer assignment. It is not some weird compound assignment operator...
This class represents the concept of a class name within the compiler.
This class represents the location of the code associated with the IR node in the original source cod...
This class represents the concept of an enum declaration.
This class represents the "this" operator (can be applied to any member data).
void set_parent(SgNode *parent)
All nodes in the AST contain a reference to a parent node.
This class represents a string type used for SgStringVal IR node.
This class represents the notion of an n-ary boolean operation. This node is intended for use with Py...
This class represents the concept of a C style extern "C" declaration. But such information (linkage)...
This class represents the notion of a declared variable.
This class represents the concept of a member function declaration statement.
This class represents the concept of a C and C++ case option (used within a switch statement)...
This class represents the concept of a function declaration statement.
This class represents the concept of a C Assembler statement (untested).
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope, etc.).
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 and C++ expression list.
This class represents the "sizeof()" operator (applied to any type).
This class represents the concept of a C++ namespace alias declaration statement. ...
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 numbr of IR nodes that don't otherwise fit into the existin...
This class represents a directory within a projects file structure of files and directories.
This class represents the notion of an value (expression value).
This class represents the concept of a C trinary conditional expression (e.g. "test ...
This class represents the notion of an expression. Expressions are derived from SgLocatedNodes, since similar to statement, expressions have a concrete location within the user's source code.
void visit(SgNode *n)
this method is called at every traversed node.
Definition: sageGeneric.h:1558
This class represents the notion of a break statement (typically used in a switch statment)...
This class represents the concept of a name within the compiler.
executes a functor for a specific node type
Definition: sageGeneric.h:1519
struct DefaultHandler
Definition: sageGeneric.h:1314
This class represents the concept of a class definition in C++.
This class represents strings within the IR nodes.
projects the constness of T1 on T2
Definition: sageGeneric.h:52
This class is intended to be a wrapper around SgStatements, allowing them to exist in scopes that onl...
struct DispatchHandler
Definition: sageGeneric.h:132
This class represents the concept of a contructor initializer list (used in constructor (member funct...
This class represents the concept of a namespace name within the compiler.
This class represents the notion of a typedef declaration.
This class represents the notion of an value (expression value).
This class represents the base class for all IR nodes within Sage III.
Definition: Cxx_Grammar.h:9311
This class represents the concept of a catch within a try-catch construct used in C++ exception handl...
This class represents the notion of an value (expression value).
This class represents the concept of a variable name within the compiler (a shared container for the ...
This class represents a lambda expression.
This class represents the concept of an instantiation of function template.
This class represents the physical disequality (often called pointer disequality) operator for langua...
This class represents the "&" operator (applied to any lvalue).
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 number of IR nodes define modifiers within the C++ grammar...
This class represents the concept of a block (not a basic block from control flow analysis)...
This class represents the concept of a C++ namespace declaration.
This class represents a list display.
This class represents the notion of a statement.
This class represents the concept of a namespace definition.
This class represents the concept of a for loop.
This class represents the physical equality (often called pointer equality) operator for languages th...
This class represents the concept of a C++ using declaration.
This class represents a C99 complex type.
This class represents a tuple display.
This class represents a type for all functions.
This class represents the concept of a namespace definition.
This class represents the numeric negation of a value. Not to be confused with SgSubtractOp.
This class represents the concept of a C Assembler statement (untested).
This class represents the concept of a C or C++ default case within a switch statement.
This class represents a default type used for some IR nodes (see below).
This class represents the concept of an "if" construct.
virtual std::vector< SgNode * > get_traversalSuccessorContainer()
container of pointers to AST successor nodes used in the traversal overridden in every class by gener...
This class represents the concept of a template declaration.
This class represents the notion of an expression or statement which has a position within the source...
This class represents template argument within the use of a template to build an instantiation.
This class represents the variable refernece in expressions.
This class represents the concept of a do-while statement.
This class represents a OLD concept of the structure require for qualified names when they were in th...
This class represents the definition (initialization) of a variable.
This class represents the concept of a class definition in C++.
This class represents the concept of a C++ call to the delete operator.
virtual void accept(ROSE_VisitorPattern &visitor)
support for the classic visitor pattern done in GoF
helper class for _ancestor
Definition: sageGeneric.h:1327
This class represents the concept of a C++ call to the new operator.
This class represents the concept of a C or C++ continue statement.
This class represents an object used to initialize the unparsing.
This class represents the member function being called and must be assembled in the SgFunctionCall wi...
This class represents modifiers specific to storage.
This class represents the symbol tables used in both SgScopeStatement and the SgFunctionTypeSymbolTab...
SgNode * get_parent() const
Access function for parent node.
This class represents the function being called and must be assembled in the SgFunctionCall with the ...
This class represents the concept of try statement within the try-catch support for exception handlin...
This class represents the concept of a name and a type. It may be renamed in the future to SgTypeSymb...
This class represents a list of associated typedefs for the SgType IR nodes which reference this list...
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 the function type table (stores all function types so that they can be shared i...
This class represents a C99 complex type.
This class represents the concept of a C or C++ variable declaration.
This class represents the notion of an initializer for a variable declaration or expression in a func...
This class represents the concept of a C or C++ label statement.
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 concept of a C++ function call (which is an expression).
This class was part of CC++ support from a long time ago.
This class represents the concept of a declaration statement.
This class represents the concept of a generic call expression.
This class represents the concept of a switch.
This class represents the concept of a C++ expression built from a class name.