source: src/SynTree/Visitor.h@ c715e5f

ADT ast-experimental pthread-emulation qualifiedEnum
Last change on this file since c715e5f was 374cb117, checked in by JiadaL <j82liang@…>, 3 years ago

Replace the interface for EnumDecl node construction to support generic enum types
  • Property mode set to 100644
File size: 16.4 KB
RevLine 
[0dd3a2f]1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
[71f4e4f]7// Visitor.h --
[0dd3a2f]8//
9// Author : Richard C. Bilson
10// Created On : Mon May 18 07:44:20 2015
[033ff37]11// Last Modified By : Peter A. Buhr
[3b0bc16]12// Last Modified On : Tue Feb 1 09:26:57 2022
13// Update Count : 17
[0dd3a2f]14//
15
[6b0b624]16#pragma once
[51b73452]17
[ea6332d]18#include "Common/SemanticError.h" // for SemanticError
19#include "SynTree.h" // for AST nodes
[51b73452]20
[d9a0e76]21class Visitor {
22 protected:
[a8a2b0a]23 Visitor() = default;
24 virtual ~Visitor() = default;
[d9a0e76]25 public:
[dba6db9]26 // visit: Default implementation of all functions visits the children
[8b11840]27 // of the given syntax node, but performs no other action.
[dba6db9]28
[7870799]29 virtual void visit( ObjectDecl * node ) { visit( const_cast<const ObjectDecl *>(node) ); }
30 virtual void visit( const ObjectDecl * objectDecl ) = 0;
31 virtual void visit( FunctionDecl * node ) { visit( const_cast<const FunctionDecl *>(node) ); }
32 virtual void visit( const FunctionDecl * functionDecl ) = 0;
33 virtual void visit( StructDecl * node ) { visit( const_cast<const StructDecl *>(node) ); }
34 virtual void visit( const StructDecl * aggregateDecl ) = 0;
35 virtual void visit( UnionDecl * node ) { visit( const_cast<const UnionDecl *>(node) ); }
36 virtual void visit( const UnionDecl * aggregateDecl ) = 0;
[374cb117]37 virtual void visit( EnumDecl * node ) { visit( const_cast<const EnumDecl *>(node) ); }
[7870799]38 virtual void visit( const EnumDecl * aggregateDecl ) = 0;
39 virtual void visit( TraitDecl * node ) { visit( const_cast<const TraitDecl *>(node) ); }
40 virtual void visit( const TraitDecl * aggregateDecl ) = 0;
41 virtual void visit( TypeDecl * node ) { visit( const_cast<const TypeDecl *>(node) ); }
42 virtual void visit( const TypeDecl * typeDecl ) = 0;
43 virtual void visit( TypedefDecl * node ) { visit( const_cast<const TypedefDecl *>(node) ); }
44 virtual void visit( const TypedefDecl * typeDecl ) = 0;
45 virtual void visit( AsmDecl * node ) { visit( const_cast<const AsmDecl *>(node) ); }
46 virtual void visit( const AsmDecl * asmDecl ) = 0;
[2d019af]47 virtual void visit( DirectiveDecl * node ) { visit( const_cast<const DirectiveDecl *>(node) ); }
48 virtual void visit( const DirectiveDecl * directiveDecl ) = 0;
[7870799]49 virtual void visit( StaticAssertDecl * node ) { visit( const_cast<const StaticAssertDecl *>(node) ); }
50 virtual void visit( const StaticAssertDecl * assertDecl ) = 0;
[0dd3a2f]51
[7870799]52 virtual void visit( CompoundStmt * node ) { visit( const_cast<const CompoundStmt *>(node) ); }
53 virtual void visit( const CompoundStmt * compoundStmt ) = 0;
54 virtual void visit( ExprStmt * node ) { visit( const_cast<const ExprStmt *>(node) ); }
55 virtual void visit( const ExprStmt * exprStmt ) = 0;
56 virtual void visit( AsmStmt * node ) { visit( const_cast<const AsmStmt *>(node) ); }
57 virtual void visit( const AsmStmt * asmStmt ) = 0;
58 virtual void visit( DirectiveStmt * node ) { visit( const_cast<const DirectiveStmt *>(node) ); }
59 virtual void visit( const DirectiveStmt * directiveStmt ) = 0;
60 virtual void visit( IfStmt * node ) { visit( const_cast<const IfStmt *>(node) ); }
61 virtual void visit( const IfStmt * ifStmt ) = 0;
[3b0bc16]62 virtual void visit( WhileDoStmt * node ) { visit( const_cast<const WhileDoStmt *>(node) ); }
63 virtual void visit( const WhileDoStmt * whileDoStmt ) = 0;
[7870799]64 virtual void visit( ForStmt * node ) { visit( const_cast<const ForStmt *>(node) ); }
65 virtual void visit( const ForStmt * forStmt ) = 0;
66 virtual void visit( SwitchStmt * node ) { visit( const_cast<const SwitchStmt *>(node) ); }
67 virtual void visit( const SwitchStmt * switchStmt ) = 0;
68 virtual void visit( CaseStmt * node ) { visit( const_cast<const CaseStmt *>(node) ); }
69 virtual void visit( const CaseStmt * caseStmt ) = 0;
70 virtual void visit( BranchStmt * node ) { visit( const_cast<const BranchStmt *>(node) ); }
71 virtual void visit( const BranchStmt * branchStmt ) = 0;
72 virtual void visit( ReturnStmt * node ) { visit( const_cast<const ReturnStmt *>(node) ); }
73 virtual void visit( const ReturnStmt * returnStmt ) = 0;
74 virtual void visit( ThrowStmt * node ) { visit( const_cast<const ThrowStmt *>(node) ); }
75 virtual void visit( const ThrowStmt * throwStmt ) = 0;
76 virtual void visit( TryStmt * node ) { visit( const_cast<const TryStmt *>(node) ); }
77 virtual void visit( const TryStmt * tryStmt ) = 0;
78 virtual void visit( CatchStmt * node ) { visit( const_cast<const CatchStmt *>(node) ); }
79 virtual void visit( const CatchStmt * catchStmt ) = 0;
80 virtual void visit( FinallyStmt * node ) { visit( const_cast<const FinallyStmt *>(node) ); }
81 virtual void visit( const FinallyStmt * finallyStmt ) = 0;
[37cdd97]82 virtual void visit( SuspendStmt * node ) { visit( const_cast<const SuspendStmt *>(node) ); }
83 virtual void visit( const SuspendStmt * suspendStmt ) = 0;
[7870799]84 virtual void visit( WaitForStmt * node ) { visit( const_cast<const WaitForStmt *>(node) ); }
85 virtual void visit( const WaitForStmt * waitforStmt ) = 0;
86 virtual void visit( WithStmt * node ) { visit( const_cast<const WithStmt *>(node) ); }
87 virtual void visit( const WithStmt * withStmt ) = 0;
88 virtual void visit( NullStmt * node ) { visit( const_cast<const NullStmt *>(node) ); }
89 virtual void visit( const NullStmt * nullStmt ) = 0;
90 virtual void visit( DeclStmt * node ) { visit( const_cast<const DeclStmt *>(node) ); }
91 virtual void visit( const DeclStmt * declStmt ) = 0;
92 virtual void visit( ImplicitCtorDtorStmt * node ) { visit( const_cast<const ImplicitCtorDtorStmt *>(node) ); }
93 virtual void visit( const ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
[6cebfef]94 virtual void visit( MutexStmt * node ) { visit( const_cast<const MutexStmt *>(node) ); }
95 virtual void visit( const MutexStmt * mutexStmt ) = 0;
[0dd3a2f]96
[7870799]97 virtual void visit( ApplicationExpr * node ) { visit( const_cast<const ApplicationExpr *>(node) ); }
98 virtual void visit( const ApplicationExpr * applicationExpr ) = 0;
99 virtual void visit( UntypedExpr * node ) { visit( const_cast<const UntypedExpr *>(node) ); }
100 virtual void visit( const UntypedExpr * untypedExpr ) = 0;
101 virtual void visit( NameExpr * node ) { visit( const_cast<const NameExpr *>(node) ); }
102 virtual void visit( const NameExpr * nameExpr ) = 0;
103 virtual void visit( CastExpr * node ) { visit( const_cast<const CastExpr *>(node) ); }
104 virtual void visit( const CastExpr * castExpr ) = 0;
105 virtual void visit( KeywordCastExpr * node ) { visit( const_cast<const KeywordCastExpr *>(node) ); }
106 virtual void visit( const KeywordCastExpr * castExpr ) = 0;
107 virtual void visit( VirtualCastExpr * node ) { visit( const_cast<const VirtualCastExpr *>(node) ); }
108 virtual void visit( const VirtualCastExpr * castExpr ) = 0;
109 virtual void visit( AddressExpr * node ) { visit( const_cast<const AddressExpr *>(node) ); }
110 virtual void visit( const AddressExpr * addressExpr ) = 0;
111 virtual void visit( LabelAddressExpr * node ) { visit( const_cast<const LabelAddressExpr *>(node) ); }
112 virtual void visit( const LabelAddressExpr * labAddressExpr ) = 0;
113 virtual void visit( UntypedMemberExpr * node ) { visit( const_cast<const UntypedMemberExpr *>(node) ); }
114 virtual void visit( const UntypedMemberExpr * memberExpr ) = 0;
115 virtual void visit( MemberExpr * node ) { visit( const_cast<const MemberExpr *>(node) ); }
116 virtual void visit( const MemberExpr * memberExpr ) = 0;
117 virtual void visit( VariableExpr * node ) { visit( const_cast<const VariableExpr *>(node) ); }
118 virtual void visit( const VariableExpr * variableExpr ) = 0;
119 virtual void visit( ConstantExpr * node ) { visit( const_cast<const ConstantExpr *>(node) ); }
120 virtual void visit( const ConstantExpr * constantExpr ) = 0;
121 virtual void visit( SizeofExpr * node ) { visit( const_cast<const SizeofExpr *>(node) ); }
122 virtual void visit( const SizeofExpr * sizeofExpr ) = 0;
123 virtual void visit( AlignofExpr * node ) { visit( const_cast<const AlignofExpr *>(node) ); }
124 virtual void visit( const AlignofExpr * alignofExpr ) = 0;
125 virtual void visit( UntypedOffsetofExpr * node ) { visit( const_cast<const UntypedOffsetofExpr *>(node) ); }
126 virtual void visit( const UntypedOffsetofExpr * offsetofExpr ) = 0;
127 virtual void visit( OffsetofExpr * node ) { visit( const_cast<const OffsetofExpr *>(node) ); }
128 virtual void visit( const OffsetofExpr * offsetofExpr ) = 0;
129 virtual void visit( OffsetPackExpr * node ) { visit( const_cast<const OffsetPackExpr *>(node) ); }
130 virtual void visit( const OffsetPackExpr * offsetPackExpr ) = 0;
131 virtual void visit( LogicalExpr * node ) { visit( const_cast<const LogicalExpr *>(node) ); }
132 virtual void visit( const LogicalExpr * logicalExpr ) = 0;
133 virtual void visit( ConditionalExpr * node ) { visit( const_cast<const ConditionalExpr *>(node) ); }
134 virtual void visit( const ConditionalExpr * conditionalExpr ) = 0;
135 virtual void visit( CommaExpr * node ) { visit( const_cast<const CommaExpr *>(node) ); }
136 virtual void visit( const CommaExpr * commaExpr ) = 0;
137 virtual void visit( TypeExpr * node ) { visit( const_cast<const TypeExpr *>(node) ); }
138 virtual void visit( const TypeExpr * typeExpr ) = 0;
[6e50a6b]139 virtual void visit( DimensionExpr * node ) { visit( const_cast<const DimensionExpr *>(node) ); }
140 virtual void visit( const DimensionExpr * typeExpr ) = 0;
[7870799]141 virtual void visit( AsmExpr * node ) { visit( const_cast<const AsmExpr *>(node) ); }
142 virtual void visit( const AsmExpr * asmExpr ) = 0;
143 virtual void visit( ImplicitCopyCtorExpr * node ) { visit( const_cast<const ImplicitCopyCtorExpr *>(node) ); }
144 virtual void visit( const ImplicitCopyCtorExpr * impCpCtorExpr ) = 0;
145 virtual void visit( ConstructorExpr * node ) { visit( const_cast<const ConstructorExpr *>(node) ); }
146 virtual void visit( const ConstructorExpr * ctorExpr ) = 0;
147 virtual void visit( CompoundLiteralExpr * node ) { visit( const_cast<const CompoundLiteralExpr *>(node) ); }
148 virtual void visit( const CompoundLiteralExpr * compLitExpr ) = 0;
149 virtual void visit( RangeExpr * node ) { visit( const_cast<const RangeExpr *>(node) ); }
150 virtual void visit( const RangeExpr * rangeExpr ) = 0;
151 virtual void visit( UntypedTupleExpr * node ) { visit( const_cast<const UntypedTupleExpr *>(node) ); }
152 virtual void visit( const UntypedTupleExpr * tupleExpr ) = 0;
153 virtual void visit( TupleExpr * node ) { visit( const_cast<const TupleExpr *>(node) ); }
154 virtual void visit( const TupleExpr * tupleExpr ) = 0;
155 virtual void visit( TupleIndexExpr * node ) { visit( const_cast<const TupleIndexExpr *>(node) ); }
156 virtual void visit( const TupleIndexExpr * tupleExpr ) = 0;
157 virtual void visit( TupleAssignExpr * node ) { visit( const_cast<const TupleAssignExpr *>(node) ); }
158 virtual void visit( const TupleAssignExpr * assignExpr ) = 0;
159 virtual void visit( StmtExpr * node ) { visit( const_cast<const StmtExpr *>(node) ); }
160 virtual void visit( const StmtExpr * stmtExpr ) = 0;
161 virtual void visit( UniqueExpr * node ) { visit( const_cast<const UniqueExpr *>(node) ); }
162 virtual void visit( const UniqueExpr * uniqueExpr ) = 0;
163 virtual void visit( UntypedInitExpr * node ) { visit( const_cast<const UntypedInitExpr *>(node) ); }
164 virtual void visit( const UntypedInitExpr * initExpr ) = 0;
165 virtual void visit( InitExpr * node ) { visit( const_cast<const InitExpr *>(node) ); }
166 virtual void visit( const InitExpr * initExpr ) = 0;
167 virtual void visit( DeletedExpr * node ) { visit( const_cast<const DeletedExpr *>(node) ); }
168 virtual void visit( const DeletedExpr * delExpr ) = 0;
169 virtual void visit( DefaultArgExpr * node ) { visit( const_cast<const DefaultArgExpr *>(node) ); }
170 virtual void visit( const DefaultArgExpr * argExpr ) = 0;
171 virtual void visit( GenericExpr * node ) { visit( const_cast<const GenericExpr *>(node) ); }
172 virtual void visit( const GenericExpr * genExpr ) = 0;
[0dd3a2f]173
[7870799]174 virtual void visit( VoidType * node ) { visit( const_cast<const VoidType *>(node) ); }
175 virtual void visit( const VoidType * basicType ) = 0;
176 virtual void visit( BasicType * node ) { visit( const_cast<const BasicType *>(node) ); }
177 virtual void visit( const BasicType * basicType ) = 0;
178 virtual void visit( PointerType * node ) { visit( const_cast<const PointerType *>(node) ); }
179 virtual void visit( const PointerType * pointerType ) = 0;
180 virtual void visit( ArrayType * node ) { visit( const_cast<const ArrayType *>(node) ); }
181 virtual void visit( const ArrayType * arrayType ) = 0;
182 virtual void visit( ReferenceType * node ) { visit( const_cast<const ReferenceType *>(node) ); }
183 virtual void visit( const ReferenceType * refType ) = 0;
184 virtual void visit( QualifiedType * node ) { visit( const_cast<const QualifiedType *>(node) ); }
185 virtual void visit( const QualifiedType * qualType ) = 0;
186 virtual void visit( FunctionType * node ) { visit( const_cast<const FunctionType *>(node) ); }
187 virtual void visit( const FunctionType * functionType ) = 0;
188 virtual void visit( StructInstType * node ) { visit( const_cast<const StructInstType *>(node) ); }
189 virtual void visit( const StructInstType * aggregateUseType ) = 0;
190 virtual void visit( UnionInstType * node ) { visit( const_cast<const UnionInstType *>(node) ); }
191 virtual void visit( const UnionInstType * aggregateUseType ) = 0;
[374cb117]192 virtual void visit( EnumInstType * node ) { visit( const_cast<const EnumInstType *>(node) ); }
[7870799]193 virtual void visit( const EnumInstType * aggregateUseType ) = 0;
194 virtual void visit( TraitInstType * node ) { visit( const_cast<const TraitInstType *>(node) ); }
195 virtual void visit( const TraitInstType * aggregateUseType ) = 0;
196 virtual void visit( TypeInstType * node ) { visit( const_cast<const TypeInstType *>(node) ); }
197 virtual void visit( const TypeInstType * aggregateUseType ) = 0;
198 virtual void visit( TupleType * node ) { visit( const_cast<const TupleType *>(node) ); }
199 virtual void visit( const TupleType * tupleType ) = 0;
200 virtual void visit( TypeofType * node ) { visit( const_cast<const TypeofType *>(node) ); }
201 virtual void visit( const TypeofType * typeofType ) = 0;
[7ff35e0e]202 virtual void visit( VTableType * node ) { visit( const_cast<const VTableType *>(node) ); }
203 virtual void visit( const VTableType * vtableType ) = 0;
[7870799]204 virtual void visit( AttrType * node ) { visit( const_cast<const AttrType *>(node) ); }
205 virtual void visit( const AttrType * attrType ) = 0;
206 virtual void visit( VarArgsType * node ) { visit( const_cast<const VarArgsType *>(node) ); }
207 virtual void visit( const VarArgsType * varArgsType ) = 0;
208 virtual void visit( ZeroType * node ) { visit( const_cast<const ZeroType *>(node) ); }
209 virtual void visit( const ZeroType * zeroType ) = 0;
210 virtual void visit( OneType * node ) { visit( const_cast<const OneType *>(node) ); }
211 virtual void visit( const OneType * oneType ) = 0;
212 virtual void visit( GlobalScopeType * node ) { visit( const_cast<const GlobalScopeType *>(node) ); }
213 virtual void visit( const GlobalScopeType * globalType ) = 0;
[0dd3a2f]214
[7870799]215 virtual void visit( Designation * node ) { visit( const_cast<const Designation *>(node) ); }
216 virtual void visit( const Designation * designation ) = 0;
217 virtual void visit( SingleInit * node ) { visit( const_cast<const SingleInit *>(node) ); }
218 virtual void visit( const SingleInit * singleInit ) = 0;
219 virtual void visit( ListInit * node ) { visit( const_cast<const ListInit *>(node) ); }
220 virtual void visit( const ListInit * listInit ) = 0;
221 virtual void visit( ConstructorInit * node ) { visit( const_cast<const ConstructorInit *>(node) ); }
222 virtual void visit( const ConstructorInit * ctorInit ) = 0;
[0dd3a2f]223
[7870799]224 virtual void visit( Constant * node ) { visit( const_cast<const Constant *>(node) ); }
225 virtual void visit( const Constant * constant ) = 0;
[5ea7a22]226
[7870799]227 virtual void visit( Attribute * node ) { visit( const_cast<const Attribute *>(node) ); }
228 virtual void visit( const Attribute * attribute ) = 0;
[51b73452]229};
230
231template< typename TreeType, typename VisitorType >
[6f096d2]232inline void maybeAccept( TreeType * tree, VisitorType & visitor ) {
[0dd3a2f]233 if ( tree ) {
234 tree->accept( visitor );
235 }
[51b73452]236}
237
[6f096d2]238template< typename TreeType, typename VisitorType >
239inline void maybeAccept( const TreeType * tree, VisitorType & visitor ) {
240 if ( tree ) {
241 tree->accept( visitor );
242 }
243}
244
245template< typename Container, typename VisitorType >
246inline void acceptAll( Container & container, VisitorType & visitor ) {
247 SemanticErrorException errors;
[ce12e2b]248 for ( auto * i : container ) {
[6f096d2]249 try {
250 if ( i ) {
251 i->accept( visitor );
252 }
253 } catch( SemanticErrorException & e ) {
254 errors.append( e );
255 }
256 }
257 if ( ! errors.isEmpty() ) {
258 throw errors;
259 }
260}
261
[51b73452]262template< typename Container, typename VisitorType >
[6f096d2]263inline void acceptAll( const Container & container, VisitorType & visitor ) {
[a16764a6]264 SemanticErrorException errors;
[6f096d2]265 for ( const auto * i : container ) {
[0dd3a2f]266 try {
[6f096d2]267 if ( i ) {
268 i->accept( visitor );
[0dd3a2f]269 }
[a16764a6]270 } catch( SemanticErrorException &e ) {
[0dd3a2f]271 errors.append( e );
272 }
273 }
274 if ( ! errors.isEmpty() ) {
275 throw errors;
[51b73452]276 }
277}
278
[0dd3a2f]279// Local Variables: //
280// tab-width: 4 //
281// mode: c++ //
282// compile-command: "make install" //
283// End: //
Note: See TracBrowser for help on using the repository browser.