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

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since af397ef8 was 7b13aeb, checked in by Thierry Delisle <tdelisle@…>, 7 years ago

PassVisitor? now supports field skip_children
  • Property mode set to 100644
File size: 29.3 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( MemberTupleExpr * node ) {
620        VISIT_BODY( node ); 
621}
622
623template< typename pass_type >
624void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) {
625        VISIT_BODY( node ); 
626}
627
628//--------------------------------------------------------------------------
629// UntypedExpr
630template< typename pass_type >
631void PassVisitor< pass_type >::visit( StmtExpr * node ) {
632        VISIT_START( node );
633
634        // don't want statements from outer CompoundStmts to be added to this StmtExpr
635        ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
636        ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
637        ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
638
639        Visitor::visit( node );
640
641        VISIT_END( node );
642}
643
644template< typename pass_type >
645Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) {
646        MUTATE_START( node );
647       
648        // don't want statements from outer CompoundStmts to be added to this StmtExpr
649        ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
650        ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
651        ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
652
653        Mutator::mutate( node );
654
655        MUTATE_END( Expression, node );
656}
657
658template< typename pass_type >
659void PassVisitor< pass_type >::visit( UniqueExpr * node ) {
660        VISIT_BODY( node ); 
661}
662
663template< typename pass_type >
664void PassVisitor< pass_type >::visit( VoidType * node ) {
665        VISIT_BODY( node ); 
666}
667
668template< typename pass_type >
669void PassVisitor< pass_type >::visit( BasicType * node ) {
670        VISIT_BODY( node ); 
671}
672
673template< typename pass_type >
674void PassVisitor< pass_type >::visit( PointerType * node ) {
675        VISIT_BODY( node ); 
676}
677
678template< typename pass_type >
679void PassVisitor< pass_type >::visit( ArrayType * node ) {
680        VISIT_BODY( node ); 
681}
682
683template< typename pass_type >
684void PassVisitor< pass_type >::visit( FunctionType * node ) {
685        VISIT_BODY( node ); 
686}
687
688template< typename pass_type >
689void PassVisitor< pass_type >::visit( StructInstType * node ) {
690        VISIT_BODY( node ); 
691}
692
693template< typename pass_type >
694void PassVisitor< pass_type >::visit( UnionInstType * node ) {
695        VISIT_BODY( node ); 
696}
697
698template< typename pass_type >
699void PassVisitor< pass_type >::visit( EnumInstType * node ) {
700        VISIT_BODY( node ); 
701}
702
703template< typename pass_type >
704void PassVisitor< pass_type >::visit( TraitInstType * node ) {
705        VISIT_BODY( node ); 
706}
707
708template< typename pass_type >
709void PassVisitor< pass_type >::visit( TypeInstType * node ) {
710        VISIT_BODY( node ); 
711}
712
713template< typename pass_type >
714void PassVisitor< pass_type >::visit( TupleType * node ) {
715        VISIT_BODY( node ); 
716}
717
718template< typename pass_type >
719void PassVisitor< pass_type >::visit( TypeofType * node ) {
720        VISIT_BODY( node ); 
721}
722
723template< typename pass_type >
724void PassVisitor< pass_type >::visit( AttrType * node ) {
725        VISIT_BODY( node ); 
726}
727
728template< typename pass_type >
729void PassVisitor< pass_type >::visit( VarArgsType * node ) {
730        VISIT_BODY( node ); 
731}
732
733template< typename pass_type >
734void PassVisitor< pass_type >::visit( ZeroType * node ) {
735        VISIT_BODY( node ); 
736}
737
738template< typename pass_type >
739void PassVisitor< pass_type >::visit( OneType * node ) {
740        VISIT_BODY( node ); 
741}
742
743//--------------------------------------------------------------------------
744// UntypedExpr
745template< typename pass_type >
746void PassVisitor< pass_type >::visit( SingleInit * node ) {
747        VISIT_START( node );
748
749        visitExpression( node->get_value() );
750
751        VISIT_END( node );
752}
753
754template< typename pass_type >
755Initializer * PassVisitor< pass_type >::mutate( SingleInit * node ) {
756        MUTATE_START( node );
757
758        node->set_value( mutateExpression( node->get_value() ) );
759
760        MUTATE_END( Initializer, node );
761}
762
763template< typename pass_type >
764void PassVisitor< pass_type >::visit( ListInit * node ) {
765        VISIT_BODY( node ); 
766}
767
768template< typename pass_type >
769void PassVisitor< pass_type >::visit( ConstructorInit * node ) {
770        VISIT_BODY( node ); 
771}
772
773template< typename pass_type >
774void PassVisitor< pass_type >::visit( Subrange * node ) {
775        VISIT_BODY( node ); 
776}
777
778template< typename pass_type >
779void PassVisitor< pass_type >::visit( Constant * node ) {
780        VISIT_BODY( node ); 
781}
782
783//---------------------------------------------------------------------------------------------------------------
784
785template< typename pass_type >
786DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) {
787        MUTATE_BODY( DeclarationWithType, node );
788}
789
790template< typename pass_type >
791DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) {
792        MUTATE_BODY( DeclarationWithType, node );
793}
794
795template< typename pass_type >
796Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
797        MUTATE_BODY( Declaration, node );
798}
799
800template< typename pass_type >
801Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) {
802        MUTATE_BODY( Declaration, node );
803}
804
805template< typename pass_type >
806Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) {
807        MUTATE_BODY( Declaration, node );
808}
809
810template< typename pass_type >
811Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) {
812        MUTATE_BODY( Declaration, node );
813}
814
815template< typename pass_type >
816TypeDecl * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
817        MUTATE_BODY( TypeDecl, node );
818}
819
820template< typename pass_type >
821Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) {
822        MUTATE_BODY( Declaration, node );
823}
824
825template< typename pass_type >
826AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) {
827        MUTATE_BODY( AsmDecl, node );
828}
829
830template< typename pass_type >
831Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
832        MUTATE_BODY( Statement, node );
833}
834
835template< typename pass_type >
836Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
837        MUTATE_BODY( Statement, node );
838}
839
840template< typename pass_type >
841Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) {
842        MUTATE_BODY( Statement, node );
843}
844
845template< typename pass_type >
846NullStmt * PassVisitor< pass_type >::mutate( NullStmt * node ) {
847        MUTATE_BODY( NullStmt, node );
848}
849
850template< typename pass_type >
851Statement * PassVisitor< pass_type >::mutate( DeclStmt * node ) {
852        MUTATE_BODY( Statement, node );
853}
854
855template< typename pass_type >
856Statement * PassVisitor< pass_type >::mutate( ImplicitCtorDtorStmt * node ) {
857        MUTATE_BODY( Statement, node );
858}
859
860template< typename pass_type >
861Expression * PassVisitor< pass_type >::mutate( ApplicationExpr * node ) {
862        MUTATE_BODY( Expression, node );
863}
864
865template< typename pass_type >
866Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) {
867        MUTATE_BODY( Expression, node );
868}
869
870template< typename pass_type >
871Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) {
872        MUTATE_BODY( Expression, node );
873}
874
875template< typename pass_type >
876Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) {
877        MUTATE_BODY( Expression, node );
878}
879
880template< typename pass_type >
881Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) {
882        MUTATE_BODY( Expression, node );
883}
884
885template< typename pass_type >
886Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) {
887        MUTATE_BODY( Expression, node );
888}
889
890template< typename pass_type >
891Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) {
892        MUTATE_BODY( Expression, node );
893}
894
895template< typename pass_type >
896Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) {
897        MUTATE_BODY( Expression, node );
898}
899
900template< typename pass_type >
901Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) {
902        MUTATE_BODY( Expression, node );
903}
904
905template< typename pass_type >
906Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) {
907        MUTATE_BODY( Expression, node );
908}
909
910template< typename pass_type >
911Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) {
912        MUTATE_BODY( Expression, node );
913}
914
915template< typename pass_type >
916Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) {
917        MUTATE_BODY( Expression, node );
918}
919
920template< typename pass_type >
921Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) {
922        MUTATE_BODY( Expression, node );
923}
924
925template< typename pass_type >
926Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) {
927        MUTATE_BODY( Expression, node );
928}
929
930template< typename pass_type >
931Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) {
932        MUTATE_BODY( Expression, node );
933}
934
935template< typename pass_type >
936Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) {
937        MUTATE_BODY( Expression, node );
938}
939
940template< typename pass_type >
941Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) {
942        MUTATE_BODY( Expression, node );
943}
944
945template< typename pass_type >
946Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) {
947        MUTATE_BODY( Expression, node );
948}
949
950template< typename pass_type >
951Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) {
952        MUTATE_BODY( Expression, node );
953}
954
955template< typename pass_type >
956Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) {
957        MUTATE_BODY( Expression, node );
958}
959
960template< typename pass_type >
961Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) {
962        MUTATE_BODY( Expression, node );
963}
964
965template< typename pass_type >
966Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) {
967        MUTATE_BODY( Expression, node );
968}
969
970template< typename pass_type >
971Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) {
972        MUTATE_BODY( Expression, node );
973}
974
975template< typename pass_type >
976Expression * PassVisitor< pass_type >::mutate( UntypedValofExpr * node ) {
977        MUTATE_BODY( Expression, node );
978}
979
980template< typename pass_type >
981Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
982        MUTATE_BODY( Expression, node );
983}
984
985template< typename pass_type >
986Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) {
987        MUTATE_BODY( Expression, node );
988}
989
990template< typename pass_type >
991Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) {
992        MUTATE_BODY( Expression, node );
993}
994
995template< typename pass_type >
996Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) {
997        MUTATE_BODY( Expression, node );
998}
999
1000template< typename pass_type >
1001Expression * PassVisitor< pass_type >::mutate( MemberTupleExpr * node ) {
1002        MUTATE_BODY( Expression, node );
1003}
1004
1005template< typename pass_type >
1006Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) {
1007        MUTATE_BODY( Expression, node );
1008}
1009
1010template< typename pass_type >
1011Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) {
1012        MUTATE_BODY( Expression, node );
1013}
1014
1015template< typename pass_type >
1016Type * PassVisitor< pass_type >::mutate( VoidType * node ) {
1017        MUTATE_BODY( Type, node );
1018}
1019
1020template< typename pass_type >
1021Type * PassVisitor< pass_type >::mutate( BasicType * node ) {
1022        MUTATE_BODY( Type, node );
1023}
1024
1025template< typename pass_type >
1026Type * PassVisitor< pass_type >::mutate( PointerType * node ) {
1027        MUTATE_BODY( Type, node );
1028}
1029
1030template< typename pass_type >
1031Type * PassVisitor< pass_type >::mutate( ArrayType * node ) {
1032        MUTATE_BODY( Type, node );
1033}
1034
1035template< typename pass_type >
1036Type * PassVisitor< pass_type >::mutate( FunctionType * node ) {
1037        MUTATE_BODY( Type, node );
1038}
1039
1040template< typename pass_type >
1041Type * PassVisitor< pass_type >::mutate( StructInstType * node ) {
1042        MUTATE_BODY( Type, node );
1043}
1044
1045template< typename pass_type >
1046Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) {
1047        MUTATE_BODY( Type, node );
1048}
1049
1050template< typename pass_type >
1051Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) {
1052        MUTATE_BODY( Type, node );
1053}
1054
1055template< typename pass_type >
1056Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) {
1057        MUTATE_BODY( Type, node );
1058}
1059
1060template< typename pass_type >
1061Type * PassVisitor< pass_type >::mutate( TypeInstType * node ) {
1062        MUTATE_BODY( Type, node );
1063}
1064
1065template< typename pass_type >
1066Type * PassVisitor< pass_type >::mutate( TupleType * node ) {
1067        MUTATE_BODY( Type, node );
1068}
1069
1070template< typename pass_type >
1071Type * PassVisitor< pass_type >::mutate( TypeofType * node ) {
1072        MUTATE_BODY( Type, node );
1073}
1074
1075template< typename pass_type >
1076Type * PassVisitor< pass_type >::mutate( AttrType * node ) {
1077        MUTATE_BODY( Type, node );
1078}
1079
1080template< typename pass_type >
1081Type * PassVisitor< pass_type >::mutate( VarArgsType * node ) {
1082        MUTATE_BODY( Type, node );
1083}
1084
1085template< typename pass_type >
1086Type * PassVisitor< pass_type >::mutate( ZeroType * node ) {
1087        MUTATE_BODY( Type, node );
1088}
1089
1090template< typename pass_type >
1091Type * PassVisitor< pass_type >::mutate( OneType * node ) {
1092        MUTATE_BODY( Type, node );
1093}
1094
1095template< typename pass_type >
1096Initializer * PassVisitor< pass_type >::mutate( ListInit * node ) {
1097        MUTATE_BODY( Initializer, node );
1098}
1099
1100template< typename pass_type >
1101Initializer * PassVisitor< pass_type >::mutate( ConstructorInit * node ) {
1102        MUTATE_BODY( Initializer, node );
1103}
1104
1105template< typename pass_type >
1106Subrange * PassVisitor< pass_type >::mutate( Subrange * node  )  {
1107        MUTATE_BODY( Subrange, node );
1108}
1109
1110template< typename pass_type >
1111Constant * PassVisitor< pass_type >::mutate( Constant * node  )  {
1112        MUTATE_BODY( Constant, node );
1113}
Note: See TracBrowser for help on using the repository browser.