source: src/Common/PassVisitor.impl.h@ 3d4b23fa

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 3d4b23fa was 62423350, checked in by Rob Schluntz <rschlunt@…>, 8 years ago

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