source: src/Common/PassVisitor.impl.h@ 5e298d7

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum resolv-new with_gc
Last change on this file since 5e298d7 was 6e09f211, checked in by Thierry Delisle <tdelisle@…>, 8 years ago

Pass visitor:

  • added support for throw statment
  • now resets skip children flag after reading it
  • prototype for value guard alternative (Still un-tested)
  • Property mode set to 100644
File size: 29.8 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 reset_visit(); \
9
10#define VISIT_END( node ) \
11 } \
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 reset_visit(); \
20
21#define MUTATE_END( type, node ) \
22 } \
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( UntypedValofExpr * node ) {
614 VISIT_BODY( node );
615}
616
617template< typename pass_type >
618void PassVisitor< pass_type >::visit( RangeExpr * node ) {
619 VISIT_BODY( node );
620}
621
622template< typename pass_type >
623void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) {
624 VISIT_BODY( node );
625}
626
627template< typename pass_type >
628void PassVisitor< pass_type >::visit( TupleExpr * node ) {
629 VISIT_BODY( node );
630}
631
632template< typename pass_type >
633void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) {
634 VISIT_BODY( node );
635}
636
637template< typename pass_type >
638void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) {
639 VISIT_BODY( node );
640}
641
642//--------------------------------------------------------------------------
643// UntypedExpr
644template< typename pass_type >
645void PassVisitor< pass_type >::visit( StmtExpr * node ) {
646 VISIT_START( node );
647
648 // don't want statements from outer CompoundStmts to be added to this StmtExpr
649 ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() );
650 ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
651 ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
652
653 Visitor::visit( node );
654
655 VISIT_END( node );
656}
657
658template< typename pass_type >
659Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) {
660 MUTATE_START( node );
661
662 // don't want statements from outer CompoundStmts to be added to this StmtExpr
663 ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() );
664 ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
665 ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
666
667 Mutator::mutate( node );
668
669 MUTATE_END( Expression, node );
670}
671
672template< typename pass_type >
673void PassVisitor< pass_type >::visit( UniqueExpr * node ) {
674 VISIT_BODY( node );
675}
676
677template< typename pass_type >
678void PassVisitor< pass_type >::visit( VoidType * node ) {
679 VISIT_BODY( node );
680}
681
682template< typename pass_type >
683void PassVisitor< pass_type >::visit( BasicType * node ) {
684 VISIT_BODY( node );
685}
686
687template< typename pass_type >
688void PassVisitor< pass_type >::visit( PointerType * node ) {
689 VISIT_BODY( node );
690}
691
692template< typename pass_type >
693void PassVisitor< pass_type >::visit( ArrayType * node ) {
694 VISIT_BODY( node );
695}
696
697template< typename pass_type >
698void PassVisitor< pass_type >::visit( FunctionType * node ) {
699 VISIT_BODY( node );
700}
701
702template< typename pass_type >
703void PassVisitor< pass_type >::visit( StructInstType * node ) {
704 VISIT_BODY( node );
705}
706
707template< typename pass_type >
708void PassVisitor< pass_type >::visit( UnionInstType * node ) {
709 VISIT_BODY( node );
710}
711
712template< typename pass_type >
713void PassVisitor< pass_type >::visit( EnumInstType * node ) {
714 VISIT_BODY( node );
715}
716
717template< typename pass_type >
718void PassVisitor< pass_type >::visit( TraitInstType * node ) {
719 VISIT_BODY( node );
720}
721
722template< typename pass_type >
723void PassVisitor< pass_type >::visit( TypeInstType * node ) {
724 VISIT_BODY( node );
725}
726
727template< typename pass_type >
728void PassVisitor< pass_type >::visit( TupleType * node ) {
729 VISIT_BODY( node );
730}
731
732template< typename pass_type >
733void PassVisitor< pass_type >::visit( TypeofType * node ) {
734 VISIT_BODY( node );
735}
736
737template< typename pass_type >
738void PassVisitor< pass_type >::visit( AttrType * node ) {
739 VISIT_BODY( node );
740}
741
742template< typename pass_type >
743void PassVisitor< pass_type >::visit( VarArgsType * node ) {
744 VISIT_BODY( node );
745}
746
747template< typename pass_type >
748void PassVisitor< pass_type >::visit( ZeroType * node ) {
749 VISIT_BODY( node );
750}
751
752template< typename pass_type >
753void PassVisitor< pass_type >::visit( OneType * node ) {
754 VISIT_BODY( node );
755}
756
757//--------------------------------------------------------------------------
758// UntypedExpr
759template< typename pass_type >
760void PassVisitor< pass_type >::visit( SingleInit * node ) {
761 VISIT_START( node );
762
763 visitExpression( node->get_value() );
764
765 VISIT_END( node );
766}
767
768template< typename pass_type >
769Initializer * PassVisitor< pass_type >::mutate( SingleInit * node ) {
770 MUTATE_START( node );
771
772 node->set_value( mutateExpression( node->get_value() ) );
773
774 MUTATE_END( Initializer, node );
775}
776
777template< typename pass_type >
778void PassVisitor< pass_type >::visit( ListInit * node ) {
779 VISIT_BODY( node );
780}
781
782template< typename pass_type >
783void PassVisitor< pass_type >::visit( ConstructorInit * node ) {
784 VISIT_BODY( node );
785}
786
787template< typename pass_type >
788void PassVisitor< pass_type >::visit( Subrange * node ) {
789 VISIT_BODY( node );
790}
791
792template< typename pass_type >
793void PassVisitor< pass_type >::visit( Constant * node ) {
794 VISIT_BODY( node );
795}
796
797//---------------------------------------------------------------------------------------------------------------
798
799template< typename pass_type >
800DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) {
801 MUTATE_BODY( DeclarationWithType, node );
802}
803
804template< typename pass_type >
805DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) {
806 MUTATE_BODY( DeclarationWithType, node );
807}
808
809template< typename pass_type >
810Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
811 MUTATE_BODY( Declaration, node );
812}
813
814template< typename pass_type >
815Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) {
816 MUTATE_BODY( Declaration, node );
817}
818
819template< typename pass_type >
820Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) {
821 MUTATE_BODY( Declaration, node );
822}
823
824template< typename pass_type >
825Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) {
826 MUTATE_BODY( Declaration, node );
827}
828
829template< typename pass_type >
830TypeDecl * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
831 MUTATE_BODY( TypeDecl, node );
832}
833
834template< typename pass_type >
835Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) {
836 MUTATE_BODY( Declaration, node );
837}
838
839template< typename pass_type >
840AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) {
841 MUTATE_BODY( AsmDecl, node );
842}
843
844template< typename pass_type >
845Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
846 MUTATE_BODY( Statement, node );
847}
848
849template< typename pass_type >
850Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
851 MUTATE_BODY( Statement, node );
852}
853
854template< typename pass_type >
855Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) {
856 MUTATE_BODY( Statement, node );
857}
858
859template< typename pass_type >
860NullStmt * PassVisitor< pass_type >::mutate( NullStmt * node ) {
861 MUTATE_BODY( NullStmt, node );
862}
863
864template< typename pass_type >
865Statement * PassVisitor< pass_type >::mutate( DeclStmt * node ) {
866 MUTATE_BODY( Statement, node );
867}
868
869template< typename pass_type >
870Statement * PassVisitor< pass_type >::mutate( ImplicitCtorDtorStmt * node ) {
871 MUTATE_BODY( Statement, node );
872}
873
874template< typename pass_type >
875Expression * PassVisitor< pass_type >::mutate( ApplicationExpr * node ) {
876 MUTATE_BODY( Expression, node );
877}
878
879template< typename pass_type >
880Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) {
881 MUTATE_BODY( Expression, node );
882}
883
884template< typename pass_type >
885Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) {
886 MUTATE_BODY( Expression, node );
887}
888
889template< typename pass_type >
890Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) {
891 MUTATE_BODY( Expression, node );
892}
893
894template< typename pass_type >
895Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) {
896 MUTATE_BODY( Expression, node );
897}
898
899template< typename pass_type >
900Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) {
901 MUTATE_BODY( Expression, node );
902}
903
904template< typename pass_type >
905Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) {
906 MUTATE_BODY( Expression, node );
907}
908
909template< typename pass_type >
910Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) {
911 MUTATE_BODY( Expression, node );
912}
913
914template< typename pass_type >
915Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) {
916 MUTATE_BODY( Expression, node );
917}
918
919template< typename pass_type >
920Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) {
921 MUTATE_BODY( Expression, node );
922}
923
924template< typename pass_type >
925Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) {
926 MUTATE_BODY( Expression, node );
927}
928
929template< typename pass_type >
930Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) {
931 MUTATE_BODY( Expression, node );
932}
933
934template< typename pass_type >
935Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) {
936 MUTATE_BODY( Expression, node );
937}
938
939template< typename pass_type >
940Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) {
941 MUTATE_BODY( Expression, node );
942}
943
944template< typename pass_type >
945Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) {
946 MUTATE_BODY( Expression, node );
947}
948
949template< typename pass_type >
950Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) {
951 MUTATE_BODY( Expression, node );
952}
953
954template< typename pass_type >
955Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) {
956 MUTATE_BODY( Expression, node );
957}
958
959template< typename pass_type >
960Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) {
961 MUTATE_BODY( Expression, node );
962}
963
964template< typename pass_type >
965Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) {
966 MUTATE_BODY( Expression, node );
967}
968
969template< typename pass_type >
970Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) {
971 MUTATE_BODY( Expression, node );
972}
973
974template< typename pass_type >
975Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) {
976 MUTATE_BODY( Expression, node );
977}
978
979template< typename pass_type >
980Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) {
981 MUTATE_BODY( Expression, node );
982}
983
984template< typename pass_type >
985Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) {
986 MUTATE_BODY( Expression, node );
987}
988
989template< typename pass_type >
990Expression * PassVisitor< pass_type >::mutate( UntypedValofExpr * node ) {
991 MUTATE_BODY( Expression, node );
992}
993
994template< typename pass_type >
995Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
996 MUTATE_BODY( Expression, node );
997}
998
999template< typename pass_type >
1000Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) {
1001 MUTATE_BODY( Expression, node );
1002}
1003
1004template< typename pass_type >
1005Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) {
1006 MUTATE_BODY( Expression, node );
1007}
1008
1009template< typename pass_type >
1010Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) {
1011 MUTATE_BODY( Expression, node );
1012}
1013
1014template< typename pass_type >
1015Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) {
1016 MUTATE_BODY( Expression, node );
1017}
1018
1019template< typename pass_type >
1020Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) {
1021 MUTATE_BODY( Expression, node );
1022}
1023
1024template< typename pass_type >
1025Type * PassVisitor< pass_type >::mutate( VoidType * node ) {
1026 MUTATE_BODY( Type, node );
1027}
1028
1029template< typename pass_type >
1030Type * PassVisitor< pass_type >::mutate( BasicType * node ) {
1031 MUTATE_BODY( Type, node );
1032}
1033
1034template< typename pass_type >
1035Type * PassVisitor< pass_type >::mutate( PointerType * node ) {
1036 MUTATE_BODY( Type, node );
1037}
1038
1039template< typename pass_type >
1040Type * PassVisitor< pass_type >::mutate( ArrayType * node ) {
1041 MUTATE_BODY( Type, node );
1042}
1043
1044template< typename pass_type >
1045Type * PassVisitor< pass_type >::mutate( FunctionType * node ) {
1046 MUTATE_BODY( Type, node );
1047}
1048
1049template< typename pass_type >
1050Type * PassVisitor< pass_type >::mutate( StructInstType * node ) {
1051 MUTATE_BODY( Type, node );
1052}
1053
1054template< typename pass_type >
1055Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) {
1056 MUTATE_BODY( Type, node );
1057}
1058
1059template< typename pass_type >
1060Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) {
1061 MUTATE_BODY( Type, node );
1062}
1063
1064template< typename pass_type >
1065Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) {
1066 MUTATE_BODY( Type, node );
1067}
1068
1069template< typename pass_type >
1070Type * PassVisitor< pass_type >::mutate( TypeInstType * node ) {
1071 MUTATE_BODY( Type, node );
1072}
1073
1074template< typename pass_type >
1075Type * PassVisitor< pass_type >::mutate( TupleType * node ) {
1076 MUTATE_BODY( Type, node );
1077}
1078
1079template< typename pass_type >
1080Type * PassVisitor< pass_type >::mutate( TypeofType * node ) {
1081 MUTATE_BODY( Type, node );
1082}
1083
1084template< typename pass_type >
1085Type * PassVisitor< pass_type >::mutate( AttrType * node ) {
1086 MUTATE_BODY( Type, node );
1087}
1088
1089template< typename pass_type >
1090Type * PassVisitor< pass_type >::mutate( VarArgsType * node ) {
1091 MUTATE_BODY( Type, node );
1092}
1093
1094template< typename pass_type >
1095Type * PassVisitor< pass_type >::mutate( ZeroType * node ) {
1096 MUTATE_BODY( Type, node );
1097}
1098
1099template< typename pass_type >
1100Type * PassVisitor< pass_type >::mutate( OneType * node ) {
1101 MUTATE_BODY( Type, node );
1102}
1103
1104template< typename pass_type >
1105Initializer * PassVisitor< pass_type >::mutate( ListInit * node ) {
1106 MUTATE_BODY( Initializer, node );
1107}
1108
1109template< typename pass_type >
1110Initializer * PassVisitor< pass_type >::mutate( ConstructorInit * node ) {
1111 MUTATE_BODY( Initializer, node );
1112}
1113
1114template< typename pass_type >
1115Subrange * PassVisitor< pass_type >::mutate( Subrange * node ) {
1116 MUTATE_BODY( Subrange, node );
1117}
1118
1119template< typename pass_type >
1120Constant * PassVisitor< pass_type >::mutate( Constant * node ) {
1121 MUTATE_BODY( Constant, node );
1122}
Note: See TracBrowser for help on using the repository browser.