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

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

remove UntypedValOfExpr? and hook in build for StmtExpr?

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