source: src/Common/PassVisitor.impl.h @ 2a7b3ca

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since 2a7b3ca was 2a7b3ca, checked in by Rob Schluntz <rschlunt@…>, 4 years ago

convert InstantiateGeneric? to PassVisitor?, add missing mutate and accept calls to PassVisitor?, add missing ValueGuardPtrs? to PassVisitor::handleStatementList

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