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

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

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