source: src/Common/PassVisitor.impl.h@ 7e003011

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum resolv-new with_gc
Last change on this file since 7e003011 was 9c1600c, checked in by Thierry Delisle <tdelisle@…>, 8 years ago

PassVisitor now supports adding statements and using the environment when visiting as well as mutating
  • Property mode set to 100644
File size: 29.2 KB
Line 
1#pragma once
2
3#define VISIT_START( node ) \
4 call_previsit( node ); \
5
6#define VISIT_END( node ) \
7 return call_postvisit( node ); \
8
9#define MUTATE_START( node ) \
10 call_premutate( node ); \
11
12#define MUTATE_END( type, node ) \
13 return call_postmutate< type * >( node ); \
14
15
16#define VISIT_BODY( node ) \
17 VISIT_START( node ); \
18 Visitor::visit( node ); \
19 VISIT_END( node ); \
20
21
22#define MUTATE_BODY( type, node ) \
23 MUTATE_START( node ); \
24 Mutator::mutate( node ); \
25 MUTATE_END( type, node ); \
26
27
28
29template<typename T>
30static inline bool empty( T * ptr ) {
31 return !ptr || ptr->empty();
32}
33
34typedef std::list< Statement * > StmtList_t;
35
36template< typename pass_type >
37void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) {
38 SemanticError errors;
39
40 StmtList_t* beforeStmts = get_beforeStmts();
41 StmtList_t* afterStmts = get_afterStmts();
42
43 for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
44 if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); }
45 try {
46 (*i)->accept( *this );
47 } catch ( SemanticError &e ) {
48 errors.append( e );
49 }
50 if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
51 }
52
53 if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); }
54 if ( !errors.isEmpty() ) { throw errors; }
55}
56
57template< typename pass_type >
58void PassVisitor< pass_type >::mutateStatementList( std::list< Statement * > & statements ) {
59 SemanticError errors;
60
61 StmtList_t* beforeStmts = get_beforeStmts();
62 StmtList_t* afterStmts = get_afterStmts();
63
64 for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
65 if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); }
66 try {
67 *i = (*i)->acceptMutator( *this );
68 } catch ( SemanticError &e ) {
69 errors.append( e );
70 }
71 if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
72 }
73
74 if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); }
75 if ( !errors.isEmpty() ) { throw errors; }
76}
77
78template< typename pass_type >
79Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
80 // don't want statements from outer CompoundStmts to be added to this CompoundStmt
81 ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() );
82 ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
83 ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
84
85 maybeAccept( stmt, *this );
86
87 StmtList_t* beforeStmts = get_beforeStmts();
88 StmtList_t* afterStmts = get_afterStmts();
89
90 if( empty(beforeStmts) && empty(afterStmts) ) { return stmt; }
91
92 CompoundStmt *compound = new CompoundStmt( noLabels );
93 if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
94 compound->get_kids().push_back( stmt );
95 if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
96 return compound;
97}
98
99template< typename pass_type >
100Statement * PassVisitor< pass_type >::mutateStatement( Statement * stmt ) {
101 // don't want statements from outer CompoundStmts to be added to this CompoundStmt
102 ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() );
103 ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
104 ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
105
106 Statement *newStmt = maybeMutate( stmt, *this );
107
108 StmtList_t* beforeStmts = get_beforeStmts();
109 StmtList_t* afterStmts = get_afterStmts();
110
111 if( empty(beforeStmts) && empty(afterStmts) ) { return newStmt; }
112
113 CompoundStmt *compound = new CompoundStmt( noLabels );
114 if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
115 compound->get_kids().push_back( newStmt );
116 if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
117 return compound;
118}
119
120
121
122template< typename pass_type >
123void PassVisitor< pass_type >::visitExpression( Expression * expr ) {
124 if( !expr ) return;
125
126 auto env_ptr = get_env_ptr();
127 if ( env_ptr && expr->get_env() ) {
128 *env_ptr = expr->get_env();
129 }
130 // xxx - should env be cloned (or moved) onto the result of the mutate?
131 expr->accept( *this );
132}
133
134template< typename pass_type >
135Expression * PassVisitor< pass_type >::mutateExpression( Expression * expr ) {
136 if( !expr ) return nullptr;
137
138 auto env_ptr = get_env_ptr();
139 if ( env_ptr && expr->get_env() ) {
140 *env_ptr = expr->get_env();
141 }
142 // xxx - should env be cloned (or moved) onto the result of the mutate?
143 return expr->acceptMutator( *this );
144}
145
146
147//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
148
149template< typename pass_type >
150void PassVisitor< pass_type >::visit( ObjectDecl * node ) {
151 VISIT_BODY( node );
152}
153
154template< typename pass_type >
155void PassVisitor< pass_type >::visit( FunctionDecl * node ) {
156 VISIT_BODY( node );
157}
158
159template< typename pass_type >
160void PassVisitor< pass_type >::visit( StructDecl * node ) {
161 VISIT_BODY( node );
162}
163
164template< typename pass_type >
165void PassVisitor< pass_type >::visit( UnionDecl * node ) {
166 VISIT_BODY( node );
167}
168
169template< typename pass_type >
170void PassVisitor< pass_type >::visit( EnumDecl * node ) {
171 VISIT_BODY( node );
172}
173
174template< typename pass_type >
175void PassVisitor< pass_type >::visit( TraitDecl * node ) {
176 VISIT_BODY( node );
177}
178
179template< typename pass_type >
180void PassVisitor< pass_type >::visit( TypeDecl * node ) {
181 VISIT_BODY( node );
182}
183
184template< typename pass_type >
185void PassVisitor< pass_type >::visit( TypedefDecl * node ) {
186 VISIT_BODY( node );
187}
188
189template< typename pass_type >
190void PassVisitor< pass_type >::visit( AsmDecl * node ) {
191 VISIT_BODY( node );
192}
193
194//--------------------------------------------------------------------------
195// CompoundStmt
196template< typename pass_type >
197void PassVisitor< pass_type >::visit( CompoundStmt * node ) {
198 VISIT_START( node );
199 call_beginScope();
200
201 visitStatementList( node->get_kids() );
202
203 call_endScope();
204 VISIT_END( node );
205}
206
207template< typename pass_type >
208CompoundStmt * PassVisitor< pass_type >::mutate( CompoundStmt * node ) {
209 MUTATE_START( node );
210 call_beginScope();
211
212 mutateStatementList( node->get_kids() );
213
214 call_endScope();
215 MUTATE_END( CompoundStmt, node );
216}
217
218//--------------------------------------------------------------------------
219// ExprStmt
220template< typename pass_type >
221void PassVisitor< pass_type >::visit( ExprStmt * node ) {
222 VISIT_START( node );
223 call_beginScope();
224
225 visitExpression( node->get_expr() );
226
227 call_endScope();
228 VISIT_END( node );
229}
230
231template< typename pass_type >
232Statement * PassVisitor< pass_type >::mutate( ExprStmt * node ) {
233 MUTATE_START( node );
234
235 node->set_expr( mutateExpression( node->get_expr() ) );
236
237 MUTATE_END( Statement, node );
238}
239
240template< typename pass_type >
241void PassVisitor< pass_type >::visit( AsmStmt * node ) {
242 VISIT_BODY( node );
243}
244
245//--------------------------------------------------------------------------
246// IfStmt
247template< typename pass_type >
248void PassVisitor< pass_type >::visit( IfStmt * node ) {
249 VISIT_START( node );
250
251 visitExpression( node->get_condition() );
252 node->set_thenPart ( visitStatement( node->get_thenPart() ) );
253 node->set_elsePart ( visitStatement( node->get_elsePart() ) );
254
255 VISIT_END( node );
256}
257
258template< typename pass_type >
259Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) {
260 MUTATE_START( node );
261
262 node->set_condition( mutateExpression( node->get_condition() ) );
263 node->set_thenPart ( mutateStatement ( node->get_thenPart() ) );
264 node->set_elsePart ( mutateStatement ( node->get_elsePart() ) );
265
266 MUTATE_END( Statement, node );
267}
268
269//--------------------------------------------------------------------------
270// WhileStmt
271template< typename pass_type >
272void PassVisitor< pass_type >::visit( WhileStmt * node ) {
273 VISIT_START( node );
274
275 visitExpression( node->get_condition() );
276 node->set_body( visitStatement( node->get_body() ) );
277
278 VISIT_END( node );
279}
280
281template< typename pass_type >
282Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) {
283 MUTATE_START( node );
284
285 node->set_condition( mutateExpression( node->get_condition() ) );
286 node->set_body( mutateStatement( node->get_body() ) );
287
288 MUTATE_END( Statement, node );
289}
290
291//--------------------------------------------------------------------------
292// WhileStmt
293template< typename pass_type >
294void PassVisitor< pass_type >::visit( ForStmt * node ) {
295 VISIT_START( node );
296
297 acceptAll( node->get_initialization(), *this );
298 visitExpression( node->get_condition() );
299 visitExpression( node->get_increment() );
300 node->set_body( visitStatement( node->get_body() ) );
301
302 VISIT_END( node );
303}
304
305template< typename pass_type >
306Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) {
307 MUTATE_START( node );
308
309 mutateAll( node->get_initialization(), *this );
310 node->set_condition( mutateExpression( node->get_condition() ) );
311 node->set_increment( mutateExpression( node->get_increment() ) );
312 node->set_body( mutateStatement( node->get_body() ) );
313
314 MUTATE_END( Statement, node );
315}
316
317//--------------------------------------------------------------------------
318// SwitchStmt
319template< typename pass_type >
320void PassVisitor< pass_type >::visit( SwitchStmt * node ) {
321 VISIT_START( node );
322
323 visitExpression( node->get_condition() );
324 visitStatementList( node->get_statements() );
325
326 VISIT_END( node );
327}
328
329template< typename pass_type >
330Statement * PassVisitor< pass_type >::mutate( SwitchStmt * node ) {
331 MUTATE_START( node );
332
333 node->set_condition( mutateExpression( node->get_condition() ) );
334 mutateStatementList( node->get_statements() );
335
336 MUTATE_END( Statement, node );
337}
338
339//--------------------------------------------------------------------------
340// SwitchStmt
341template< typename pass_type >
342void PassVisitor< pass_type >::visit( CaseStmt * node ) {
343 VISIT_START( node );
344
345 visitExpression( node->get_condition() );
346 visitStatementList( node->get_statements() );
347
348 VISIT_END( node );
349}
350
351template< typename pass_type >
352Statement * PassVisitor< pass_type >::mutate( CaseStmt * node ) {
353 MUTATE_START( node );
354
355 node->set_condition( mutateExpression( node->get_condition() ) );
356 mutateStatementList( node->get_statements() );
357
358 MUTATE_END( Statement, node );
359}
360
361template< typename pass_type >
362void PassVisitor< pass_type >::visit( BranchStmt * node ) {
363 VISIT_BODY( node );
364}
365
366//--------------------------------------------------------------------------
367// ReturnStmt
368template< typename pass_type >
369void PassVisitor< pass_type >::visit( ReturnStmt * node ) {
370 VISIT_START( node );
371
372 visitExpression( node->get_expr() );
373
374 VISIT_END( node );
375}
376
377template< typename pass_type >
378Statement * PassVisitor< pass_type >::mutate( ReturnStmt * node ) {
379 MUTATE_START( node );
380
381 node->set_expr( mutateExpression( node->get_expr() ) );
382
383 MUTATE_END( Statement, node );
384}
385
386//--------------------------------------------------------------------------
387// TryStmt
388template< typename pass_type >
389void PassVisitor< pass_type >::visit( TryStmt * node ) {
390 VISIT_START( node );
391
392 maybeAccept( node->get_block(), *this );
393 acceptAll( node->get_catchers(), *this );
394
395 VISIT_END( node );
396}
397
398template< typename pass_type >
399Statement * PassVisitor< pass_type >::mutate( TryStmt * node ) {
400 MUTATE_START( node );
401
402 node->set_block( maybeMutate( node->get_block(), *this ) );
403 mutateAll( node->get_catchers(), *this );
404
405 MUTATE_END( Statement, node );
406}
407
408//--------------------------------------------------------------------------
409// CatchStmt
410template< typename pass_type >
411void PassVisitor< pass_type >::visit( CatchStmt * node ) {
412 VISIT_START( node );
413
414 node->set_body( visitStatement( node->get_body() ) );
415 maybeAccept( node->get_decl(), *this );
416
417 VISIT_END( node );
418}
419
420template< typename pass_type >
421Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) {
422 MUTATE_START( node );
423
424 node->set_body( mutateStatement( node->get_body() ) );
425 node->set_decl( maybeMutate( node->get_decl(), *this ) );
426
427 MUTATE_END( Statement, node );
428}
429
430template< typename pass_type >
431void PassVisitor< pass_type >::visit( FinallyStmt * node ) {
432 VISIT_BODY( node );
433}
434
435template< typename pass_type >
436void PassVisitor< pass_type >::visit( NullStmt * node ) {
437 VISIT_BODY( node );
438}
439
440template< typename pass_type >
441void PassVisitor< pass_type >::visit( DeclStmt * node ) {
442 VISIT_BODY( node );
443}
444
445template< typename pass_type >
446void PassVisitor< pass_type >::visit( ImplicitCtorDtorStmt * node ) {
447 VISIT_BODY( node );
448}
449
450template< typename pass_type >
451void PassVisitor< pass_type >::visit( ApplicationExpr * node ) {
452 VISIT_BODY( node );
453}
454
455//--------------------------------------------------------------------------
456// UntypedExpr
457template< typename pass_type >
458void PassVisitor< pass_type >::visit( UntypedExpr * node ) {
459 VISIT_START( node );
460
461 for ( auto expr : node->get_args() ) {
462 visitExpression( expr );
463 }
464
465 VISIT_END( node );
466}
467
468template< typename pass_type >
469Expression * PassVisitor< pass_type >::mutate( UntypedExpr * node ) {
470 MUTATE_START( node );
471
472 for ( auto& expr : node->get_args() ) {
473 expr = mutateExpression( expr );
474 }
475
476 MUTATE_END( Expression, node );
477}
478
479template< typename pass_type >
480void PassVisitor< pass_type >::visit( NameExpr * node ) {
481 VISIT_BODY( node );
482}
483
484template< typename pass_type >
485void PassVisitor< pass_type >::visit( CastExpr * node ) {
486 VISIT_BODY( node );
487}
488
489template< typename pass_type >
490void PassVisitor< pass_type >::visit( AddressExpr * node ) {
491 VISIT_BODY( node );
492}
493
494template< typename pass_type >
495void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) {
496 VISIT_BODY( node );
497}
498
499template< typename pass_type >
500void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) {
501 VISIT_BODY( node );
502}
503
504template< typename pass_type >
505void PassVisitor< pass_type >::visit( MemberExpr * node ) {
506 VISIT_BODY( node );
507}
508
509template< typename pass_type >
510void PassVisitor< pass_type >::visit( VariableExpr * node ) {
511 VISIT_BODY( node );
512}
513
514template< typename pass_type >
515void PassVisitor< pass_type >::visit( ConstantExpr * node ) {
516 VISIT_BODY( node );
517}
518
519template< typename pass_type >
520void PassVisitor< pass_type >::visit( SizeofExpr * node ) {
521 VISIT_BODY( node );
522}
523
524template< typename pass_type >
525void PassVisitor< pass_type >::visit( AlignofExpr * node ) {
526 VISIT_BODY( node );
527}
528
529template< typename pass_type >
530void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) {
531 VISIT_BODY( node );
532}
533
534template< typename pass_type >
535void PassVisitor< pass_type >::visit( OffsetofExpr * node ) {
536 VISIT_BODY( node );
537}
538
539template< typename pass_type >
540void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) {
541 VISIT_BODY( node );
542}
543
544template< typename pass_type >
545void PassVisitor< pass_type >::visit( AttrExpr * node ) {
546 VISIT_BODY( node );
547}
548
549template< typename pass_type >
550void PassVisitor< pass_type >::visit( LogicalExpr * node ) {
551 VISIT_BODY( node );
552}
553
554template< typename pass_type >
555void PassVisitor< pass_type >::visit( ConditionalExpr * node ) {
556 VISIT_BODY( node );
557}
558
559template< typename pass_type >
560void PassVisitor< pass_type >::visit( CommaExpr * node ) {
561 VISIT_BODY( node );
562}
563
564template< typename pass_type >
565void PassVisitor< pass_type >::visit( TypeExpr * node ) {
566 VISIT_BODY( node );
567}
568
569template< typename pass_type >
570void PassVisitor< pass_type >::visit( AsmExpr * node ) {
571 VISIT_BODY( node );
572}
573
574template< typename pass_type >
575void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) {
576 VISIT_BODY( node );
577}
578
579template< typename pass_type >
580void PassVisitor< pass_type >::visit( ConstructorExpr * node ) {
581 VISIT_BODY( node );
582}
583
584template< typename pass_type >
585void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) {
586 VISIT_BODY( node );
587}
588
589template< typename pass_type >
590void PassVisitor< pass_type >::visit( UntypedValofExpr * node ) {
591 VISIT_BODY( node );
592}
593
594template< typename pass_type >
595void PassVisitor< pass_type >::visit( RangeExpr * node ) {
596 VISIT_BODY( node );
597}
598
599template< typename pass_type >
600void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) {
601 VISIT_BODY( node );
602}
603
604template< typename pass_type >
605void PassVisitor< pass_type >::visit( TupleExpr * node ) {
606 VISIT_BODY( node );
607}
608
609template< typename pass_type >
610void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) {
611 VISIT_BODY( node );
612}
613
614template< typename pass_type >
615void PassVisitor< pass_type >::visit( MemberTupleExpr * node ) {
616 VISIT_BODY( node );
617}
618
619template< typename pass_type >
620void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) {
621 VISIT_BODY( node );
622}
623
624//--------------------------------------------------------------------------
625// UntypedExpr
626template< typename pass_type >
627void PassVisitor< pass_type >::visit( StmtExpr * node ) {
628 VISIT_START( node );
629
630 // don't want statements from outer CompoundStmts to be added to this StmtExpr
631 ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() );
632 ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
633 ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
634
635 Visitor::visit( node );
636
637 VISIT_END( node );
638}
639
640template< typename pass_type >
641Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) {
642 MUTATE_START( node );
643
644 // don't want statements from outer CompoundStmts to be added to this StmtExpr
645 ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() );
646 ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
647 ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
648
649 Mutator::mutate( node );
650
651 MUTATE_END( Expression, node );
652}
653
654template< typename pass_type >
655void PassVisitor< pass_type >::visit( UniqueExpr * node ) {
656 VISIT_BODY( node );
657}
658
659template< typename pass_type >
660void PassVisitor< pass_type >::visit( VoidType * node ) {
661 VISIT_BODY( node );
662}
663
664template< typename pass_type >
665void PassVisitor< pass_type >::visit( BasicType * node ) {
666 VISIT_BODY( node );
667}
668
669template< typename pass_type >
670void PassVisitor< pass_type >::visit( PointerType * node ) {
671 VISIT_BODY( node );
672}
673
674template< typename pass_type >
675void PassVisitor< pass_type >::visit( ArrayType * node ) {
676 VISIT_BODY( node );
677}
678
679template< typename pass_type >
680void PassVisitor< pass_type >::visit( FunctionType * node ) {
681 VISIT_BODY( node );
682}
683
684template< typename pass_type >
685void PassVisitor< pass_type >::visit( StructInstType * node ) {
686 VISIT_BODY( node );
687}
688
689template< typename pass_type >
690void PassVisitor< pass_type >::visit( UnionInstType * node ) {
691 VISIT_BODY( node );
692}
693
694template< typename pass_type >
695void PassVisitor< pass_type >::visit( EnumInstType * node ) {
696 VISIT_BODY( node );
697}
698
699template< typename pass_type >
700void PassVisitor< pass_type >::visit( TraitInstType * node ) {
701 VISIT_BODY( node );
702}
703
704template< typename pass_type >
705void PassVisitor< pass_type >::visit( TypeInstType * node ) {
706 VISIT_BODY( node );
707}
708
709template< typename pass_type >
710void PassVisitor< pass_type >::visit( TupleType * node ) {
711 VISIT_BODY( node );
712}
713
714template< typename pass_type >
715void PassVisitor< pass_type >::visit( TypeofType * node ) {
716 VISIT_BODY( node );
717}
718
719template< typename pass_type >
720void PassVisitor< pass_type >::visit( AttrType * node ) {
721 VISIT_BODY( node );
722}
723
724template< typename pass_type >
725void PassVisitor< pass_type >::visit( VarArgsType * node ) {
726 VISIT_BODY( node );
727}
728
729template< typename pass_type >
730void PassVisitor< pass_type >::visit( ZeroType * node ) {
731 VISIT_BODY( node );
732}
733
734template< typename pass_type >
735void PassVisitor< pass_type >::visit( OneType * node ) {
736 VISIT_BODY( node );
737}
738
739//--------------------------------------------------------------------------
740// UntypedExpr
741template< typename pass_type >
742void PassVisitor< pass_type >::visit( SingleInit * node ) {
743 VISIT_START( node );
744
745 visitExpression( node->get_value() );
746
747 VISIT_END( node );
748}
749
750template< typename pass_type >
751Initializer * PassVisitor< pass_type >::mutate( SingleInit * node ) {
752 MUTATE_START( node );
753
754 node->set_value( mutateExpression( node->get_value() ) );
755
756 MUTATE_END( Initializer, node );
757}
758
759template< typename pass_type >
760void PassVisitor< pass_type >::visit( ListInit * node ) {
761 VISIT_BODY( node );
762}
763
764template< typename pass_type >
765void PassVisitor< pass_type >::visit( ConstructorInit * node ) {
766 VISIT_BODY( node );
767}
768
769template< typename pass_type >
770void PassVisitor< pass_type >::visit( Subrange * node ) {
771 VISIT_BODY( node );
772}
773
774template< typename pass_type >
775void PassVisitor< pass_type >::visit( Constant * node ) {
776 VISIT_BODY( node );
777}
778
779//---------------------------------------------------------------------------------------------------------------
780
781template< typename pass_type >
782DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) {
783 MUTATE_BODY( DeclarationWithType, node );
784}
785
786template< typename pass_type >
787DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) {
788 MUTATE_BODY( DeclarationWithType, node );
789}
790
791template< typename pass_type >
792Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
793 MUTATE_BODY( Declaration, node );
794}
795
796template< typename pass_type >
797Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) {
798 MUTATE_BODY( Declaration, node );
799}
800
801template< typename pass_type >
802Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) {
803 MUTATE_BODY( Declaration, node );
804}
805
806template< typename pass_type >
807Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) {
808 MUTATE_BODY( Declaration, node );
809}
810
811template< typename pass_type >
812TypeDecl * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
813 MUTATE_BODY( TypeDecl, node );
814}
815
816template< typename pass_type >
817Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) {
818 MUTATE_BODY( Declaration, node );
819}
820
821template< typename pass_type >
822AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) {
823 MUTATE_BODY( AsmDecl, node );
824}
825
826template< typename pass_type >
827Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
828 MUTATE_BODY( Statement, node );
829}
830
831template< typename pass_type >
832Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
833 MUTATE_BODY( Statement, node );
834}
835
836template< typename pass_type >
837Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) {
838 MUTATE_BODY( Statement, node );
839}
840
841template< typename pass_type >
842NullStmt * PassVisitor< pass_type >::mutate( NullStmt * node ) {
843 MUTATE_BODY( NullStmt, node );
844}
845
846template< typename pass_type >
847Statement * PassVisitor< pass_type >::mutate( DeclStmt * node ) {
848 MUTATE_BODY( Statement, node );
849}
850
851template< typename pass_type >
852Statement * PassVisitor< pass_type >::mutate( ImplicitCtorDtorStmt * node ) {
853 MUTATE_BODY( Statement, node );
854}
855
856template< typename pass_type >
857Expression * PassVisitor< pass_type >::mutate( ApplicationExpr * node ) {
858 MUTATE_BODY( Expression, node );
859}
860
861template< typename pass_type >
862Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) {
863 MUTATE_BODY( Expression, node );
864}
865
866template< typename pass_type >
867Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) {
868 MUTATE_BODY( Expression, node );
869}
870
871template< typename pass_type >
872Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) {
873 MUTATE_BODY( Expression, node );
874}
875
876template< typename pass_type >
877Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) {
878 MUTATE_BODY( Expression, node );
879}
880
881template< typename pass_type >
882Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) {
883 MUTATE_BODY( Expression, node );
884}
885
886template< typename pass_type >
887Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) {
888 MUTATE_BODY( Expression, node );
889}
890
891template< typename pass_type >
892Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) {
893 MUTATE_BODY( Expression, node );
894}
895
896template< typename pass_type >
897Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) {
898 MUTATE_BODY( Expression, node );
899}
900
901template< typename pass_type >
902Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) {
903 MUTATE_BODY( Expression, node );
904}
905
906template< typename pass_type >
907Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) {
908 MUTATE_BODY( Expression, node );
909}
910
911template< typename pass_type >
912Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) {
913 MUTATE_BODY( Expression, node );
914}
915
916template< typename pass_type >
917Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) {
918 MUTATE_BODY( Expression, node );
919}
920
921template< typename pass_type >
922Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) {
923 MUTATE_BODY( Expression, node );
924}
925
926template< typename pass_type >
927Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) {
928 MUTATE_BODY( Expression, node );
929}
930
931template< typename pass_type >
932Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) {
933 MUTATE_BODY( Expression, node );
934}
935
936template< typename pass_type >
937Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) {
938 MUTATE_BODY( Expression, node );
939}
940
941template< typename pass_type >
942Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) {
943 MUTATE_BODY( Expression, node );
944}
945
946template< typename pass_type >
947Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) {
948 MUTATE_BODY( Expression, node );
949}
950
951template< typename pass_type >
952Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) {
953 MUTATE_BODY( Expression, node );
954}
955
956template< typename pass_type >
957Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) {
958 MUTATE_BODY( Expression, node );
959}
960
961template< typename pass_type >
962Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) {
963 MUTATE_BODY( Expression, node );
964}
965
966template< typename pass_type >
967Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) {
968 MUTATE_BODY( Expression, node );
969}
970
971template< typename pass_type >
972Expression * PassVisitor< pass_type >::mutate( UntypedValofExpr * node ) {
973 MUTATE_BODY( Expression, node );
974}
975
976template< typename pass_type >
977Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
978 MUTATE_BODY( Expression, node );
979}
980
981template< typename pass_type >
982Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) {
983 MUTATE_BODY( Expression, node );
984}
985
986template< typename pass_type >
987Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) {
988 MUTATE_BODY( Expression, node );
989}
990
991template< typename pass_type >
992Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) {
993 MUTATE_BODY( Expression, node );
994}
995
996template< typename pass_type >
997Expression * PassVisitor< pass_type >::mutate( MemberTupleExpr * node ) {
998 MUTATE_BODY( Expression, node );
999}
1000
1001template< typename pass_type >
1002Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) {
1003 MUTATE_BODY( Expression, node );
1004}
1005
1006template< typename pass_type >
1007Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) {
1008 MUTATE_BODY( Expression, node );
1009}
1010
1011template< typename pass_type >
1012Type * PassVisitor< pass_type >::mutate( VoidType * node ) {
1013 MUTATE_BODY( Type, node );
1014}
1015
1016template< typename pass_type >
1017Type * PassVisitor< pass_type >::mutate( BasicType * node ) {
1018 MUTATE_BODY( Type, node );
1019}
1020
1021template< typename pass_type >
1022Type * PassVisitor< pass_type >::mutate( PointerType * node ) {
1023 MUTATE_BODY( Type, node );
1024}
1025
1026template< typename pass_type >
1027Type * PassVisitor< pass_type >::mutate( ArrayType * node ) {
1028 MUTATE_BODY( Type, node );
1029}
1030
1031template< typename pass_type >
1032Type * PassVisitor< pass_type >::mutate( FunctionType * node ) {
1033 MUTATE_BODY( Type, node );
1034}
1035
1036template< typename pass_type >
1037Type * PassVisitor< pass_type >::mutate( StructInstType * node ) {
1038 MUTATE_BODY( Type, node );
1039}
1040
1041template< typename pass_type >
1042Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) {
1043 MUTATE_BODY( Type, node );
1044}
1045
1046template< typename pass_type >
1047Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) {
1048 MUTATE_BODY( Type, node );
1049}
1050
1051template< typename pass_type >
1052Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) {
1053 MUTATE_BODY( Type, node );
1054}
1055
1056template< typename pass_type >
1057Type * PassVisitor< pass_type >::mutate( TypeInstType * node ) {
1058 MUTATE_BODY( Type, node );
1059}
1060
1061template< typename pass_type >
1062Type * PassVisitor< pass_type >::mutate( TupleType * node ) {
1063 MUTATE_BODY( Type, node );
1064}
1065
1066template< typename pass_type >
1067Type * PassVisitor< pass_type >::mutate( TypeofType * node ) {
1068 MUTATE_BODY( Type, node );
1069}
1070
1071template< typename pass_type >
1072Type * PassVisitor< pass_type >::mutate( AttrType * node ) {
1073 MUTATE_BODY( Type, node );
1074}
1075
1076template< typename pass_type >
1077Type * PassVisitor< pass_type >::mutate( VarArgsType * node ) {
1078 MUTATE_BODY( Type, node );
1079}
1080
1081template< typename pass_type >
1082Type * PassVisitor< pass_type >::mutate( ZeroType * node ) {
1083 MUTATE_BODY( Type, node );
1084}
1085
1086template< typename pass_type >
1087Type * PassVisitor< pass_type >::mutate( OneType * node ) {
1088 MUTATE_BODY( Type, node );
1089}
1090
1091template< typename pass_type >
1092Initializer * PassVisitor< pass_type >::mutate( ListInit * node ) {
1093 MUTATE_BODY( Initializer, node );
1094}
1095
1096template< typename pass_type >
1097Initializer * PassVisitor< pass_type >::mutate( ConstructorInit * node ) {
1098 MUTATE_BODY( Initializer, node );
1099}
1100
1101template< typename pass_type >
1102Subrange * PassVisitor< pass_type >::mutate( Subrange * node ) {
1103 MUTATE_BODY( Subrange, node );
1104}
1105
1106template< typename pass_type >
1107Constant * PassVisitor< pass_type >::mutate( Constant * node ) {
1108 MUTATE_BODY( Constant, node );
1109}
Note: See TracBrowser for help on using the repository browser.