source: src/Common/PassVisitor.impl.h @ 6ca154b

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since 6ca154b was 6ca154b, checked in by Thierry Delisle <tdelisle@…>, 4 years ago

PassVisitor? now supports declarations to add

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