Line data    Source code

       1             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
       2             : |*                                                                            *|
       3             : |* List of AST nodes of a particular kind                                     *|
       4             : |*                                                                            *|
       5             : |* Automatically generated file, do not edit!                                 *|
       6             : |*                                                                            *|
       7             : \*===----------------------------------------------------------------------===*/
       8             : 
       9             : #ifndef ABSTRACT_STMT
      10             : #  define ABSTRACT_STMT(Type) Type
      11             : #endif
      12             : #ifndef STMT_RANGE
      13             : #  define STMT_RANGE(Base, First, Last)
      14             : #endif
      15             : 
      16             : #ifndef LAST_STMT_RANGE
      17             : #  define LAST_STMT_RANGE(Base, First, Last) STMT_RANGE(Base, First, Last)
      18             : #endif
      19             : 
      20             : #ifndef ASMSTMT
      21             : #  define ASMSTMT(Type, Base) STMT(Type, Base)
      22             : #endif
      23           0 : ABSTRACT_STMT(ASMSTMT(AsmStmt, Stmt))
      24             : #ifndef GCCASMSTMT
      25             : #  define GCCASMSTMT(Type, Base) ASMSTMT(Type, Base)
      26             : #endif
      27           0 : GCCASMSTMT(GCCAsmStmt, AsmStmt)
      28             : #undef GCCASMSTMT
      29             : 
      30             : #ifndef MSASMSTMT
      31             : #  define MSASMSTMT(Type, Base) ASMSTMT(Type, Base)
      32             : #endif
      33           0 : MSASMSTMT(MSAsmStmt, AsmStmt)
      34             : #undef MSASMSTMT
      35             : 
      36             : STMT_RANGE(AsmStmt, GCCAsmStmt, MSAsmStmt)
      37             : 
      38             : #undef ASMSTMT
      39             : 
      40             : #ifndef ATTRIBUTEDSTMT
      41             : #  define ATTRIBUTEDSTMT(Type, Base) STMT(Type, Base)
      42             : #endif
      43           0 : ATTRIBUTEDSTMT(AttributedStmt, Stmt)
      44             : #undef ATTRIBUTEDSTMT
      45             : 
      46             : #ifndef BREAKSTMT
      47             : #  define BREAKSTMT(Type, Base) STMT(Type, Base)
      48             : #endif
      49           0 : BREAKSTMT(BreakStmt, Stmt)
      50             : #undef BREAKSTMT
      51             : 
      52             : #ifndef CXXCATCHSTMT
      53             : #  define CXXCATCHSTMT(Type, Base) STMT(Type, Base)
      54             : #endif
      55           0 : CXXCATCHSTMT(CXXCatchStmt, Stmt)
      56             : #undef CXXCATCHSTMT
      57             : 
      58             : #ifndef CXXFORRANGESTMT
      59             : #  define CXXFORRANGESTMT(Type, Base) STMT(Type, Base)
      60             : #endif
      61           0 : CXXFORRANGESTMT(CXXForRangeStmt, Stmt)
      62             : #undef CXXFORRANGESTMT
      63             : 
      64             : #ifndef CXXTRYSTMT
      65             : #  define CXXTRYSTMT(Type, Base) STMT(Type, Base)
      66             : #endif
      67           0 : CXXTRYSTMT(CXXTryStmt, Stmt)
      68             : #undef CXXTRYSTMT
      69             : 
      70             : #ifndef CAPTUREDSTMT
      71             : #  define CAPTUREDSTMT(Type, Base) STMT(Type, Base)
      72             : #endif
      73           0 : CAPTUREDSTMT(CapturedStmt, Stmt)
      74             : #undef CAPTUREDSTMT
      75             : 
      76             : #ifndef COMPOUNDSTMT
      77             : #  define COMPOUNDSTMT(Type, Base) STMT(Type, Base)
      78             : #endif
      79         117 : COMPOUNDSTMT(CompoundStmt, Stmt)
      80             : #undef COMPOUNDSTMT
      81             : 
      82             : #ifndef CONTINUESTMT
      83             : #  define CONTINUESTMT(Type, Base) STMT(Type, Base)
      84             : #endif
      85           0 : CONTINUESTMT(ContinueStmt, Stmt)
      86             : #undef CONTINUESTMT
      87             : 
      88             : #ifndef DECLSTMT
      89             : #  define DECLSTMT(Type, Base) STMT(Type, Base)
      90             : #endif
      91          54 : DECLSTMT(DeclStmt, Stmt)
      92             : #undef DECLSTMT
      93             : 
      94             : #ifndef DOSTMT
      95             : #  define DOSTMT(Type, Base) STMT(Type, Base)
      96             : #endif
      97           0 : DOSTMT(DoStmt, Stmt)
      98             : #undef DOSTMT
      99             : 
     100             : #ifndef EXPR
     101             : #  define EXPR(Type, Base) STMT(Type, Base)
     102             : #endif
     103         432 : ABSTRACT_STMT(EXPR(Expr, Stmt))
     104             : #ifndef ABSTRACTCONDITIONALOPERATOR
     105             : #  define ABSTRACTCONDITIONALOPERATOR(Type, Base) EXPR(Type, Base)
     106             : #endif
     107           0 : ABSTRACT_STMT(ABSTRACTCONDITIONALOPERATOR(AbstractConditionalOperator, Expr))
     108             : #ifndef BINARYCONDITIONALOPERATOR
     109             : #  define BINARYCONDITIONALOPERATOR(Type, Base) ABSTRACTCONDITIONALOPERATOR(Type, Base)
     110             : #endif
     111           0 : BINARYCONDITIONALOPERATOR(BinaryConditionalOperator, AbstractConditionalOperator)
     112             : #undef BINARYCONDITIONALOPERATOR
     113             : 
     114             : #ifndef CONDITIONALOPERATOR
     115             : #  define CONDITIONALOPERATOR(Type, Base) ABSTRACTCONDITIONALOPERATOR(Type, Base)
     116             : #endif
     117           0 : CONDITIONALOPERATOR(ConditionalOperator, AbstractConditionalOperator)
     118             : #undef CONDITIONALOPERATOR
     119             : 
     120             : STMT_RANGE(AbstractConditionalOperator, BinaryConditionalOperator, ConditionalOperator)
     121             : 
     122             : #undef ABSTRACTCONDITIONALOPERATOR
     123             : 
     124             : #ifndef ADDRLABELEXPR
     125             : #  define ADDRLABELEXPR(Type, Base) EXPR(Type, Base)
     126             : #endif
     127           0 : ADDRLABELEXPR(AddrLabelExpr, Expr)
     128             : #undef ADDRLABELEXPR
     129             : 
     130             : #ifndef ARRAYSUBSCRIPTEXPR
     131             : #  define ARRAYSUBSCRIPTEXPR(Type, Base) EXPR(Type, Base)
     132             : #endif
     133           0 : ARRAYSUBSCRIPTEXPR(ArraySubscriptExpr, Expr)
     134             : #undef ARRAYSUBSCRIPTEXPR
     135             : 
     136             : #ifndef ARRAYTYPETRAITEXPR
     137             : #  define ARRAYTYPETRAITEXPR(Type, Base) EXPR(Type, Base)
     138             : #endif
     139           0 : ARRAYTYPETRAITEXPR(ArrayTypeTraitExpr, Expr)
     140             : #undef ARRAYTYPETRAITEXPR
     141             : 
     142             : #ifndef ASTYPEEXPR
     143             : #  define ASTYPEEXPR(Type, Base) EXPR(Type, Base)
     144             : #endif
     145           0 : ASTYPEEXPR(AsTypeExpr, Expr)
     146             : #undef ASTYPEEXPR
     147             : 
     148             : #ifndef ATOMICEXPR
     149             : #  define ATOMICEXPR(Type, Base) EXPR(Type, Base)
     150             : #endif
     151           0 : ATOMICEXPR(AtomicExpr, Expr)
     152             : #undef ATOMICEXPR
     153             : 
     154             : #ifndef BINARYOPERATOR
     155             : #  define BINARYOPERATOR(Type, Base) EXPR(Type, Base)
     156             : #endif
     157           9 : BINARYOPERATOR(BinaryOperator, Expr)
     158             : #ifndef COMPOUNDASSIGNOPERATOR
     159             : #  define COMPOUNDASSIGNOPERATOR(Type, Base) BINARYOPERATOR(Type, Base)
     160             : #endif
     161           0 : COMPOUNDASSIGNOPERATOR(CompoundAssignOperator, BinaryOperator)
     162             : #undef COMPOUNDASSIGNOPERATOR
     163             : 
     164             : STMT_RANGE(BinaryOperator, BinaryOperator, CompoundAssignOperator)
     165             : 
     166             : #undef BINARYOPERATOR
     167             : 
     168             : #ifndef BLOCKEXPR
     169             : #  define BLOCKEXPR(Type, Base) EXPR(Type, Base)
     170             : #endif
     171           0 : BLOCKEXPR(BlockExpr, Expr)
     172             : #undef BLOCKEXPR
     173             : 
     174             : #ifndef CXXBINDTEMPORARYEXPR
     175             : #  define CXXBINDTEMPORARYEXPR(Type, Base) EXPR(Type, Base)
     176             : #endif
     177           0 : CXXBINDTEMPORARYEXPR(CXXBindTemporaryExpr, Expr)
     178             : #undef CXXBINDTEMPORARYEXPR
     179             : 
     180             : #ifndef CXXBOOLLITERALEXPR
     181             : #  define CXXBOOLLITERALEXPR(Type, Base) EXPR(Type, Base)
     182             : #endif
     183           0 : CXXBOOLLITERALEXPR(CXXBoolLiteralExpr, Expr)
     184             : #undef CXXBOOLLITERALEXPR
     185             : 
     186             : #ifndef CXXCONSTRUCTEXPR
     187             : #  define CXXCONSTRUCTEXPR(Type, Base) EXPR(Type, Base)
     188             : #endif
     189          24 : CXXCONSTRUCTEXPR(CXXConstructExpr, Expr)
     190             : #ifndef CXXTEMPORARYOBJECTEXPR
     191             : #  define CXXTEMPORARYOBJECTEXPR(Type, Base) CXXCONSTRUCTEXPR(Type, Base)
     192             : #endif
     193           0 : CXXTEMPORARYOBJECTEXPR(CXXTemporaryObjectExpr, CXXConstructExpr)
     194             : #undef CXXTEMPORARYOBJECTEXPR
     195             : 
     196             : STMT_RANGE(CXXConstructExpr, CXXConstructExpr, CXXTemporaryObjectExpr)
     197             : 
     198             : #undef CXXCONSTRUCTEXPR
     199             : 
     200             : #ifndef CXXDEFAULTARGEXPR
     201             : #  define CXXDEFAULTARGEXPR(Type, Base) EXPR(Type, Base)
     202             : #endif
     203           0 : CXXDEFAULTARGEXPR(CXXDefaultArgExpr, Expr)
     204             : #undef CXXDEFAULTARGEXPR
     205             : 
     206             : #ifndef CXXDEFAULTINITEXPR
     207             : #  define CXXDEFAULTINITEXPR(Type, Base) EXPR(Type, Base)
     208             : #endif
     209           0 : CXXDEFAULTINITEXPR(CXXDefaultInitExpr, Expr)
     210             : #undef CXXDEFAULTINITEXPR
     211             : 
     212             : #ifndef CXXDELETEEXPR
     213             : #  define CXXDELETEEXPR(Type, Base) EXPR(Type, Base)
     214             : #endif
     215           0 : CXXDELETEEXPR(CXXDeleteExpr, Expr)
     216             : #undef CXXDELETEEXPR
     217             : 
     218             : #ifndef CXXDEPENDENTSCOPEMEMBEREXPR
     219             : #  define CXXDEPENDENTSCOPEMEMBEREXPR(Type, Base) EXPR(Type, Base)
     220             : #endif
     221           0 : CXXDEPENDENTSCOPEMEMBEREXPR(CXXDependentScopeMemberExpr, Expr)
     222             : #undef CXXDEPENDENTSCOPEMEMBEREXPR
     223             : 
     224             : #ifndef CXXFOLDEXPR
     225             : #  define CXXFOLDEXPR(Type, Base) EXPR(Type, Base)
     226             : #endif
     227           0 : CXXFOLDEXPR(CXXFoldExpr, Expr)
     228             : #undef CXXFOLDEXPR
     229             : 
     230             : #ifndef CXXNEWEXPR
     231             : #  define CXXNEWEXPR(Type, Base) EXPR(Type, Base)
     232             : #endif
     233           9 : CXXNEWEXPR(CXXNewExpr, Expr)
     234             : #undef CXXNEWEXPR
     235             : 
     236             : #ifndef CXXNOEXCEPTEXPR
     237             : #  define CXXNOEXCEPTEXPR(Type, Base) EXPR(Type, Base)
     238             : #endif
     239           0 : CXXNOEXCEPTEXPR(CXXNoexceptExpr, Expr)
     240             : #undef CXXNOEXCEPTEXPR
     241             : 
     242             : #ifndef CXXNULLPTRLITERALEXPR
     243             : #  define CXXNULLPTRLITERALEXPR(Type, Base) EXPR(Type, Base)
     244             : #endif
     245           0 : CXXNULLPTRLITERALEXPR(CXXNullPtrLiteralExpr, Expr)
     246             : #undef CXXNULLPTRLITERALEXPR
     247             : 
     248             : #ifndef CXXPSEUDODESTRUCTOREXPR
     249             : #  define CXXPSEUDODESTRUCTOREXPR(Type, Base) EXPR(Type, Base)
     250             : #endif
     251           0 : CXXPSEUDODESTRUCTOREXPR(CXXPseudoDestructorExpr, Expr)
     252             : #undef CXXPSEUDODESTRUCTOREXPR
     253             : 
     254             : #ifndef CXXSCALARVALUEINITEXPR
     255             : #  define CXXSCALARVALUEINITEXPR(Type, Base) EXPR(Type, Base)
     256             : #endif
     257           0 : CXXSCALARVALUEINITEXPR(CXXScalarValueInitExpr, Expr)
     258             : #undef CXXSCALARVALUEINITEXPR
     259             : 
     260             : #ifndef CXXSTDINITIALIZERLISTEXPR
     261             : #  define CXXSTDINITIALIZERLISTEXPR(Type, Base) EXPR(Type, Base)
     262             : #endif
     263           0 : CXXSTDINITIALIZERLISTEXPR(CXXStdInitializerListExpr, Expr)
     264             : #undef CXXSTDINITIALIZERLISTEXPR
     265             : 
     266             : #ifndef CXXTHISEXPR
     267             : #  define CXXTHISEXPR(Type, Base) EXPR(Type, Base)
     268             : #endif
     269           0 : CXXTHISEXPR(CXXThisExpr, Expr)
     270             : #undef CXXTHISEXPR
     271             : 
     272             : #ifndef CXXTHROWEXPR
     273             : #  define CXXTHROWEXPR(Type, Base) EXPR(Type, Base)
     274             : #endif
     275           0 : CXXTHROWEXPR(CXXThrowExpr, Expr)
     276             : #undef CXXTHROWEXPR
     277             : 
     278             : #ifndef CXXTYPEIDEXPR
     279             : #  define CXXTYPEIDEXPR(Type, Base) EXPR(Type, Base)
     280             : #endif
     281           0 : CXXTYPEIDEXPR(CXXTypeidExpr, Expr)
     282             : #undef CXXTYPEIDEXPR
     283             : 
     284             : #ifndef CXXUNRESOLVEDCONSTRUCTEXPR
     285             : #  define CXXUNRESOLVEDCONSTRUCTEXPR(Type, Base) EXPR(Type, Base)
     286             : #endif
     287           0 : CXXUNRESOLVEDCONSTRUCTEXPR(CXXUnresolvedConstructExpr, Expr)
     288             : #undef CXXUNRESOLVEDCONSTRUCTEXPR
     289             : 
     290             : #ifndef CXXUUIDOFEXPR
     291             : #  define CXXUUIDOFEXPR(Type, Base) EXPR(Type, Base)
     292             : #endif
     293           0 : CXXUUIDOFEXPR(CXXUuidofExpr, Expr)
     294             : #undef CXXUUIDOFEXPR
     295             : 
     296             : #ifndef CALLEXPR
     297             : #  define CALLEXPR(Type, Base) EXPR(Type, Base)
     298             : #endif
     299          45 : CALLEXPR(CallExpr, Expr)
     300             : #ifndef CUDAKERNELCALLEXPR
     301             : #  define CUDAKERNELCALLEXPR(Type, Base) CALLEXPR(Type, Base)
     302             : #endif
     303           0 : CUDAKERNELCALLEXPR(CUDAKernelCallExpr, CallExpr)
     304             : #undef CUDAKERNELCALLEXPR
     305             : 
     306             : #ifndef CXXMEMBERCALLEXPR
     307             : #  define CXXMEMBERCALLEXPR(Type, Base) CALLEXPR(Type, Base)
     308             : #endif
     309          27 : CXXMEMBERCALLEXPR(CXXMemberCallExpr, CallExpr)
     310             : #undef CXXMEMBERCALLEXPR
     311             : 
     312             : #ifndef CXXOPERATORCALLEXPR
     313             : #  define CXXOPERATORCALLEXPR(Type, Base) CALLEXPR(Type, Base)
     314             : #endif
     315           0 : CXXOPERATORCALLEXPR(CXXOperatorCallExpr, CallExpr)
     316             : #undef CXXOPERATORCALLEXPR
     317             : 
     318             : #ifndef USERDEFINEDLITERAL
     319             : #  define USERDEFINEDLITERAL(Type, Base) CALLEXPR(Type, Base)
     320             : #endif
     321           0 : USERDEFINEDLITERAL(UserDefinedLiteral, CallExpr)
     322             : #undef USERDEFINEDLITERAL
     323             : 
     324             : STMT_RANGE(CallExpr, CallExpr, UserDefinedLiteral)
     325             : 
     326             : #undef CALLEXPR
     327             : 
     328             : #ifndef CASTEXPR
     329             : #  define CASTEXPR(Type, Base) EXPR(Type, Base)
     330             : #endif
     331         117 : ABSTRACT_STMT(CASTEXPR(CastExpr, Expr))
     332             : #ifndef EXPLICITCASTEXPR
     333             : #  define EXPLICITCASTEXPR(Type, Base) CASTEXPR(Type, Base)
     334             : #endif
     335          18 : ABSTRACT_STMT(EXPLICITCASTEXPR(ExplicitCastExpr, CastExpr))
     336             : #ifndef CSTYLECASTEXPR
     337             : #  define CSTYLECASTEXPR(Type, Base) EXPLICITCASTEXPR(Type, Base)
     338             : #endif
     339           0 : CSTYLECASTEXPR(CStyleCastExpr, ExplicitCastExpr)
     340             : #undef CSTYLECASTEXPR
     341             : 
     342             : #ifndef CXXFUNCTIONALCASTEXPR
     343             : #  define CXXFUNCTIONALCASTEXPR(Type, Base) EXPLICITCASTEXPR(Type, Base)
     344             : #endif
     345           0 : CXXFUNCTIONALCASTEXPR(CXXFunctionalCastExpr, ExplicitCastExpr)
     346             : #undef CXXFUNCTIONALCASTEXPR
     347             : 
     348             : #ifndef CXXNAMEDCASTEXPR
     349             : #  define CXXNAMEDCASTEXPR(Type, Base) EXPLICITCASTEXPR(Type, Base)
     350             : #endif
     351          18 : ABSTRACT_STMT(CXXNAMEDCASTEXPR(CXXNamedCastExpr, ExplicitCastExpr))
     352             : #ifndef CXXCONSTCASTEXPR
     353             : #  define CXXCONSTCASTEXPR(Type, Base) CXXNAMEDCASTEXPR(Type, Base)
     354             : #endif
     355           0 : CXXCONSTCASTEXPR(CXXConstCastExpr, CXXNamedCastExpr)
     356             : #undef CXXCONSTCASTEXPR
     357             : 
     358             : #ifndef CXXDYNAMICCASTEXPR
     359             : #  define CXXDYNAMICCASTEXPR(Type, Base) CXXNAMEDCASTEXPR(Type, Base)
     360             : #endif
     361           0 : CXXDYNAMICCASTEXPR(CXXDynamicCastExpr, CXXNamedCastExpr)
     362             : #undef CXXDYNAMICCASTEXPR
     363             : 
     364             : #ifndef CXXREINTERPRETCASTEXPR
     365             : #  define CXXREINTERPRETCASTEXPR(Type, Base) CXXNAMEDCASTEXPR(Type, Base)
     366             : #endif
     367           0 : CXXREINTERPRETCASTEXPR(CXXReinterpretCastExpr, CXXNamedCastExpr)
     368             : #undef CXXREINTERPRETCASTEXPR
     369             : 
     370             : #ifndef CXXSTATICCASTEXPR
     371             : #  define CXXSTATICCASTEXPR(Type, Base) CXXNAMEDCASTEXPR(Type, Base)
     372             : #endif
     373          16 : CXXSTATICCASTEXPR(CXXStaticCastExpr, CXXNamedCastExpr)
     374             : #undef CXXSTATICCASTEXPR
     375             : 
     376             : STMT_RANGE(CXXNamedCastExpr, CXXConstCastExpr, CXXStaticCastExpr)
     377             : 
     378             : #undef CXXNAMEDCASTEXPR
     379             : 
     380             : #ifndef OBJCBRIDGEDCASTEXPR
     381             : #  define OBJCBRIDGEDCASTEXPR(Type, Base) EXPLICITCASTEXPR(Type, Base)
     382             : #endif
     383           0 : OBJCBRIDGEDCASTEXPR(ObjCBridgedCastExpr, ExplicitCastExpr)
     384             : #undef OBJCBRIDGEDCASTEXPR
     385             : 
     386             : STMT_RANGE(ExplicitCastExpr, CStyleCastExpr, ObjCBridgedCastExpr)
     387             : 
     388             : #undef EXPLICITCASTEXPR
     389             : 
     390             : #ifndef IMPLICITCASTEXPR
     391             : #  define IMPLICITCASTEXPR(Type, Base) CASTEXPR(Type, Base)
     392             : #endif
     393          99 : IMPLICITCASTEXPR(ImplicitCastExpr, CastExpr)
     394             : #undef IMPLICITCASTEXPR
     395             : 
     396             : STMT_RANGE(CastExpr, CStyleCastExpr, ImplicitCastExpr)
     397             : 
     398             : #undef CASTEXPR
     399             : 
     400             : #ifndef CHARACTERLITERAL
     401             : #  define CHARACTERLITERAL(Type, Base) EXPR(Type, Base)
     402             : #endif
     403           0 : CHARACTERLITERAL(CharacterLiteral, Expr)
     404             : #undef CHARACTERLITERAL
     405             : 
     406             : #ifndef CHOOSEEXPR
     407             : #  define CHOOSEEXPR(Type, Base) EXPR(Type, Base)
     408             : #endif
     409           0 : CHOOSEEXPR(ChooseExpr, Expr)
     410             : #undef CHOOSEEXPR
     411             : 
     412             : #ifndef COMPOUNDLITERALEXPR
     413             : #  define COMPOUNDLITERALEXPR(Type, Base) EXPR(Type, Base)
     414             : #endif
     415           0 : COMPOUNDLITERALEXPR(CompoundLiteralExpr, Expr)
     416             : #undef COMPOUNDLITERALEXPR
     417             : 
     418             : #ifndef CONVERTVECTOREXPR
     419             : #  define CONVERTVECTOREXPR(Type, Base) EXPR(Type, Base)
     420             : #endif
     421           0 : CONVERTVECTOREXPR(ConvertVectorExpr, Expr)
     422             : #undef CONVERTVECTOREXPR
     423             : 
     424             : #ifndef DECLREFEXPR
     425             : #  define DECLREFEXPR(Type, Base) EXPR(Type, Base)
     426             : #endif
     427          72 : DECLREFEXPR(DeclRefExpr, Expr)
     428             : #undef DECLREFEXPR
     429             : 
     430             : #ifndef DEPENDENTSCOPEDECLREFEXPR
     431             : #  define DEPENDENTSCOPEDECLREFEXPR(Type, Base) EXPR(Type, Base)
     432             : #endif
     433           0 : DEPENDENTSCOPEDECLREFEXPR(DependentScopeDeclRefExpr, Expr)
     434             : #undef DEPENDENTSCOPEDECLREFEXPR
     435             : 
     436             : #ifndef DESIGNATEDINITEXPR
     437             : #  define DESIGNATEDINITEXPR(Type, Base) EXPR(Type, Base)
     438             : #endif
     439           0 : DESIGNATEDINITEXPR(DesignatedInitExpr, Expr)
     440             : #undef DESIGNATEDINITEXPR
     441             : 
     442             : #ifndef DESIGNATEDINITUPDATEEXPR
     443             : #  define DESIGNATEDINITUPDATEEXPR(Type, Base) EXPR(Type, Base)
     444             : #endif
     445           0 : DESIGNATEDINITUPDATEEXPR(DesignatedInitUpdateExpr, Expr)
     446             : #undef DESIGNATEDINITUPDATEEXPR
     447             : 
     448             : #ifndef EXPRWITHCLEANUPS
     449             : #  define EXPRWITHCLEANUPS(Type, Base) EXPR(Type, Base)
     450             : #endif
     451           0 : EXPRWITHCLEANUPS(ExprWithCleanups, Expr)
     452             : #undef EXPRWITHCLEANUPS
     453             : 
     454             : #ifndef EXPRESSIONTRAITEXPR
     455             : #  define EXPRESSIONTRAITEXPR(Type, Base) EXPR(Type, Base)
     456             : #endif
     457           0 : EXPRESSIONTRAITEXPR(ExpressionTraitExpr, Expr)
     458             : #undef EXPRESSIONTRAITEXPR
     459             : 
     460             : #ifndef EXTVECTORELEMENTEXPR
     461             : #  define EXTVECTORELEMENTEXPR(Type, Base) EXPR(Type, Base)
     462             : #endif
     463           0 : EXTVECTORELEMENTEXPR(ExtVectorElementExpr, Expr)
     464             : #undef EXTVECTORELEMENTEXPR
     465             : 
     466             : #ifndef FLOATINGLITERAL
     467             : #  define FLOATINGLITERAL(Type, Base) EXPR(Type, Base)
     468             : #endif
     469           0 : FLOATINGLITERAL(FloatingLiteral, Expr)
     470             : #undef FLOATINGLITERAL
     471             : 
     472             : #ifndef FUNCTIONPARMPACKEXPR
     473             : #  define FUNCTIONPARMPACKEXPR(Type, Base) EXPR(Type, Base)
     474             : #endif
     475           0 : FUNCTIONPARMPACKEXPR(FunctionParmPackExpr, Expr)
     476             : #undef FUNCTIONPARMPACKEXPR
     477             : 
     478             : #ifndef GNUNULLEXPR
     479             : #  define GNUNULLEXPR(Type, Base) EXPR(Type, Base)
     480             : #endif
     481           0 : GNUNULLEXPR(GNUNullExpr, Expr)
     482             : #undef GNUNULLEXPR
     483             : 
     484             : #ifndef GENERICSELECTIONEXPR
     485             : #  define GENERICSELECTIONEXPR(Type, Base) EXPR(Type, Base)
     486             : #endif
     487           0 : GENERICSELECTIONEXPR(GenericSelectionExpr, Expr)
     488             : #undef GENERICSELECTIONEXPR
     489             : 
     490             : #ifndef IMAGINARYLITERAL
     491             : #  define IMAGINARYLITERAL(Type, Base) EXPR(Type, Base)
     492             : #endif
     493           0 : IMAGINARYLITERAL(ImaginaryLiteral, Expr)
     494             : #undef IMAGINARYLITERAL
     495             : 
     496             : #ifndef IMPLICITVALUEINITEXPR
     497             : #  define IMPLICITVALUEINITEXPR(Type, Base) EXPR(Type, Base)
     498             : #endif
     499           0 : IMPLICITVALUEINITEXPR(ImplicitValueInitExpr, Expr)
     500             : #undef IMPLICITVALUEINITEXPR
     501             : 
     502             : #ifndef INITLISTEXPR
     503             : #  define INITLISTEXPR(Type, Base) EXPR(Type, Base)
     504             : #endif
     505           0 : INITLISTEXPR(InitListExpr, Expr)
     506             : #undef INITLISTEXPR
     507             : 
     508             : #ifndef INTEGERLITERAL
     509             : #  define INTEGERLITERAL(Type, Base) EXPR(Type, Base)
     510             : #endif
     511          81 : INTEGERLITERAL(IntegerLiteral, Expr)
     512             : #undef INTEGERLITERAL
     513             : 
     514             : #ifndef LAMBDAEXPR
     515             : #  define LAMBDAEXPR(Type, Base) EXPR(Type, Base)
     516             : #endif
     517           0 : LAMBDAEXPR(LambdaExpr, Expr)
     518             : #undef LAMBDAEXPR
     519             : 
     520             : #ifndef MSPROPERTYREFEXPR
     521             : #  define MSPROPERTYREFEXPR(Type, Base) EXPR(Type, Base)
     522             : #endif
     523           0 : MSPROPERTYREFEXPR(MSPropertyRefExpr, Expr)
     524             : #undef MSPROPERTYREFEXPR
     525             : 
     526             : #ifndef MATERIALIZETEMPORARYEXPR
     527             : #  define MATERIALIZETEMPORARYEXPR(Type, Base) EXPR(Type, Base)
     528             : #endif
     529           0 : MATERIALIZETEMPORARYEXPR(MaterializeTemporaryExpr, Expr)
     530             : #undef MATERIALIZETEMPORARYEXPR
     531             : 
     532             : #ifndef MEMBEREXPR
     533             : #  define MEMBEREXPR(Type, Base) EXPR(Type, Base)
     534             : #endif
     535          48 : MEMBEREXPR(MemberExpr, Expr)
     536             : #undef MEMBEREXPR
     537             : 
     538             : #ifndef NOINITEXPR
     539             : #  define NOINITEXPR(Type, Base) EXPR(Type, Base)
     540             : #endif
     541           0 : NOINITEXPR(NoInitExpr, Expr)
     542             : #undef NOINITEXPR
     543             : 
     544             : #ifndef OBJCARRAYLITERAL
     545             : #  define OBJCARRAYLITERAL(Type, Base) EXPR(Type, Base)
     546             : #endif
     547           0 : OBJCARRAYLITERAL(ObjCArrayLiteral, Expr)
     548             : #undef OBJCARRAYLITERAL
     549             : 
     550             : #ifndef OBJCBOOLLITERALEXPR
     551             : #  define OBJCBOOLLITERALEXPR(Type, Base) EXPR(Type, Base)
     552             : #endif
     553           0 : OBJCBOOLLITERALEXPR(ObjCBoolLiteralExpr, Expr)
     554             : #undef OBJCBOOLLITERALEXPR
     555             : 
     556             : #ifndef OBJCBOXEDEXPR
     557             : #  define OBJCBOXEDEXPR(Type, Base) EXPR(Type, Base)
     558             : #endif
     559           0 : OBJCBOXEDEXPR(ObjCBoxedExpr, Expr)
     560             : #undef OBJCBOXEDEXPR
     561             : 
     562             : #ifndef OBJCDICTIONARYLITERAL
     563             : #  define OBJCDICTIONARYLITERAL(Type, Base) EXPR(Type, Base)
     564             : #endif
     565           0 : OBJCDICTIONARYLITERAL(ObjCDictionaryLiteral, Expr)
     566             : #undef OBJCDICTIONARYLITERAL
     567             : 
     568             : #ifndef OBJCENCODEEXPR
     569             : #  define OBJCENCODEEXPR(Type, Base) EXPR(Type, Base)
     570             : #endif
     571           0 : OBJCENCODEEXPR(ObjCEncodeExpr, Expr)
     572             : #undef OBJCENCODEEXPR
     573             : 
     574             : #ifndef OBJCINDIRECTCOPYRESTOREEXPR
     575             : #  define OBJCINDIRECTCOPYRESTOREEXPR(Type, Base) EXPR(Type, Base)
     576             : #endif
     577           0 : OBJCINDIRECTCOPYRESTOREEXPR(ObjCIndirectCopyRestoreExpr, Expr)
     578             : #undef OBJCINDIRECTCOPYRESTOREEXPR
     579             : 
     580             : #ifndef OBJCISAEXPR
     581             : #  define OBJCISAEXPR(Type, Base) EXPR(Type, Base)
     582             : #endif
     583           0 : OBJCISAEXPR(ObjCIsaExpr, Expr)
     584             : #undef OBJCISAEXPR
     585             : 
     586             : #ifndef OBJCIVARREFEXPR
     587             : #  define OBJCIVARREFEXPR(Type, Base) EXPR(Type, Base)
     588             : #endif
     589           0 : OBJCIVARREFEXPR(ObjCIvarRefExpr, Expr)
     590             : #undef OBJCIVARREFEXPR
     591             : 
     592             : #ifndef OBJCMESSAGEEXPR
     593             : #  define OBJCMESSAGEEXPR(Type, Base) EXPR(Type, Base)
     594             : #endif
     595           0 : OBJCMESSAGEEXPR(ObjCMessageExpr, Expr)
     596             : #undef OBJCMESSAGEEXPR
     597             : 
     598             : #ifndef OBJCPROPERTYREFEXPR
     599             : #  define OBJCPROPERTYREFEXPR(Type, Base) EXPR(Type, Base)
     600             : #endif
     601           0 : OBJCPROPERTYREFEXPR(ObjCPropertyRefExpr, Expr)
     602             : #undef OBJCPROPERTYREFEXPR
     603             : 
     604             : #ifndef OBJCPROTOCOLEXPR
     605             : #  define OBJCPROTOCOLEXPR(Type, Base) EXPR(Type, Base)
     606             : #endif
     607           0 : OBJCPROTOCOLEXPR(ObjCProtocolExpr, Expr)
     608             : #undef OBJCPROTOCOLEXPR
     609             : 
     610             : #ifndef OBJCSELECTOREXPR
     611             : #  define OBJCSELECTOREXPR(Type, Base) EXPR(Type, Base)
     612             : #endif
     613           0 : OBJCSELECTOREXPR(ObjCSelectorExpr, Expr)
     614             : #undef OBJCSELECTOREXPR
     615             : 
     616             : #ifndef OBJCSTRINGLITERAL
     617             : #  define OBJCSTRINGLITERAL(Type, Base) EXPR(Type, Base)
     618             : #endif
     619           0 : OBJCSTRINGLITERAL(ObjCStringLiteral, Expr)
     620             : #undef OBJCSTRINGLITERAL
     621             : 
     622             : #ifndef OBJCSUBSCRIPTREFEXPR
     623             : #  define OBJCSUBSCRIPTREFEXPR(Type, Base) EXPR(Type, Base)
     624             : #endif
     625           0 : OBJCSUBSCRIPTREFEXPR(ObjCSubscriptRefExpr, Expr)
     626             : #undef OBJCSUBSCRIPTREFEXPR
     627             : 
     628             : #ifndef OFFSETOFEXPR
     629             : #  define OFFSETOFEXPR(Type, Base) EXPR(Type, Base)
     630             : #endif
     631           0 : OFFSETOFEXPR(OffsetOfExpr, Expr)
     632             : #undef OFFSETOFEXPR
     633             : 
     634             : #ifndef OPAQUEVALUEEXPR
     635             : #  define OPAQUEVALUEEXPR(Type, Base) EXPR(Type, Base)
     636             : #endif
     637           0 : OPAQUEVALUEEXPR(OpaqueValueExpr, Expr)
     638             : #undef OPAQUEVALUEEXPR
     639             : 
     640             : #ifndef OVERLOADEXPR
     641             : #  define OVERLOADEXPR(Type, Base) EXPR(Type, Base)
     642             : #endif
     643           0 : ABSTRACT_STMT(OVERLOADEXPR(OverloadExpr, Expr))
     644             : #ifndef UNRESOLVEDLOOKUPEXPR
     645             : #  define UNRESOLVEDLOOKUPEXPR(Type, Base) OVERLOADEXPR(Type, Base)
     646             : #endif
     647           0 : UNRESOLVEDLOOKUPEXPR(UnresolvedLookupExpr, OverloadExpr)
     648             : #undef UNRESOLVEDLOOKUPEXPR
     649             : 
     650             : #ifndef UNRESOLVEDMEMBEREXPR
     651             : #  define UNRESOLVEDMEMBEREXPR(Type, Base) OVERLOADEXPR(Type, Base)
     652             : #endif
     653           0 : UNRESOLVEDMEMBEREXPR(UnresolvedMemberExpr, OverloadExpr)
     654             : #undef UNRESOLVEDMEMBEREXPR
     655             : 
     656             : STMT_RANGE(OverloadExpr, UnresolvedLookupExpr, UnresolvedMemberExpr)
     657             : 
     658             : #undef OVERLOADEXPR
     659             : 
     660             : #ifndef PACKEXPANSIONEXPR
     661             : #  define PACKEXPANSIONEXPR(Type, Base) EXPR(Type, Base)
     662             : #endif
     663           0 : PACKEXPANSIONEXPR(PackExpansionExpr, Expr)
     664             : #undef PACKEXPANSIONEXPR
     665             : 
     666             : #ifndef PARENEXPR
     667             : #  define PARENEXPR(Type, Base) EXPR(Type, Base)
     668             : #endif
     669           0 : PARENEXPR(ParenExpr, Expr)
     670             : #undef PARENEXPR
     671             : 
     672             : #ifndef PARENLISTEXPR
     673             : #  define PARENLISTEXPR(Type, Base) EXPR(Type, Base)
     674             : #endif
     675           0 : PARENLISTEXPR(ParenListExpr, Expr)
     676             : #undef PARENLISTEXPR
     677             : 
     678             : #ifndef PREDEFINEDEXPR
     679             : #  define PREDEFINEDEXPR(Type, Base) EXPR(Type, Base)
     680             : #endif
     681           0 : PREDEFINEDEXPR(PredefinedExpr, Expr)
     682             : #undef PREDEFINEDEXPR
     683             : 
     684             : #ifndef PSEUDOOBJECTEXPR
     685             : #  define PSEUDOOBJECTEXPR(Type, Base) EXPR(Type, Base)
     686             : #endif
     687           0 : PSEUDOOBJECTEXPR(PseudoObjectExpr, Expr)
     688             : #undef PSEUDOOBJECTEXPR
     689             : 
     690             : #ifndef SHUFFLEVECTOREXPR
     691             : #  define SHUFFLEVECTOREXPR(Type, Base) EXPR(Type, Base)
     692             : #endif
     693           0 : SHUFFLEVECTOREXPR(ShuffleVectorExpr, Expr)
     694             : #undef SHUFFLEVECTOREXPR
     695             : 
     696             : #ifndef SIZEOFPACKEXPR
     697             : #  define SIZEOFPACKEXPR(Type, Base) EXPR(Type, Base)
     698             : #endif
     699           0 : SIZEOFPACKEXPR(SizeOfPackExpr, Expr)
     700             : #undef SIZEOFPACKEXPR
     701             : 
     702             : #ifndef STMTEXPR
     703             : #  define STMTEXPR(Type, Base) EXPR(Type, Base)
     704             : #endif
     705           0 : STMTEXPR(StmtExpr, Expr)
     706             : #undef STMTEXPR
     707             : 
     708             : #ifndef STRINGLITERAL
     709             : #  define STRINGLITERAL(Type, Base) EXPR(Type, Base)
     710             : #endif
     711           0 : STRINGLITERAL(StringLiteral, Expr)
     712             : #undef STRINGLITERAL
     713             : 
     714             : #ifndef SUBSTNONTYPETEMPLATEPARMEXPR
     715             : #  define SUBSTNONTYPETEMPLATEPARMEXPR(Type, Base) EXPR(Type, Base)
     716             : #endif
     717           0 : SUBSTNONTYPETEMPLATEPARMEXPR(SubstNonTypeTemplateParmExpr, Expr)
     718             : #undef SUBSTNONTYPETEMPLATEPARMEXPR
     719             : 
     720             : #ifndef SUBSTNONTYPETEMPLATEPARMPACKEXPR
     721             : #  define SUBSTNONTYPETEMPLATEPARMPACKEXPR(Type, Base) EXPR(Type, Base)
     722             : #endif
     723           0 : SUBSTNONTYPETEMPLATEPARMPACKEXPR(SubstNonTypeTemplateParmPackExpr, Expr)
     724             : #undef SUBSTNONTYPETEMPLATEPARMPACKEXPR
     725             : 
     726             : #ifndef TYPETRAITEXPR
     727             : #  define TYPETRAITEXPR(Type, Base) EXPR(Type, Base)
     728             : #endif
     729           0 : TYPETRAITEXPR(TypeTraitExpr, Expr)
     730             : #undef TYPETRAITEXPR
     731             : 
     732             : #ifndef TYPOEXPR
     733             : #  define TYPOEXPR(Type, Base) EXPR(Type, Base)
     734             : #endif
     735           0 : TYPOEXPR(TypoExpr, Expr)
     736             : #undef TYPOEXPR
     737             : 
     738             : #ifndef UNARYEXPRORTYPETRAITEXPR
     739             : #  define UNARYEXPRORTYPETRAITEXPR(Type, Base) EXPR(Type, Base)
     740             : #endif
     741           0 : UNARYEXPRORTYPETRAITEXPR(UnaryExprOrTypeTraitExpr, Expr)
     742             : #undef UNARYEXPRORTYPETRAITEXPR
     743             : 
     744             : #ifndef UNARYOPERATOR
     745             : #  define UNARYOPERATOR(Type, Base) EXPR(Type, Base)
     746             : #endif
     747           9 : UNARYOPERATOR(UnaryOperator, Expr)
     748             : #undef UNARYOPERATOR
     749             : 
     750             : #ifndef VAARGEXPR
     751             : #  define VAARGEXPR(Type, Base) EXPR(Type, Base)
     752             : #endif
     753           0 : VAARGEXPR(VAArgExpr, Expr)
     754             : #undef VAARGEXPR
     755             : 
     756             : STMT_RANGE(Expr, BinaryConditionalOperator, VAArgExpr)
     757             : 
     758             : #undef EXPR
     759             : 
     760             : #ifndef FORSTMT
     761             : #  define FORSTMT(Type, Base) STMT(Type, Base)
     762             : #endif
     763           0 : FORSTMT(ForStmt, Stmt)
     764             : #undef FORSTMT
     765             : 
     766             : #ifndef GOTOSTMT
     767             : #  define GOTOSTMT(Type, Base) STMT(Type, Base)
     768             : #endif
     769           0 : GOTOSTMT(GotoStmt, Stmt)
     770             : #undef GOTOSTMT
     771             : 
     772             : #ifndef IFSTMT
     773             : #  define IFSTMT(Type, Base) STMT(Type, Base)
     774             : #endif
     775           0 : IFSTMT(IfStmt, Stmt)
     776             : #undef IFSTMT
     777             : 
     778             : #ifndef INDIRECTGOTOSTMT
     779             : #  define INDIRECTGOTOSTMT(Type, Base) STMT(Type, Base)
     780             : #endif
     781           0 : INDIRECTGOTOSTMT(IndirectGotoStmt, Stmt)
     782             : #undef INDIRECTGOTOSTMT
     783             : 
     784             : #ifndef LABELSTMT
     785             : #  define LABELSTMT(Type, Base) STMT(Type, Base)
     786             : #endif
     787           0 : LABELSTMT(LabelStmt, Stmt)
     788             : #undef LABELSTMT
     789             : 
     790             : #ifndef MSDEPENDENTEXISTSSTMT
     791             : #  define MSDEPENDENTEXISTSSTMT(Type, Base) STMT(Type, Base)
     792             : #endif
     793           0 : MSDEPENDENTEXISTSSTMT(MSDependentExistsStmt, Stmt)
     794             : #undef MSDEPENDENTEXISTSSTMT
     795             : 
     796             : #ifndef NULLSTMT
     797             : #  define NULLSTMT(Type, Base) STMT(Type, Base)
     798             : #endif
     799           0 : NULLSTMT(NullStmt, Stmt)
     800             : #undef NULLSTMT
     801             : 
     802             : #ifndef OMPEXECUTABLEDIRECTIVE
     803             : #  define OMPEXECUTABLEDIRECTIVE(Type, Base) STMT(Type, Base)
     804             : #endif
     805           0 : ABSTRACT_STMT(OMPEXECUTABLEDIRECTIVE(OMPExecutableDirective, Stmt))
     806             : #ifndef OMPATOMICDIRECTIVE
     807             : #  define OMPATOMICDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     808             : #endif
     809           0 : OMPATOMICDIRECTIVE(OMPAtomicDirective, OMPExecutableDirective)
     810             : #undef OMPATOMICDIRECTIVE
     811             : 
     812             : #ifndef OMPBARRIERDIRECTIVE
     813             : #  define OMPBARRIERDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     814             : #endif
     815           0 : OMPBARRIERDIRECTIVE(OMPBarrierDirective, OMPExecutableDirective)
     816             : #undef OMPBARRIERDIRECTIVE
     817             : 
     818             : #ifndef OMPCANCELDIRECTIVE
     819             : #  define OMPCANCELDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     820             : #endif
     821           0 : OMPCANCELDIRECTIVE(OMPCancelDirective, OMPExecutableDirective)
     822             : #undef OMPCANCELDIRECTIVE
     823             : 
     824             : #ifndef OMPCANCELLATIONPOINTDIRECTIVE
     825             : #  define OMPCANCELLATIONPOINTDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     826             : #endif
     827           0 : OMPCANCELLATIONPOINTDIRECTIVE(OMPCancellationPointDirective, OMPExecutableDirective)
     828             : #undef OMPCANCELLATIONPOINTDIRECTIVE
     829             : 
     830             : #ifndef OMPCRITICALDIRECTIVE
     831             : #  define OMPCRITICALDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     832             : #endif
     833           0 : OMPCRITICALDIRECTIVE(OMPCriticalDirective, OMPExecutableDirective)
     834             : #undef OMPCRITICALDIRECTIVE
     835             : 
     836             : #ifndef OMPFLUSHDIRECTIVE
     837             : #  define OMPFLUSHDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     838             : #endif
     839           0 : OMPFLUSHDIRECTIVE(OMPFlushDirective, OMPExecutableDirective)
     840             : #undef OMPFLUSHDIRECTIVE
     841             : 
     842             : #ifndef OMPLOOPDIRECTIVE
     843             : #  define OMPLOOPDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     844             : #endif
     845           0 : ABSTRACT_STMT(OMPLOOPDIRECTIVE(OMPLoopDirective, OMPExecutableDirective))
     846             : #ifndef OMPFORDIRECTIVE
     847             : #  define OMPFORDIRECTIVE(Type, Base) OMPLOOPDIRECTIVE(Type, Base)
     848             : #endif
     849           0 : OMPFORDIRECTIVE(OMPForDirective, OMPLoopDirective)
     850             : #undef OMPFORDIRECTIVE
     851             : 
     852             : #ifndef OMPFORSIMDDIRECTIVE
     853             : #  define OMPFORSIMDDIRECTIVE(Type, Base) OMPLOOPDIRECTIVE(Type, Base)
     854             : #endif
     855           0 : OMPFORSIMDDIRECTIVE(OMPForSimdDirective, OMPLoopDirective)
     856             : #undef OMPFORSIMDDIRECTIVE
     857             : 
     858             : #ifndef OMPPARALLELFORDIRECTIVE
     859             : #  define OMPPARALLELFORDIRECTIVE(Type, Base) OMPLOOPDIRECTIVE(Type, Base)
     860             : #endif
     861           0 : OMPPARALLELFORDIRECTIVE(OMPParallelForDirective, OMPLoopDirective)
     862             : #undef OMPPARALLELFORDIRECTIVE
     863             : 
     864             : #ifndef OMPPARALLELFORSIMDDIRECTIVE
     865             : #  define OMPPARALLELFORSIMDDIRECTIVE(Type, Base) OMPLOOPDIRECTIVE(Type, Base)
     866             : #endif
     867           0 : OMPPARALLELFORSIMDDIRECTIVE(OMPParallelForSimdDirective, OMPLoopDirective)
     868             : #undef OMPPARALLELFORSIMDDIRECTIVE
     869             : 
     870             : #ifndef OMPSIMDDIRECTIVE
     871             : #  define OMPSIMDDIRECTIVE(Type, Base) OMPLOOPDIRECTIVE(Type, Base)
     872             : #endif
     873           0 : OMPSIMDDIRECTIVE(OMPSimdDirective, OMPLoopDirective)
     874             : #undef OMPSIMDDIRECTIVE
     875             : 
     876             : STMT_RANGE(OMPLoopDirective, OMPForDirective, OMPSimdDirective)
     877             : 
     878             : #undef OMPLOOPDIRECTIVE
     879             : 
     880             : #ifndef OMPMASTERDIRECTIVE
     881             : #  define OMPMASTERDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     882             : #endif
     883           0 : OMPMASTERDIRECTIVE(OMPMasterDirective, OMPExecutableDirective)
     884             : #undef OMPMASTERDIRECTIVE
     885             : 
     886             : #ifndef OMPORDEREDDIRECTIVE
     887             : #  define OMPORDEREDDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     888             : #endif
     889           0 : OMPORDEREDDIRECTIVE(OMPOrderedDirective, OMPExecutableDirective)
     890             : #undef OMPORDEREDDIRECTIVE
     891             : 
     892             : #ifndef OMPPARALLELDIRECTIVE
     893             : #  define OMPPARALLELDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     894             : #endif
     895           0 : OMPPARALLELDIRECTIVE(OMPParallelDirective, OMPExecutableDirective)
     896             : #undef OMPPARALLELDIRECTIVE
     897             : 
     898             : #ifndef OMPPARALLELSECTIONSDIRECTIVE
     899             : #  define OMPPARALLELSECTIONSDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     900             : #endif
     901           0 : OMPPARALLELSECTIONSDIRECTIVE(OMPParallelSectionsDirective, OMPExecutableDirective)
     902             : #undef OMPPARALLELSECTIONSDIRECTIVE
     903             : 
     904             : #ifndef OMPSECTIONDIRECTIVE
     905             : #  define OMPSECTIONDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     906             : #endif
     907           0 : OMPSECTIONDIRECTIVE(OMPSectionDirective, OMPExecutableDirective)
     908             : #undef OMPSECTIONDIRECTIVE
     909             : 
     910             : #ifndef OMPSECTIONSDIRECTIVE
     911             : #  define OMPSECTIONSDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     912             : #endif
     913           0 : OMPSECTIONSDIRECTIVE(OMPSectionsDirective, OMPExecutableDirective)
     914             : #undef OMPSECTIONSDIRECTIVE
     915             : 
     916             : #ifndef OMPSINGLEDIRECTIVE
     917             : #  define OMPSINGLEDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     918             : #endif
     919           0 : OMPSINGLEDIRECTIVE(OMPSingleDirective, OMPExecutableDirective)
     920             : #undef OMPSINGLEDIRECTIVE
     921             : 
     922             : #ifndef OMPTARGETDIRECTIVE
     923             : #  define OMPTARGETDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     924             : #endif
     925           0 : OMPTARGETDIRECTIVE(OMPTargetDirective, OMPExecutableDirective)
     926             : #undef OMPTARGETDIRECTIVE
     927             : 
     928             : #ifndef OMPTASKDIRECTIVE
     929             : #  define OMPTASKDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     930             : #endif
     931           0 : OMPTASKDIRECTIVE(OMPTaskDirective, OMPExecutableDirective)
     932             : #undef OMPTASKDIRECTIVE
     933             : 
     934             : #ifndef OMPTASKGROUPDIRECTIVE
     935             : #  define OMPTASKGROUPDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     936             : #endif
     937           0 : OMPTASKGROUPDIRECTIVE(OMPTaskgroupDirective, OMPExecutableDirective)
     938             : #undef OMPTASKGROUPDIRECTIVE
     939             : 
     940             : #ifndef OMPTASKWAITDIRECTIVE
     941             : #  define OMPTASKWAITDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     942             : #endif
     943           0 : OMPTASKWAITDIRECTIVE(OMPTaskwaitDirective, OMPExecutableDirective)
     944             : #undef OMPTASKWAITDIRECTIVE
     945             : 
     946             : #ifndef OMPTASKYIELDDIRECTIVE
     947             : #  define OMPTASKYIELDDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     948             : #endif
     949           0 : OMPTASKYIELDDIRECTIVE(OMPTaskyieldDirective, OMPExecutableDirective)
     950             : #undef OMPTASKYIELDDIRECTIVE
     951             : 
     952             : #ifndef OMPTEAMSDIRECTIVE
     953             : #  define OMPTEAMSDIRECTIVE(Type, Base) OMPEXECUTABLEDIRECTIVE(Type, Base)
     954             : #endif
     955           0 : OMPTEAMSDIRECTIVE(OMPTeamsDirective, OMPExecutableDirective)
     956             : #undef OMPTEAMSDIRECTIVE
     957             : 
     958             : STMT_RANGE(OMPExecutableDirective, OMPAtomicDirective, OMPTeamsDirective)
     959             : 
     960             : #undef OMPEXECUTABLEDIRECTIVE
     961             : 
     962             : #ifndef OBJCATCATCHSTMT
     963             : #  define OBJCATCATCHSTMT(Type, Base) STMT(Type, Base)
     964             : #endif
     965           0 : OBJCATCATCHSTMT(ObjCAtCatchStmt, Stmt)
     966             : #undef OBJCATCATCHSTMT
     967             : 
     968             : #ifndef OBJCATFINALLYSTMT
     969             : #  define OBJCATFINALLYSTMT(Type, Base) STMT(Type, Base)
     970             : #endif
     971           0 : OBJCATFINALLYSTMT(ObjCAtFinallyStmt, Stmt)
     972             : #undef OBJCATFINALLYSTMT
     973             : 
     974             : #ifndef OBJCATSYNCHRONIZEDSTMT
     975             : #  define OBJCATSYNCHRONIZEDSTMT(Type, Base) STMT(Type, Base)
     976             : #endif
     977           0 : OBJCATSYNCHRONIZEDSTMT(ObjCAtSynchronizedStmt, Stmt)
     978             : #undef OBJCATSYNCHRONIZEDSTMT
     979             : 
     980             : #ifndef OBJCATTHROWSTMT
     981             : #  define OBJCATTHROWSTMT(Type, Base) STMT(Type, Base)
     982             : #endif
     983           0 : OBJCATTHROWSTMT(ObjCAtThrowStmt, Stmt)
     984             : #undef OBJCATTHROWSTMT
     985             : 
     986             : #ifndef OBJCATTRYSTMT
     987             : #  define OBJCATTRYSTMT(Type, Base) STMT(Type, Base)
     988             : #endif
     989           0 : OBJCATTRYSTMT(ObjCAtTryStmt, Stmt)
     990             : #undef OBJCATTRYSTMT
     991             : 
     992             : #ifndef OBJCAUTORELEASEPOOLSTMT
     993             : #  define OBJCAUTORELEASEPOOLSTMT(Type, Base) STMT(Type, Base)
     994             : #endif
     995           0 : OBJCAUTORELEASEPOOLSTMT(ObjCAutoreleasePoolStmt, Stmt)
     996             : #undef OBJCAUTORELEASEPOOLSTMT
     997             : 
     998             : #ifndef OBJCFORCOLLECTIONSTMT
     999             : #  define OBJCFORCOLLECTIONSTMT(Type, Base) STMT(Type, Base)
    1000             : #endif
    1001           0 : OBJCFORCOLLECTIONSTMT(ObjCForCollectionStmt, Stmt)
    1002             : #undef OBJCFORCOLLECTIONSTMT
    1003             : 
    1004             : #ifndef RETURNSTMT
    1005             : #  define RETURNSTMT(Type, Base) STMT(Type, Base)
    1006             : #endif
    1007          45 : RETURNSTMT(ReturnStmt, Stmt)
    1008             : #undef RETURNSTMT
    1009             : 
    1010             : #ifndef SEHEXCEPTSTMT
    1011             : #  define SEHEXCEPTSTMT(Type, Base) STMT(Type, Base)
    1012             : #endif
    1013           0 : SEHEXCEPTSTMT(SEHExceptStmt, Stmt)
    1014             : #undef SEHEXCEPTSTMT
    1015             : 
    1016             : #ifndef SEHFINALLYSTMT
    1017             : #  define SEHFINALLYSTMT(Type, Base) STMT(Type, Base)
    1018             : #endif
    1019           0 : SEHFINALLYSTMT(SEHFinallyStmt, Stmt)
    1020             : #undef SEHFINALLYSTMT
    1021             : 
    1022             : #ifndef SEHLEAVESTMT
    1023             : #  define SEHLEAVESTMT(Type, Base) STMT(Type, Base)
    1024             : #endif
    1025           0 : SEHLEAVESTMT(SEHLeaveStmt, Stmt)
    1026             : #undef SEHLEAVESTMT
    1027             : 
    1028             : #ifndef SEHTRYSTMT
    1029             : #  define SEHTRYSTMT(Type, Base) STMT(Type, Base)
    1030             : #endif
    1031           0 : SEHTRYSTMT(SEHTryStmt, Stmt)
    1032             : #undef SEHTRYSTMT
    1033             : 
    1034             : #ifndef SWITCHCASE
    1035             : #  define SWITCHCASE(Type, Base) STMT(Type, Base)
    1036             : #endif
    1037           0 : ABSTRACT_STMT(SWITCHCASE(SwitchCase, Stmt))
    1038             : #ifndef CASESTMT
    1039             : #  define CASESTMT(Type, Base) SWITCHCASE(Type, Base)
    1040             : #endif
    1041           0 : CASESTMT(CaseStmt, SwitchCase)
    1042             : #undef CASESTMT
    1043             : 
    1044             : #ifndef DEFAULTSTMT
    1045             : #  define DEFAULTSTMT(Type, Base) SWITCHCASE(Type, Base)
    1046             : #endif
    1047           0 : DEFAULTSTMT(DefaultStmt, SwitchCase)
    1048             : #undef DEFAULTSTMT
    1049             : 
    1050             : STMT_RANGE(SwitchCase, CaseStmt, DefaultStmt)
    1051             : 
    1052             : #undef SWITCHCASE
    1053             : 
    1054             : #ifndef SWITCHSTMT
    1055             : #  define SWITCHSTMT(Type, Base) STMT(Type, Base)
    1056             : #endif
    1057           0 : SWITCHSTMT(SwitchStmt, Stmt)
    1058             : #undef SWITCHSTMT
    1059             : 
    1060             : #ifndef WHILESTMT
    1061             : #  define WHILESTMT(Type, Base) STMT(Type, Base)
    1062             : #endif
    1063           0 : WHILESTMT(WhileStmt, Stmt)
    1064             : #undef WHILESTMT
    1065             : 
    1066             : LAST_STMT_RANGE(Stmt, GCCAsmStmt, WhileStmt)
    1067             : 
    1068             : #undef STMT
    1069             : #undef STMT_RANGE
    1070             : #undef LAST_STMT_RANGE
    1071             : #undef ABSTRACT_STMT