Changeset e9a3b20b
- Timestamp:
- Jun 21, 2017, 5:47:52 PM (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:
- 1a18423, 2c37f34, 925b7f4, 969ee0df, fda8168
- Parents:
- d56e5bc (diff), 06edda0 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - Location:
- src
- Files:
-
- 19 edited
Legend:
- Unmodified
- Added
- Removed
-
src/Common/PassVisitor.h
rd56e5bc re9a3b20b 18 18 // Templated visitor type 19 19 // To use declare a PassVisitor< YOUR VISITOR TYPE > 20 // The visitor type should specify the previsit/postvisit for types that are desired. 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 22 // 23 // Several additional features are available through inheritance 24 // | WithTypeSubstitution - provides polymorphic TypeSubstitution * env for the current expression 25 // | WithStmtsToAdd - provides the ability to insert statements before or after the current statement by adding new statements into 26 // stmtsToAddBefore or stmtsToAddAfter respectively. 27 // | WithShortCircuiting - provides the ability to skip visiting child nodes; set skip_children to true if pre{visit,mutate} to skip visiting children 28 // | WithScopes - provides the ability to save/restore data like a LIFO stack; to save, call GuardValue with the variable to save, the variable 29 // will automatically be restored to its previous value after the corresponding postvisit/postmutate teminates. 21 30 //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 22 31 template< typename pass_type > … … 86 95 virtual void visit( ConstructorExpr * ctorExpr ) override final; 87 96 virtual void visit( CompoundLiteralExpr *compLitExpr ) override final; 88 virtual void visit( UntypedValofExpr *valofExpr ) override final;89 97 virtual void visit( RangeExpr *rangeExpr ) override final; 90 98 virtual void visit( UntypedTupleExpr *tupleExpr ) override final; … … 172 180 virtual Expression* mutate( ConstructorExpr *ctorExpr ) override final; 173 181 virtual Expression* mutate( CompoundLiteralExpr *compLitExpr ) override final; 174 virtual Expression* mutate( UntypedValofExpr *valofExpr ) override final;175 182 virtual Expression* mutate( RangeExpr *rangeExpr ) override final; 176 183 virtual Expression* mutate( UntypedTupleExpr *tupleExpr ) override final; -
src/Common/PassVisitor.impl.h
rd56e5bc re9a3b20b 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 607 607 template< typename pass_type > 608 608 void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) { 609 VISIT_BODY( node ); 610 } 611 612 template< typename pass_type > 613 void PassVisitor< pass_type >::visit( UntypedValofExpr * node ) { 614 VISIT_BODY( node ); 609 VISIT_BODY( node ); 615 610 } 616 611 617 612 template< typename pass_type > 618 613 void PassVisitor< pass_type >::visit( RangeExpr * node ) { 619 VISIT_BODY( node ); 614 VISIT_BODY( node ); 620 615 } 621 616 622 617 template< typename pass_type > 623 618 void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) { 624 VISIT_BODY( node ); 619 VISIT_BODY( node ); 625 620 } 626 621 627 622 template< typename pass_type > 628 623 void PassVisitor< pass_type >::visit( TupleExpr * node ) { 629 VISIT_BODY( node ); 624 VISIT_BODY( node ); 630 625 } 631 626 632 627 template< typename pass_type > 633 628 void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) { 634 VISIT_BODY( node ); 629 VISIT_BODY( node ); 635 630 } 636 631 637 632 template< typename pass_type > 638 633 void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) { 639 VISIT_BODY( node ); 634 VISIT_BODY( node ); 640 635 } 641 636 … … 659 654 Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) { 660 655 MUTATE_START( node ); 661 656 662 657 // don't want statements from outer CompoundStmts to be added to this StmtExpr 663 658 ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() ); … … 672 667 template< typename pass_type > 673 668 void PassVisitor< pass_type >::visit( UniqueExpr * node ) { 674 VISIT_BODY( node ); 669 VISIT_BODY( node ); 675 670 } 676 671 677 672 template< typename pass_type > 678 673 void PassVisitor< pass_type >::visit( VoidType * node ) { 679 VISIT_BODY( node ); 674 VISIT_BODY( node ); 680 675 } 681 676 682 677 template< typename pass_type > 683 678 void PassVisitor< pass_type >::visit( BasicType * node ) { 684 VISIT_BODY( node ); 679 VISIT_BODY( node ); 685 680 } 686 681 687 682 template< typename pass_type > 688 683 void PassVisitor< pass_type >::visit( PointerType * node ) { 689 VISIT_BODY( node ); 684 VISIT_BODY( node ); 690 685 } 691 686 692 687 template< typename pass_type > 693 688 void PassVisitor< pass_type >::visit( ArrayType * node ) { 694 VISIT_BODY( node ); 689 VISIT_BODY( node ); 695 690 } 696 691 697 692 template< typename pass_type > 698 693 void PassVisitor< pass_type >::visit( FunctionType * node ) { 699 VISIT_BODY( node ); 694 VISIT_BODY( node ); 700 695 } 701 696 702 697 template< typename pass_type > 703 698 void PassVisitor< pass_type >::visit( StructInstType * node ) { 704 VISIT_BODY( node ); 699 VISIT_BODY( node ); 705 700 } 706 701 707 702 template< typename pass_type > 708 703 void PassVisitor< pass_type >::visit( UnionInstType * node ) { 709 VISIT_BODY( node ); 704 VISIT_BODY( node ); 710 705 } 711 706 712 707 template< typename pass_type > 713 708 void PassVisitor< pass_type >::visit( EnumInstType * node ) { 714 VISIT_BODY( node ); 709 VISIT_BODY( node ); 715 710 } 716 711 717 712 template< typename pass_type > 718 713 void PassVisitor< pass_type >::visit( TraitInstType * node ) { 719 VISIT_BODY( node ); 714 VISIT_BODY( node ); 720 715 } 721 716 722 717 template< typename pass_type > 723 718 void PassVisitor< pass_type >::visit( TypeInstType * node ) { 724 VISIT_BODY( node ); 719 VISIT_BODY( node ); 725 720 } 726 721 727 722 template< typename pass_type > 728 723 void PassVisitor< pass_type >::visit( TupleType * node ) { 729 VISIT_BODY( node ); 724 VISIT_BODY( node ); 730 725 } 731 726 732 727 template< typename pass_type > 733 728 void PassVisitor< pass_type >::visit( TypeofType * node ) { 734 VISIT_BODY( node ); 729 VISIT_BODY( node ); 735 730 } 736 731 737 732 template< typename pass_type > 738 733 void PassVisitor< pass_type >::visit( AttrType * node ) { 739 VISIT_BODY( node ); 734 VISIT_BODY( node ); 740 735 } 741 736 742 737 template< typename pass_type > 743 738 void PassVisitor< pass_type >::visit( VarArgsType * node ) { 744 VISIT_BODY( node ); 739 VISIT_BODY( node ); 745 740 } 746 741 747 742 template< typename pass_type > 748 743 void PassVisitor< pass_type >::visit( ZeroType * node ) { 749 VISIT_BODY( node ); 744 VISIT_BODY( node ); 750 745 } 751 746 752 747 template< typename pass_type > 753 748 void PassVisitor< pass_type >::visit( OneType * node ) { 754 VISIT_BODY( node ); 749 VISIT_BODY( node ); 755 750 } 756 751 … … 777 772 template< typename pass_type > 778 773 void PassVisitor< pass_type >::visit( ListInit * node ) { 779 VISIT_BODY( node ); 774 VISIT_BODY( node ); 780 775 } 781 776 782 777 template< typename pass_type > 783 778 void PassVisitor< pass_type >::visit( ConstructorInit * node ) { 784 VISIT_BODY( node ); 779 VISIT_BODY( node ); 785 780 } 786 781 787 782 template< typename pass_type > 788 783 void PassVisitor< pass_type >::visit( Subrange * node ) { 789 VISIT_BODY( node ); 784 VISIT_BODY( node ); 790 785 } 791 786 792 787 template< typename pass_type > 793 788 void PassVisitor< pass_type >::visit( Constant * node ) { 794 VISIT_BODY( node ); 789 VISIT_BODY( node ); 795 790 } 796 791 … … 988 983 989 984 template< typename pass_type > 990 Expression * PassVisitor< pass_type >::mutate( UntypedValofExpr * node ) {991 MUTATE_BODY( Expression, node );992 }993 994 template< typename pass_type >995 985 Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) { 996 986 MUTATE_BODY( Expression, node ); -
src/InitTweak/FixInit.cc
rd56e5bc re9a3b20b 56 56 typedef std::unordered_map< int, int > UnqCount; 57 57 58 class InsertImplicitCalls {58 class InsertImplicitCalls : public WithTypeSubstitution { 59 59 public: 60 60 /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which … … 69 69 // collects environments for relevant nodes 70 70 EnvMap & envMap; 71 TypeSubstitution * env; //Magically populated by the PassVisitor72 71 }; 73 72 … … 192 191 }; 193 192 194 class FixInit {193 class FixInit : public WithStmtsToAdd { 195 194 public: 196 195 /// expand each object declaration to use its constructor after it is declared. … … 200 199 201 200 std::list< Declaration * > staticDtorDecls; 202 std::list< Statement * > stmtsToAddAfter; // found by PassVisitor203 201 }; 204 202 -
src/Parser/ExpressionNode.cc
rd56e5bc re9a3b20b 348 348 349 349 Expression *build_valexpr( StatementNode *s ) { 350 return new UntypedValofExpr( maybeMoveBuild< Statement >(s), nullptr);350 return new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(s) ) ); 351 351 } 352 352 Expression *build_typevalue( DeclarationNode *decl ) { -
src/Parser/ParseNode.h
rd56e5bc re9a3b20b 415 415 result->location = cur->location; 416 416 * out++ = result; 417 } else { 418 assertf(false, "buildList unknown type"); 417 419 } // if 418 420 } catch( SemanticError &e ) { -
src/Parser/StatementNode.cc
rd56e5bc re9a3b20b 175 175 176 176 Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt ) { 177 std::list< Statement * > branches;178 buildMoveList< Statement, StatementNode >( catch_stmt, branches );177 std::list< CatchStmt * > branches; 178 buildMoveList< CatchStmt, StatementNode >( catch_stmt, branches ); 179 179 CompoundStmt *tryBlock = safe_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt)); 180 180 FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) ); -
src/SymTab/Indexer.cc
rd56e5bc re9a3b20b 493 493 acceptNewScope( compLitExpr->get_result(), *this ); 494 494 maybeAccept( compLitExpr->get_initializer(), *this ); 495 }496 497 void Indexer::visit( UntypedValofExpr *valofExpr ) {498 acceptNewScope( valofExpr->get_result(), *this );499 maybeAccept( valofExpr->get_body(), *this );500 495 } 501 496 -
src/SymTab/Indexer.h
rd56e5bc re9a3b20b 69 69 virtual void visit( ConstructorExpr * ctorExpr ); 70 70 virtual void visit( CompoundLiteralExpr *compLitExpr ); 71 virtual void visit( UntypedValofExpr *valofExpr );72 71 virtual void visit( RangeExpr *rangeExpr ); 73 72 virtual void visit( UntypedTupleExpr *tupleExpr ); -
src/SymTab/Validate.cc
rd56e5bc re9a3b20b 115 115 116 116 /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers. 117 class EnumAndPointerDecay Pass final : public Visitor{118 typedef Visitor Parent;119 v irtual voidvisit( EnumDecl *aggregateDecl );120 v irtual voidvisit( FunctionType *func );117 class EnumAndPointerDecay { 118 public: 119 void previsit( EnumDecl *aggregateDecl ); 120 void previsit( FunctionType *func ); 121 121 }; 122 122 … … 126 126 public: 127 127 LinkReferenceToTypes( bool doDebug, const Indexer *indexer ); 128 private:129 128 using Parent::visit; 130 129 void visit( EnumInstType *enumInst ) final; … … 136 135 void visit( UnionDecl *unionDecl ) final; 137 136 void visit( TypeInstType *typeInst ) final; 138 137 private: 139 138 const Indexer *indexer; 140 139 … … 147 146 }; 148 147 149 /// Replaces array and function types in forall lists by appropriate pointer type 150 class Pass3final : public Indexer {148 /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID. 149 class ForallPointerDecay final : public Indexer { 151 150 typedef Indexer Parent; 152 151 public: 153 152 using Parent::visit; 154 Pass3( const Indexer *indexer );155 private: 153 ForallPointerDecay( const Indexer *indexer ); 154 156 155 virtual void visit( ObjectDecl *object ) override; 157 156 virtual void visit( FunctionDecl *func ) override; … … 160 159 }; 161 160 162 class ReturnChecker {161 class ReturnChecker : public WithScopes { 163 162 public: 164 163 /// Checks that return statements return nothing if their return type is void … … 167 166 private: 168 167 void previsit( FunctionDecl * functionDecl ); 169 void postvisit( FunctionDecl * functionDecl );170 168 void previsit( ReturnStmt * returnStmt ); 171 169 172 170 typedef std::list< DeclarationWithType * > ReturnVals; 173 171 ReturnVals returnVals; 174 std::stack< ReturnVals > returnValsStack;175 172 }; 176 173 … … 248 245 249 246 void validate( std::list< Declaration * > &translationUnit, bool doDebug ) { 250 EnumAndPointerDecayPassepc;247 PassVisitor<EnumAndPointerDecay> epc; 251 248 LinkReferenceToTypes lrt( doDebug, 0 ); 252 Pass3 pass3( 0 );249 ForallPointerDecay fpd( 0 ); 253 250 CompoundLiteral compoundliteral; 254 251 PassVisitor<ValidateGenericParameters> genericParams; … … 262 259 VerifyCtorDtorAssign::verify( translationUnit ); // must happen before autogen, because autogen examines existing ctor/dtors 263 260 Concurrency::applyKeywords( translationUnit ); 264 autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay Pass261 autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay 265 262 Concurrency::implementMutexFuncs( translationUnit ); 266 263 Concurrency::implementThreadStarter( translationUnit ); 267 264 ReturnChecker::checkFunctionReturns( translationUnit ); 268 265 compoundliteral.mutateDeclarationList( translationUnit ); 269 acceptAll( translationUnit, pass3);266 acceptAll( translationUnit, fpd ); 270 267 ArrayLength::computeLength( translationUnit ); 271 268 } 272 269 273 270 void validateType( Type *type, const Indexer *indexer ) { 274 EnumAndPointerDecayPassepc;271 PassVisitor<EnumAndPointerDecay> epc; 275 272 LinkReferenceToTypes lrt( false, indexer ); 276 Pass3 pass3( indexer );273 ForallPointerDecay fpd( indexer ); 277 274 type->accept( epc ); 278 275 type->accept( lrt ); 279 type->accept( pass3);276 type->accept( fpd ); 280 277 } 281 278 … … 356 353 } 357 354 358 void EnumAndPointerDecay Pass::visit( EnumDecl *enumDecl ) {355 void EnumAndPointerDecay::previsit( EnumDecl *enumDecl ) { 359 356 // Set the type of each member of the enumeration to be EnumConstant 360 357 for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) { … … 363 360 obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->get_name() ) ); 364 361 } // for 365 Parent::visit( enumDecl );366 362 } 367 363 … … 370 366 void fixFunctionList( DWTList & dwts, FunctionType * func ) { 371 367 // the only case in which "void" is valid is where it is the only one in the list; then it should be removed 372 // entirely other fix ups are handled by the FixFunction class368 // entirely. other fix ups are handled by the FixFunction class 373 369 typedef typename DWTList::iterator DWTIterator; 374 370 DWTIterator begin( dwts.begin() ), end( dwts.end() ); … … 389 385 for ( ; i != end; ++i ) { 390 386 FixFunction fixer; 391 *i = (*i 387 *i = (*i)->acceptMutator( fixer ); 392 388 if ( fixer.get_isVoid() ) { 393 389 throw SemanticError( "invalid type void in function type ", func ); … … 398 394 } 399 395 400 void EnumAndPointerDecay Pass::visit( FunctionType *func ) {396 void EnumAndPointerDecay::previsit( FunctionType *func ) { 401 397 // Fix up parameters and return types 402 398 fixFunctionList( func->get_parameters(), func ); 403 399 fixFunctionList( func->get_returnVals(), func ); 404 Visitor::visit( func );405 400 } 406 401 … … 549 544 } 550 545 551 Pass3::Pass3( const Indexer *other_indexer ) : Indexer( false ) {546 ForallPointerDecay::ForallPointerDecay( const Indexer *other_indexer ) : Indexer( false ) { 552 547 if ( other_indexer ) { 553 548 indexer = other_indexer; … … 587 582 } 588 583 589 void Pass3::visit( ObjectDecl *object ) {584 void ForallPointerDecay::visit( ObjectDecl *object ) { 590 585 forallFixer( object->get_type() ); 591 586 if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) { … … 596 591 } 597 592 598 void Pass3::visit( FunctionDecl *func ) {593 void ForallPointerDecay::visit( FunctionDecl *func ) { 599 594 forallFixer( func->get_type() ); 600 595 Parent::visit( func ); … … 608 603 609 604 void ReturnChecker::previsit( FunctionDecl * functionDecl ) { 610 returnValsStack.push( returnVals );605 GuardValue( returnVals ); 611 606 returnVals = functionDecl->get_functionType()->get_returnVals(); 612 }613 void ReturnChecker::postvisit( __attribute__((unused)) FunctionDecl * functionDecl ) {614 returnVals = returnValsStack.top();615 returnValsStack.pop();616 607 } 617 608 -
src/SynTree/BaseSyntaxNode.h
rd56e5bc re9a3b20b 24 24 CodeLocation location; 25 25 26 virtual void accept( Visitor & v ) = 0; // temporary -- needs to be here so that BaseSyntaxNode is polymorphic and can be dynamic_cast 26 virtual ~BaseSyntaxNode() {} 27 28 virtual void accept( Visitor & v ) = 0; 27 29 }; 28 30 -
src/SynTree/Expression.cc
rd56e5bc re9a3b20b 288 288 } 289 289 290 // CastExpr *CastExpr::clone() const { return 0; }291 292 290 void CastExpr::print( std::ostream &os, int indent ) const { 293 291 os << "Cast of:" << std::endl << std::string( indent+2, ' ' ); … … 355 353 } 356 354 357 //// is this right? It's cloning the member, but the member is a declaration so probably shouldn't be cloned...358 355 MemberExpr::MemberExpr( const MemberExpr &other ) : 359 356 Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) { … … 361 358 362 359 MemberExpr::~MemberExpr() { 363 // d elete member;360 // don't delete the member declaration, since it points somewhere else in the tree 364 361 delete aggregate; 365 362 } … … 591 588 } 592 589 593 UntypedValofExpr::UntypedValofExpr( const UntypedValofExpr & other ) : Expression( other ), body ( maybeClone( other.body ) ) {}594 595 UntypedValofExpr::~UntypedValofExpr() { delete body; }596 597 void UntypedValofExpr::print( std::ostream &os, int indent ) const {598 os << std::string( indent, ' ' ) << "Valof Expression: " << std::endl;599 if ( get_body() != 0 )600 get_body()->print( os, indent + 2 );601 }602 603 590 RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {} 604 591 RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {} -
src/SynTree/Expression.h
rd56e5bc re9a3b20b 226 226 }; 227 227 228 /// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer 228 /// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer. 229 /// Does not take ownership of member. 229 230 class MemberExpr : public Expression { 230 231 public: … … 247 248 }; 248 249 249 /// VariableExpr represents an expression that simply refers to the value of a named variable 250 /// VariableExpr represents an expression that simply refers to the value of a named variable. 251 /// Does not take ownership of var. 250 252 class VariableExpr : public Expression { 251 253 public: … … 598 600 }; 599 601 600 /// ValofExpr represents a GCC 'lambda expression'601 class UntypedValofExpr : public Expression {602 public:603 UntypedValofExpr( Statement *_body, Expression *_aname = nullptr ) : Expression( _aname ), body ( _body ) {}604 UntypedValofExpr( const UntypedValofExpr & other );605 virtual ~UntypedValofExpr();606 607 Expression * get_value();608 Statement * get_body() const { return body; }609 610 virtual UntypedValofExpr * clone() const { return new UntypedValofExpr( * this ); }611 virtual void accept( Visitor & v ) { v.visit( this ); }612 virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }613 virtual void print( std::ostream & os, int indent = 0 ) const;614 private:615 Statement * body;616 };617 618 602 /// RangeExpr represents a range e.g. '3 ... 5' or '1~10' 619 603 class RangeExpr : public Expression { -
src/SynTree/Mutator.cc
rd56e5bc re9a3b20b 380 380 } 381 381 382 Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {383 valofExpr->set_env( maybeMutate( valofExpr->get_env(), *this ) );384 valofExpr->set_result( maybeMutate( valofExpr->get_result(), *this ) );385 return valofExpr;386 }387 388 382 Expression *Mutator::mutate( RangeExpr *rangeExpr ) { 389 383 rangeExpr->set_env( maybeMutate( rangeExpr->get_env(), *this ) ); -
src/SynTree/Mutator.h
rd56e5bc re9a3b20b 78 78 virtual Expression* mutate( ConstructorExpr *ctorExpr ); 79 79 virtual Expression* mutate( CompoundLiteralExpr *compLitExpr ); 80 virtual Expression* mutate( UntypedValofExpr *valofExpr );81 80 virtual Expression* mutate( RangeExpr *rangeExpr ); 82 81 virtual Expression* mutate( UntypedTupleExpr *tupleExpr ); -
src/SynTree/ObjectDecl.cc
rd56e5bc re9a3b20b 56 56 57 57 if ( init ) { 58 os << " with initializer " ;59 init->print( os, indent );60 os << std::endl << std::string(indent , ' ');58 os << " with initializer " << std::endl; 59 init->print( os, indent+2 ); 60 os << std::endl << std::string(indent+2, ' '); 61 61 os << "maybeConstructed? " << init->get_maybeConstructed(); 62 62 } // if -
src/SynTree/Statement.cc
rd56e5bc re9a3b20b 313 313 } 314 314 315 TryStmt::TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list< Statement *> &_handlers, FinallyStmt *_finallyBlock ) :315 TryStmt::TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &_handlers, FinallyStmt *_finallyBlock ) : 316 316 Statement( labels ), block( tryBlock ), handlers( _handlers ), finallyBlock( _finallyBlock ) { 317 317 } … … 334 334 // handlers 335 335 os << string( indent + 2, ' ' ) << "and handlers: " << endl; 336 for ( std::list< Statement *>::const_iterator i = handlers.begin(); i != handlers.end(); i++)336 for ( std::list<CatchStmt *>::const_iterator i = handlers.begin(); i != handlers.end(); i++) 337 337 (*i )->print( os, indent + 4 ); 338 338 -
src/SynTree/Statement.h
rd56e5bc re9a3b20b 315 315 class TryStmt : public Statement { 316 316 public: 317 TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list< Statement *> &handlers, FinallyStmt *finallyBlock = 0 );317 TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 ); 318 318 TryStmt( const TryStmt &other ); 319 319 virtual ~TryStmt(); … … 321 321 CompoundStmt *get_block() const { return block; } 322 322 void set_block( CompoundStmt *newValue ) { block = newValue; } 323 std::list< Statement *>& get_catchers() { return handlers; }323 std::list<CatchStmt *>& get_catchers() { return handlers; } 324 324 325 325 FinallyStmt *get_finally() const { return finallyBlock; } … … 333 333 private: 334 334 CompoundStmt *block; 335 std::list< Statement *> handlers;335 std::list<CatchStmt *> handlers; 336 336 FinallyStmt *finallyBlock; 337 337 }; -
src/SynTree/Visitor.cc
rd56e5bc re9a3b20b 301 301 } 302 302 303 void Visitor::visit( UntypedValofExpr *valofExpr ) {304 maybeAccept( valofExpr->get_result(), *this );305 maybeAccept( valofExpr->get_body(), *this );306 }307 308 303 void Visitor::visit( RangeExpr *rangeExpr ) { 309 304 maybeAccept( rangeExpr->get_low(), *this ); -
src/SynTree/Visitor.h
rd56e5bc re9a3b20b 81 81 virtual void visit( ConstructorExpr * ctorExpr ); 82 82 virtual void visit( CompoundLiteralExpr *compLitExpr ); 83 virtual void visit( UntypedValofExpr *valofExpr );84 83 virtual void visit( RangeExpr *rangeExpr ); 85 84 virtual void visit( UntypedTupleExpr *tupleExpr ); … … 163 162 } // if 164 163 } catch( SemanticError &e ) { 165 e.set_location( (*i)->location ); 164 e.set_location( (*i)->location ); 166 165 errors.append( e ); 167 166 } // try
Note: See TracChangeset
for help on using the changeset viewer.