source: src/Common/PassVisitor.impl.h@ ba912706

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 ba912706 was b73bd70, checked in by Thierry Delisle <tdelisle@…>, 8 years ago

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