Changeset 4551a6e for src/Common
- Timestamp:
- Jun 21, 2017, 11:42:45 AM (7 years ago)
- Branches:
- ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
- Children:
- af5c204a
- Parents:
- 0508ab3
- Location:
- src/Common
- Files:
-
- 2 edited
Legend:
- Unmodified
- Added
- Removed
-
src/Common/PassVisitor.h
r0508ab3 r4551a6e 19 19 // To use declare a PassVisitor< YOUR VISITOR TYPE > 20 20 // The visitor type should specify the previsit/postvisit/premutate/postmutate for types that are desired. 21 // Note: previsit/postvisit/premutate/postmutate must be **public** members 21 22 // 22 23 // Several additional features are available through inheritance -
src/Common/PassVisitor.impl.h
r0508ab3 r4551a6e 6 6 call_previsit( node ); \ 7 7 if( visit_children() ) { \ 8 reset_visit(); \9 8 10 9 #define VISIT_END( node ) \ 11 10 } \ 11 reset_visit(); \ 12 12 call_postvisit( node ); \ 13 13 … … 17 17 call_premutate( node ); \ 18 18 if( visit_children() ) { \ 19 reset_visit(); \20 19 21 20 #define MUTATE_END( type, node ) \ 22 21 } \ 22 reset_visit(); \ 23 23 return call_postmutate< type * >( node ); \ 24 24 … … 159 159 template< typename pass_type > 160 160 void PassVisitor< pass_type >::visit( ObjectDecl * node ) { 161 VISIT_BODY( node ); 161 VISIT_BODY( node ); 162 162 } 163 163 164 164 template< typename pass_type > 165 165 void PassVisitor< pass_type >::visit( FunctionDecl * node ) { 166 VISIT_BODY( node ); 166 VISIT_BODY( node ); 167 167 } 168 168 169 169 template< typename pass_type > 170 170 void PassVisitor< pass_type >::visit( StructDecl * node ) { 171 VISIT_BODY( node ); 171 VISIT_BODY( node ); 172 172 } 173 173 174 174 template< typename pass_type > 175 175 void PassVisitor< pass_type >::visit( UnionDecl * node ) { 176 VISIT_BODY( node ); 176 VISIT_BODY( node ); 177 177 } 178 178 179 179 template< typename pass_type > 180 180 void PassVisitor< pass_type >::visit( EnumDecl * node ) { 181 VISIT_BODY( node ); 181 VISIT_BODY( node ); 182 182 } 183 183 184 184 template< typename pass_type > 185 185 void PassVisitor< pass_type >::visit( TraitDecl * node ) { 186 VISIT_BODY( node ); 186 VISIT_BODY( node ); 187 187 } 188 188 189 189 template< typename pass_type > 190 190 void PassVisitor< pass_type >::visit( TypeDecl * node ) { 191 VISIT_BODY( node ); 191 VISIT_BODY( node ); 192 192 } 193 193 194 194 template< typename pass_type > 195 195 void PassVisitor< pass_type >::visit( TypedefDecl * node ) { 196 VISIT_BODY( node ); 196 VISIT_BODY( node ); 197 197 } 198 198 199 199 template< typename pass_type > 200 200 void PassVisitor< pass_type >::visit( AsmDecl * node ) { 201 VISIT_BODY( node ); 201 VISIT_BODY( node ); 202 202 } 203 203 … … 250 250 template< typename pass_type > 251 251 void PassVisitor< pass_type >::visit( AsmStmt * node ) { 252 VISIT_BODY( node ); 252 VISIT_BODY( node ); 253 253 } 254 254 … … 257 257 template< typename pass_type > 258 258 void PassVisitor< pass_type >::visit( IfStmt * node ) { 259 VISIT_START( node ); 259 VISIT_START( node ); 260 260 261 261 visitExpression( node->get_condition() ); … … 268 268 template< typename pass_type > 269 269 Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) { 270 MUTATE_START( node ); 270 MUTATE_START( node ); 271 271 272 272 node->set_condition( mutateExpression( node->get_condition() ) ); … … 281 281 template< typename pass_type > 282 282 void PassVisitor< pass_type >::visit( WhileStmt * node ) { 283 VISIT_START( node ); 283 VISIT_START( node ); 284 284 285 285 visitExpression( node->get_condition() ); … … 291 291 template< typename pass_type > 292 292 Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) { 293 MUTATE_START( node ); 293 MUTATE_START( node ); 294 294 295 295 node->set_condition( mutateExpression( node->get_condition() ) ); … … 303 303 template< typename pass_type > 304 304 void PassVisitor< pass_type >::visit( ForStmt * node ) { 305 VISIT_START( node ); 305 VISIT_START( node ); 306 306 307 307 acceptAll( node->get_initialization(), *this ); … … 315 315 template< typename pass_type > 316 316 Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) { 317 MUTATE_START( node ); 317 MUTATE_START( node ); 318 318 319 319 mutateAll( node->get_initialization(), *this ); … … 329 329 template< typename pass_type > 330 330 void PassVisitor< pass_type >::visit( SwitchStmt * node ) { 331 VISIT_START( node ); 331 VISIT_START( node ); 332 332 333 333 visitExpression( node->get_condition() ); … … 339 339 template< typename pass_type > 340 340 Statement * PassVisitor< pass_type >::mutate( SwitchStmt * node ) { 341 MUTATE_START( node ); 342 341 MUTATE_START( node ); 342 343 343 node->set_condition( mutateExpression( node->get_condition() ) ); 344 344 mutateStatementList( node->get_statements() ); 345 345 346 346 MUTATE_END( Statement, node ); 347 347 } … … 351 351 template< typename pass_type > 352 352 void PassVisitor< pass_type >::visit( CaseStmt * node ) { 353 VISIT_START( node ); 354 353 VISIT_START( node ); 354 355 355 visitExpression( node->get_condition() ); 356 356 visitStatementList( node->get_statements() ); 357 357 358 358 VISIT_END( node ); 359 359 } … … 361 361 template< typename pass_type > 362 362 Statement * PassVisitor< pass_type >::mutate( CaseStmt * node ) { 363 MUTATE_START( node ); 364 363 MUTATE_START( node ); 364 365 365 node->set_condition( mutateExpression( node->get_condition() ) ); 366 366 mutateStatementList( node->get_statements() ); 367 367 368 368 MUTATE_END( Statement, node ); 369 369 } … … 371 371 template< typename pass_type > 372 372 void PassVisitor< pass_type >::visit( BranchStmt * node ) { 373 VISIT_BODY( node ); 373 VISIT_BODY( node ); 374 374 } 375 375 … … 425 425 node->set_block( maybeMutate( node->get_block(), *this ) ); 426 426 mutateAll( node->get_catchers(), *this ); 427 427 428 428 MUTATE_END( Statement, node ); 429 429 } … … 444 444 Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) { 445 445 MUTATE_START( node ); 446 446 447 447 node->set_body( mutateStatement( node->get_body() ) ); 448 448 node->set_decl( maybeMutate( node->get_decl(), *this ) ); 449 449 450 450 MUTATE_END( Statement, node ); 451 451 } … … 453 453 template< typename pass_type > 454 454 void PassVisitor< pass_type >::visit( FinallyStmt * node ) { 455 VISIT_BODY( node ); 455 VISIT_BODY( node ); 456 456 } 457 457 458 458 template< typename pass_type > 459 459 void PassVisitor< pass_type >::visit( NullStmt * node ) { 460 VISIT_BODY( node ); 460 VISIT_BODY( node ); 461 461 } 462 462 463 463 template< typename pass_type > 464 464 void PassVisitor< pass_type >::visit( DeclStmt * node ) { 465 VISIT_BODY( node ); 465 VISIT_BODY( node ); 466 466 } 467 467 468 468 template< typename pass_type > 469 469 void PassVisitor< pass_type >::visit( ImplicitCtorDtorStmt * node ) { 470 VISIT_BODY( node ); 470 VISIT_BODY( node ); 471 471 } 472 472 473 473 template< typename pass_type > 474 474 void PassVisitor< pass_type >::visit( ApplicationExpr * node ) { 475 VISIT_BODY( node ); 475 VISIT_BODY( node ); 476 476 } 477 477 … … 502 502 template< typename pass_type > 503 503 void PassVisitor< pass_type >::visit( NameExpr * node ) { 504 VISIT_BODY( node ); 504 VISIT_BODY( node ); 505 505 } 506 506 507 507 template< typename pass_type > 508 508 void PassVisitor< pass_type >::visit( CastExpr * node ) { 509 VISIT_BODY( node ); 509 VISIT_BODY( node ); 510 510 } 511 511 512 512 template< typename pass_type > 513 513 void PassVisitor< pass_type >::visit( AddressExpr * node ) { 514 VISIT_BODY( node ); 514 VISIT_BODY( node ); 515 515 } 516 516 517 517 template< typename pass_type > 518 518 void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) { 519 VISIT_BODY( node ); 519 VISIT_BODY( node ); 520 520 } 521 521 522 522 template< typename pass_type > 523 523 void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) { 524 VISIT_BODY( node ); 524 VISIT_BODY( node ); 525 525 } 526 526 527 527 template< typename pass_type > 528 528 void PassVisitor< pass_type >::visit( MemberExpr * node ) { 529 VISIT_BODY( node ); 529 VISIT_BODY( node ); 530 530 } 531 531 532 532 template< typename pass_type > 533 533 void PassVisitor< pass_type >::visit( VariableExpr * node ) { 534 VISIT_BODY( node ); 534 VISIT_BODY( node ); 535 535 } 536 536 537 537 template< typename pass_type > 538 538 void PassVisitor< pass_type >::visit( ConstantExpr * node ) { 539 VISIT_BODY( node ); 539 VISIT_BODY( node ); 540 540 } 541 541 542 542 template< typename pass_type > 543 543 void PassVisitor< pass_type >::visit( SizeofExpr * node ) { 544 VISIT_BODY( node ); 544 VISIT_BODY( node ); 545 545 } 546 546 547 547 template< typename pass_type > 548 548 void PassVisitor< pass_type >::visit( AlignofExpr * node ) { 549 VISIT_BODY( node ); 549 VISIT_BODY( node ); 550 550 } 551 551 552 552 template< typename pass_type > 553 553 void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) { 554 VISIT_BODY( node ); 554 VISIT_BODY( node ); 555 555 } 556 556 557 557 template< typename pass_type > 558 558 void PassVisitor< pass_type >::visit( OffsetofExpr * node ) { 559 VISIT_BODY( node ); 559 VISIT_BODY( node ); 560 560 } 561 561 562 562 template< typename pass_type > 563 563 void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) { 564 VISIT_BODY( node ); 564 VISIT_BODY( node ); 565 565 } 566 566 567 567 template< typename pass_type > 568 568 void PassVisitor< pass_type >::visit( AttrExpr * node ) { 569 VISIT_BODY( node ); 569 VISIT_BODY( node ); 570 570 } 571 571 572 572 template< typename pass_type > 573 573 void PassVisitor< pass_type >::visit( LogicalExpr * node ) { 574 VISIT_BODY( node ); 574 VISIT_BODY( node ); 575 575 } 576 576 577 577 template< typename pass_type > 578 578 void PassVisitor< pass_type >::visit( ConditionalExpr * node ) { 579 VISIT_BODY( node ); 579 VISIT_BODY( node ); 580 580 } 581 581 582 582 template< typename pass_type > 583 583 void PassVisitor< pass_type >::visit( CommaExpr * node ) { 584 VISIT_BODY( node ); 584 VISIT_BODY( node ); 585 585 } 586 586 587 587 template< typename pass_type > 588 588 void PassVisitor< pass_type >::visit( TypeExpr * node ) { 589 VISIT_BODY( node ); 589 VISIT_BODY( node ); 590 590 } 591 591 592 592 template< typename pass_type > 593 593 void PassVisitor< pass_type >::visit( AsmExpr * node ) { 594 VISIT_BODY( node ); 594 VISIT_BODY( node ); 595 595 } 596 596 597 597 template< typename pass_type > 598 598 void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) { 599 VISIT_BODY( node ); 599 VISIT_BODY( node ); 600 600 } 601 601 602 602 template< typename pass_type > 603 603 void PassVisitor< pass_type >::visit( ConstructorExpr * node ) { 604 VISIT_BODY( node ); 604 VISIT_BODY( node ); 605 605 } 606 606 … … 617 617 template< typename pass_type > 618 618 void PassVisitor< pass_type >::visit( RangeExpr * node ) { 619 VISIT_BODY( node ); 619 VISIT_BODY( node ); 620 620 } 621 621 622 622 template< typename pass_type > 623 623 void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) { 624 VISIT_BODY( node ); 624 VISIT_BODY( node ); 625 625 } 626 626 627 627 template< typename pass_type > 628 628 void PassVisitor< pass_type >::visit( TupleExpr * node ) { 629 VISIT_BODY( node ); 629 VISIT_BODY( node ); 630 630 } 631 631 632 632 template< typename pass_type > 633 633 void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) { 634 VISIT_BODY( node ); 634 VISIT_BODY( node ); 635 635 } 636 636 637 637 template< typename pass_type > 638 638 void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) { 639 VISIT_BODY( node ); 639 VISIT_BODY( node ); 640 640 } 641 641 … … 659 659 Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) { 660 660 MUTATE_START( node ); 661 661 662 662 // don't want statements from outer CompoundStmts to be added to this StmtExpr 663 663 ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() ); … … 672 672 template< typename pass_type > 673 673 void PassVisitor< pass_type >::visit( UniqueExpr * node ) { 674 VISIT_BODY( node ); 674 VISIT_BODY( node ); 675 675 } 676 676 677 677 template< typename pass_type > 678 678 void PassVisitor< pass_type >::visit( VoidType * node ) { 679 VISIT_BODY( node ); 679 VISIT_BODY( node ); 680 680 } 681 681 682 682 template< typename pass_type > 683 683 void PassVisitor< pass_type >::visit( BasicType * node ) { 684 VISIT_BODY( node ); 684 VISIT_BODY( node ); 685 685 } 686 686 687 687 template< typename pass_type > 688 688 void PassVisitor< pass_type >::visit( PointerType * node ) { 689 VISIT_BODY( node ); 689 VISIT_BODY( node ); 690 690 } 691 691 692 692 template< typename pass_type > 693 693 void PassVisitor< pass_type >::visit( ArrayType * node ) { 694 VISIT_BODY( node ); 694 VISIT_BODY( node ); 695 695 } 696 696 697 697 template< typename pass_type > 698 698 void PassVisitor< pass_type >::visit( FunctionType * node ) { 699 VISIT_BODY( node ); 699 VISIT_BODY( node ); 700 700 } 701 701 702 702 template< typename pass_type > 703 703 void PassVisitor< pass_type >::visit( StructInstType * node ) { 704 VISIT_BODY( node ); 704 VISIT_BODY( node ); 705 705 } 706 706 707 707 template< typename pass_type > 708 708 void PassVisitor< pass_type >::visit( UnionInstType * node ) { 709 VISIT_BODY( node ); 709 VISIT_BODY( node ); 710 710 } 711 711 712 712 template< typename pass_type > 713 713 void PassVisitor< pass_type >::visit( EnumInstType * node ) { 714 VISIT_BODY( node ); 714 VISIT_BODY( node ); 715 715 } 716 716 717 717 template< typename pass_type > 718 718 void PassVisitor< pass_type >::visit( TraitInstType * node ) { 719 VISIT_BODY( node ); 719 VISIT_BODY( node ); 720 720 } 721 721 722 722 template< typename pass_type > 723 723 void PassVisitor< pass_type >::visit( TypeInstType * node ) { 724 VISIT_BODY( node ); 724 VISIT_BODY( node ); 725 725 } 726 726 727 727 template< typename pass_type > 728 728 void PassVisitor< pass_type >::visit( TupleType * node ) { 729 VISIT_BODY( node ); 729 VISIT_BODY( node ); 730 730 } 731 731 732 732 template< typename pass_type > 733 733 void PassVisitor< pass_type >::visit( TypeofType * node ) { 734 VISIT_BODY( node ); 734 VISIT_BODY( node ); 735 735 } 736 736 737 737 template< typename pass_type > 738 738 void PassVisitor< pass_type >::visit( AttrType * node ) { 739 VISIT_BODY( node ); 739 VISIT_BODY( node ); 740 740 } 741 741 742 742 template< typename pass_type > 743 743 void PassVisitor< pass_type >::visit( VarArgsType * node ) { 744 VISIT_BODY( node ); 744 VISIT_BODY( node ); 745 745 } 746 746 747 747 template< typename pass_type > 748 748 void PassVisitor< pass_type >::visit( ZeroType * node ) { 749 VISIT_BODY( node ); 749 VISIT_BODY( node ); 750 750 } 751 751 752 752 template< typename pass_type > 753 753 void PassVisitor< pass_type >::visit( OneType * node ) { 754 VISIT_BODY( node ); 754 VISIT_BODY( node ); 755 755 } 756 756 … … 777 777 template< typename pass_type > 778 778 void PassVisitor< pass_type >::visit( ListInit * node ) { 779 VISIT_BODY( node ); 779 VISIT_BODY( node ); 780 780 } 781 781 782 782 template< typename pass_type > 783 783 void PassVisitor< pass_type >::visit( ConstructorInit * node ) { 784 VISIT_BODY( node ); 784 VISIT_BODY( node ); 785 785 } 786 786 787 787 template< typename pass_type > 788 788 void PassVisitor< pass_type >::visit( Subrange * node ) { 789 VISIT_BODY( node ); 789 VISIT_BODY( node ); 790 790 } 791 791 792 792 template< typename pass_type > 793 793 void PassVisitor< pass_type >::visit( Constant * node ) { 794 VISIT_BODY( node ); 794 VISIT_BODY( node ); 795 795 } 796 796
Note: See TracChangeset
for help on using the changeset viewer.