source: src/Common/PassVisitor.impl.h @ 9c1600c

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since 9c1600c was 9c1600c, checked in by Thierry Delisle <tdelisle@…>, 6 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.