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

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

PassVisitor? now properly copes skip-children

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