source: src/Common/PassVisitor.impl.h @ 96f9ef5

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

Modify TypeDecl? mutate to return a Declaration

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