Changeset 0f9e4403 for src/SymTab/Indexer.cc
- Timestamp:
- Apr 15, 2016, 12:03:11 PM (8 years ago)
- Branches:
- ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
- Children:
- 29ad0ac
- Parents:
- c5833e8 (diff), 37f0da8 (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. - File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
src/SymTab/Indexer.cc
rc5833e8 r0f9e4403 9 9 // Author : Richard C. Bilson 10 10 // Created On : Sun May 17 21:37:33 2015 11 // Last Modified By : Rob Schluntz 12 // Last Modified On : Wed Aug 05 13:52:42 2015 13 // Update Count : 10 14 // 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed Mar 2 17:31:29 2016 13 // Update Count : 11 14 // 15 16 #include "Indexer.h" 17 18 #include <string> 19 #include <typeinfo> 20 #include <unordered_map> 21 #include <unordered_set> 22 #include <utility> 23 24 #include "Mangler.h" 25 26 #include "Common/utility.h" 27 28 #include "ResolvExpr/typeops.h" 15 29 16 30 #include "SynTree/Declaration.h" … … 19 33 #include "SynTree/Initializer.h" 20 34 #include "SynTree/Statement.h" 21 #include "Indexer.h"22 #include <typeinfo>23 #include "Common/utility.h"24 35 25 36 #define debugPrint(x) if ( doDebug ) { std::cout << x; } … … 33 44 } 34 45 35 Indexer::Indexer( bool useDebug ) : doDebug( useDebug ) {} 36 37 Indexer::~Indexer() {} 46 typedef std::unordered_map< std::string, DeclarationWithType* > MangleTable; 47 typedef std::unordered_map< std::string, MangleTable > IdTable; 48 typedef std::unordered_map< std::string, NamedTypeDecl* > TypeTable; 49 typedef std::unordered_map< std::string, StructDecl* > StructTable; 50 typedef std::unordered_map< std::string, EnumDecl* > EnumTable; 51 typedef std::unordered_map< std::string, UnionDecl* > UnionTable; 52 typedef std::unordered_map< std::string, TraitDecl* > TraitTable; 53 54 void dump( const IdTable &table, std::ostream &os ) { 55 for ( IdTable::const_iterator id = table.begin(); id != table.end(); ++id ) { 56 for ( MangleTable::const_iterator mangle = id->second.begin(); mangle != id->second.end(); ++mangle ) { 57 os << mangle->second << std::endl; 58 } 59 } 60 } 61 62 template< typename Decl > 63 void dump( const std::unordered_map< std::string, Decl* > &table, std::ostream &os ) { 64 for ( typename std::unordered_map< std::string, Decl* >::const_iterator it = table.begin(); it != table.end(); ++it ) { 65 os << it->second << std::endl; 66 } // for 67 } 68 69 struct Indexer::Impl { 70 Impl( unsigned long _scope ) : refCount(1), scope( _scope ), size( 0 ), base(), 71 idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {} 72 Impl( unsigned long _scope, Indexer &&_base ) : refCount(1), scope( _scope ), size( 0 ), base( _base ), 73 idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {} 74 unsigned long refCount; ///< Number of references to these tables 75 unsigned long scope; ///< Scope these tables are associated with 76 unsigned long size; ///< Number of elements stored in this table 77 const Indexer base; ///< Base indexer this extends 78 79 IdTable idTable; ///< Identifier namespace 80 TypeTable typeTable; ///< Type namespace 81 StructTable structTable; ///< Struct namespace 82 EnumTable enumTable; ///< Enum namespace 83 UnionTable unionTable; ///< Union namespace 84 TraitTable traitTable; ///< Trait namespace 85 }; 86 87 Indexer::Impl *Indexer::newRef( Indexer::Impl *toClone ) { 88 if ( ! toClone ) return 0; 89 90 // shorten the search chain by skipping empty links 91 Indexer::Impl *ret = toClone->size == 0 ? toClone->base.tables : toClone; 92 if ( ret ) { ++ret->refCount; } 93 94 return ret; 95 } 96 97 void Indexer::deleteRef( Indexer::Impl *toFree ) { 98 if ( ! toFree ) return; 99 100 if ( --toFree->refCount == 0 ) delete toFree; 101 } 102 103 void Indexer::makeWritable() { 104 if ( ! tables ) { 105 // create indexer if not yet set 106 tables = new Indexer::Impl( scope ); 107 } else if ( tables->refCount > 1 || tables->scope != scope ) { 108 // make this indexer the base of a fresh indexer at the current scope 109 tables = new Indexer::Impl( scope, std::move( *this ) ); 110 } 111 } 112 113 Indexer::Indexer( bool _doDebug ) : tables( 0 ), scope( 0 ), doDebug( _doDebug ) {} 114 115 Indexer::Indexer( const Indexer &that ) : tables( newRef( that.tables ) ), scope( that.scope ), doDebug( that.doDebug ) {} 116 117 Indexer::Indexer( Indexer &&that ) : tables( that.tables ), scope( that.scope ), doDebug( that.doDebug ) { 118 that.tables = 0; 119 } 120 121 Indexer::~Indexer() { 122 deleteRef( tables ); 123 } 124 125 Indexer& Indexer::operator= ( const Indexer &that ) { 126 deleteRef( tables ); 127 128 tables = newRef( that.tables ); 129 scope = that.scope; 130 doDebug = that.doDebug; 131 132 return *this; 133 } 134 135 Indexer& Indexer::operator= ( Indexer &&that ) { 136 deleteRef( tables ); 137 138 tables = that.tables; 139 scope = that.scope; 140 doDebug = that.doDebug; 141 142 that.tables = 0; 143 144 return *this; 145 } 38 146 39 147 void Indexer::visit( ObjectDecl *objectDecl ) { … … 45 153 if ( objectDecl->get_name() != "" ) { 46 154 debugPrint( "Adding object " << objectDecl->get_name() << std::endl ); 47 idTable.addDecl( objectDecl );155 addId( objectDecl ); 48 156 } // if 49 157 } … … 52 160 if ( functionDecl->get_name() == "" ) return; 53 161 debugPrint( "Adding function " << functionDecl->get_name() << std::endl ); 54 idTable.addDecl( functionDecl );162 addId( functionDecl ); 55 163 enterScope(); 56 164 maybeAccept( functionDecl->get_functionType(), *this ); … … 90 198 leaveScope(); 91 199 debugPrint( "Adding type " << typeDecl->get_name() << std::endl ); 92 typeTable.add( typeDecl );200 addType( typeDecl ); 93 201 acceptAll( typeDecl->get_assertions(), *this ); 94 202 } … … 100 208 leaveScope(); 101 209 debugPrint( "Adding typedef " << typeDecl->get_name() << std::endl ); 102 typeTable.add( typeDecl );210 addType( typeDecl ); 103 211 } 104 212 … … 108 216 cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() ); 109 217 debugPrint( "Adding fwd decl for struct " << fwdDecl.get_name() << std::endl ); 110 structTable.add( &fwdDecl );218 addStruct( &fwdDecl ); 111 219 112 220 enterScope(); … … 117 225 debugPrint( "Adding struct " << aggregateDecl->get_name() << std::endl ); 118 226 // this addition replaces the forward declaration 119 structTable.add( aggregateDecl );227 addStruct( aggregateDecl ); 120 228 } 121 229 … … 125 233 cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() ); 126 234 debugPrint( "Adding fwd decl for union " << fwdDecl.get_name() << std::endl ); 127 unionTable.add( &fwdDecl );235 addUnion( &fwdDecl ); 128 236 129 237 enterScope(); … … 133 241 134 242 debugPrint( "Adding union " << aggregateDecl->get_name() << std::endl ); 135 unionTable.add( aggregateDecl );243 addUnion( aggregateDecl ); 136 244 } 137 245 138 246 void Indexer::visit( EnumDecl *aggregateDecl ) { 139 247 debugPrint( "Adding enum " << aggregateDecl->get_name() << std::endl ); 140 enumTable.add( aggregateDecl );248 addEnum( aggregateDecl ); 141 249 // unlike structs, contexts, and unions, enums inject their members into the global scope 142 250 acceptAll( aggregateDecl->get_members(), *this ); 143 251 } 144 252 145 void Indexer::visit( ContextDecl *aggregateDecl ) {253 void Indexer::visit( TraitDecl *aggregateDecl ) { 146 254 enterScope(); 147 255 acceptAll( aggregateDecl->get_parameters(), *this ); … … 150 258 151 259 debugPrint( "Adding context " << aggregateDecl->get_name() << std::endl ); 152 contextTable.add( aggregateDecl );260 addTrait( aggregateDecl ); 153 261 } 154 262 … … 236 344 maybeAccept( offsetofExpr->get_type(), *this ); 237 345 maybeAccept( offsetofExpr->get_member(), *this ); 346 } 347 348 void Indexer::visit( OffsetPackExpr *offsetPackExpr ) { 349 acceptAllNewScope( offsetPackExpr->get_results(), *this ); 350 maybeAccept( offsetPackExpr->get_type(), *this ); 238 351 } 239 352 … … 293 406 294 407 295 void Indexer::visit( ContextInstType *contextInst ) {408 void Indexer::visit( TraitInstType *contextInst ) { 296 409 acceptAll( contextInst->get_parameters(), *this ); 297 410 acceptAll( contextInst->get_members(), *this ); … … 299 412 300 413 void Indexer::visit( StructInstType *structInst ) { 301 if ( ! structTable.lookup( structInst->get_name() ) ) {414 if ( ! lookupStruct( structInst->get_name() ) ) { 302 415 debugPrint( "Adding struct " << structInst->get_name() << " from implicit forward declaration" << std::endl ); 303 structTable.add( structInst->get_name() );416 addStruct( structInst->get_name() ); 304 417 } 305 418 enterScope(); … … 309 422 310 423 void Indexer::visit( UnionInstType *unionInst ) { 311 if ( ! unionTable.lookup( unionInst->get_name() ) ) {424 if ( ! lookupUnion( unionInst->get_name() ) ) { 312 425 debugPrint( "Adding union " << unionInst->get_name() << " from implicit forward declaration" << std::endl ); 313 unionTable.add( unionInst->get_name() );426 addUnion( unionInst->get_name() ); 314 427 } 315 428 enterScope(); … … 325 438 } 326 439 327 328 void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &list ) const { 329 idTable.lookupId( id, list ); 330 } 331 332 DeclarationWithType* Indexer::lookupId( const std::string &id) const { 333 return idTable.lookupId(id); 440 441 442 void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &out ) const { 443 std::unordered_set< std::string > foundMangleNames; 444 445 Indexer::Impl *searchTables = tables; 446 while ( searchTables ) { 447 448 IdTable::const_iterator decls = searchTables->idTable.find( id ); 449 if ( decls != searchTables->idTable.end() ) { 450 const MangleTable &mangleTable = decls->second; 451 for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) { 452 // mark the mangled name as found, skipping this insertion if a declaration for that name has already been found 453 if ( foundMangleNames.insert( decl->first ).second == false ) continue; 454 455 out.push_back( decl->second ); 456 } 457 } 458 459 // get declarations from base indexers 460 searchTables = searchTables->base.tables; 461 } 334 462 } 335 463 336 464 NamedTypeDecl *Indexer::lookupType( const std::string &id ) const { 337 return typeTable.lookup( id ); 465 if ( ! tables ) return 0; 466 467 TypeTable::const_iterator ret = tables->typeTable.find( id ); 468 return ret != tables->typeTable.end() ? ret->second : tables->base.lookupType( id ); 338 469 } 339 470 340 471 StructDecl *Indexer::lookupStruct( const std::string &id ) const { 341 return structTable.lookup( id ); 472 if ( ! tables ) return 0; 473 474 StructTable::const_iterator ret = tables->structTable.find( id ); 475 return ret != tables->structTable.end() ? ret->second : tables->base.lookupStruct( id ); 342 476 } 343 477 344 478 EnumDecl *Indexer::lookupEnum( const std::string &id ) const { 345 return enumTable.lookup( id ); 479 if ( ! tables ) return 0; 480 481 EnumTable::const_iterator ret = tables->enumTable.find( id ); 482 return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnum( id ); 346 483 } 347 484 348 485 UnionDecl *Indexer::lookupUnion( const std::string &id ) const { 349 return unionTable.lookup( id ); 350 } 351 352 ContextDecl * Indexer::lookupContext( const std::string &id ) const { 353 return contextTable.lookup( id ); 486 if ( ! tables ) return 0; 487 488 UnionTable::const_iterator ret = tables->unionTable.find( id ); 489 return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnion( id ); 490 } 491 492 TraitDecl *Indexer::lookupTrait( const std::string &id ) const { 493 if ( ! tables ) return 0; 494 495 TraitTable::const_iterator ret = tables->traitTable.find( id ); 496 return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTrait( id ); 497 } 498 499 DeclarationWithType *Indexer::lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const { 500 if ( ! tables ) return 0; 501 if ( tables->scope < scope ) return 0; 502 503 IdTable::const_iterator decls = tables->idTable.find( id ); 504 if ( decls != tables->idTable.end() ) { 505 const MangleTable &mangleTable = decls->second; 506 MangleTable::const_iterator decl = mangleTable.find( mangleName ); 507 if ( decl != mangleTable.end() ) return decl->second; 508 } 509 510 return tables->base.lookupIdAtScope( id, mangleName, scope ); 511 } 512 513 bool Indexer::hasIncompatibleCDecl( const std::string &id, const std::string &mangleName ) const { 514 if ( ! tables ) return false; 515 516 IdTable::const_iterator decls = tables->idTable.find( id ); 517 if ( decls != tables->idTable.end() ) { 518 const MangleTable &mangleTable = decls->second; 519 for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) { 520 // check for C decls with the same name, skipping 521 // those with a compatible type (by mangleName) 522 if ( decl->second->get_linkage() == LinkageSpec::C && decl->first != mangleName ) return true; 523 } 524 } 525 526 return tables->base.hasIncompatibleCDecl( id, mangleName ); 527 } 528 529 NamedTypeDecl *Indexer::lookupTypeAtScope( const std::string &id, unsigned long scope ) const { 530 if ( ! tables ) return 0; 531 if ( tables->scope < scope ) return 0; 532 533 TypeTable::const_iterator ret = tables->typeTable.find( id ); 534 return ret != tables->typeTable.end() ? ret->second : tables->base.lookupTypeAtScope( id, scope ); 535 } 536 537 StructDecl *Indexer::lookupStructAtScope( const std::string &id, unsigned long scope ) const { 538 if ( ! tables ) return 0; 539 if ( tables->scope < scope ) return 0; 540 541 StructTable::const_iterator ret = tables->structTable.find( id ); 542 return ret != tables->structTable.end() ? ret->second : tables->base.lookupStructAtScope( id, scope ); 543 } 544 545 EnumDecl *Indexer::lookupEnumAtScope( const std::string &id, unsigned long scope ) const { 546 if ( ! tables ) return 0; 547 if ( tables->scope < scope ) return 0; 548 549 EnumTable::const_iterator ret = tables->enumTable.find( id ); 550 return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnumAtScope( id, scope ); 551 } 552 553 UnionDecl *Indexer::lookupUnionAtScope( const std::string &id, unsigned long scope ) const { 554 if ( ! tables ) return 0; 555 if ( tables->scope < scope ) return 0; 556 557 UnionTable::const_iterator ret = tables->unionTable.find( id ); 558 return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnionAtScope( id, scope ); 559 } 560 561 TraitDecl *Indexer::lookupTraitAtScope( const std::string &id, unsigned long scope ) const { 562 if ( ! tables ) return 0; 563 if ( tables->scope < scope ) return 0; 564 565 TraitTable::const_iterator ret = tables->traitTable.find( id ); 566 return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTraitAtScope( id, scope ); 567 } 568 569 bool addedIdConflicts( DeclarationWithType *existing, DeclarationWithType *added ) { 570 // if we're giving the same name mangling to things of different types then there is something wrong 571 assert( (dynamic_cast<ObjectDecl*>( added ) && dynamic_cast<ObjectDecl*>( existing ) ) 572 || (dynamic_cast<FunctionDecl*>( added ) && dynamic_cast<FunctionDecl*>( existing ) ) ); 573 574 if ( LinkageSpec::isOverridable( existing->get_linkage() ) ) { 575 // new definition shadows the autogenerated one, even at the same scope 576 return false; 577 } else if ( added->get_linkage() != LinkageSpec::C || ResolvExpr::typesCompatible( added->get_type(), existing->get_type(), Indexer() ) ) { 578 // typesCompatible doesn't really do the right thing here. When checking compatibility of function types, 579 // we should ignore outermost pointer qualifiers, except _Atomic? 580 FunctionDecl *newentry = dynamic_cast< FunctionDecl* >( added ); 581 FunctionDecl *oldentry = dynamic_cast< FunctionDecl* >( existing ); 582 if ( newentry && oldentry ) { 583 if ( newentry->get_statements() && oldentry->get_statements() ) { 584 throw SemanticError( "duplicate function definition for ", added ); 585 } // if 586 } else { 587 // two objects with the same mangled name defined in the same scope. 588 // both objects must be marked extern or both must be intrinsic for this to be okay 589 // xxx - perhaps it's actually if either is intrinsic then this is okay? 590 // might also need to be same storage class? 591 ObjectDecl *newobj = dynamic_cast< ObjectDecl* >( added ); 592 ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( existing ); 593 if ( newobj->get_storageClass() != DeclarationNode::Extern && oldobj->get_storageClass() != DeclarationNode::Extern ) { 594 throw SemanticError( "duplicate object definition for ", added ); 595 } // if 596 } // if 597 } else { 598 throw SemanticError( "duplicate definition for ", added ); 599 } // if 600 601 return true; 602 } 603 604 void Indexer::addId( DeclarationWithType *decl ) { 605 makeWritable(); 606 607 const std::string &name = decl->get_name(); 608 std::string mangleName; 609 if ( LinkageSpec::isOverridable( decl->get_linkage() ) ) { 610 // mangle the name without including the appropriate suffix, so overridable routines are placed into the 611 // same "bucket" as their user defined versions. 612 mangleName = Mangler::mangle( decl, false ); 613 } else { 614 mangleName = Mangler::mangle( decl ); 615 } // if 616 617 DeclarationWithType *existing = lookupIdAtScope( name, mangleName, scope ); 618 if ( ! existing || ! addedIdConflicts( existing, decl ) ) { 619 // this ensures that no two declarations with the same unmangled name both have C linkage 620 if ( decl->get_linkage() == LinkageSpec::C && hasIncompatibleCDecl( name, mangleName ) ) { 621 throw SemanticError( "invalid overload of C function ", decl ); 622 } // NOTE this is broken in Richard's original code in such a way that it never triggers (it 623 // doesn't check decls that have the same manglename, and all C-linkage decls are defined to 624 // have their name as their manglename, hence the error can never trigger). 625 // The code here is closer to correct, but name mangling would have to be completely 626 // isomorphic to C type-compatibility, which it may not be. 627 628 tables->idTable[ name ][ mangleName ] = decl; 629 ++tables->size; 630 } 631 } 632 633 bool addedTypeConflicts( NamedTypeDecl *existing, NamedTypeDecl *added ) { 634 if ( existing->get_base() == 0 ) { 635 return false; 636 } else if ( added->get_base() == 0 ) { 637 return true; 638 } else { 639 throw SemanticError( "redeclaration of ", added ); 640 } 641 } 642 643 void Indexer::addType( NamedTypeDecl *decl ) { 644 makeWritable(); 645 646 const std::string &id = decl->get_name(); 647 TypeTable::iterator existing = tables->typeTable.find( id ); 648 if ( existing == tables->typeTable.end() ) { 649 NamedTypeDecl *parent = tables->base.lookupTypeAtScope( id, scope ); 650 if ( ! parent || ! addedTypeConflicts( parent, decl ) ) { 651 tables->typeTable.insert( existing, std::make_pair( id, decl ) ); 652 ++tables->size; 653 } 654 } else { 655 if ( ! addedTypeConflicts( existing->second, decl ) ) { 656 existing->second = decl; 657 } 658 } 659 } 660 661 bool addedDeclConflicts( AggregateDecl *existing, AggregateDecl *added ) { 662 if ( existing->get_members().empty() ) { 663 return false; 664 } else if ( ! added->get_members().empty() ) { 665 throw SemanticError( "redeclaration of ", added ); 666 } // if 667 return true; 668 } 669 670 void Indexer::addStruct( const std::string &id ) { 671 addStruct( new StructDecl( id ) ); 672 } 673 674 void Indexer::addStruct( StructDecl *decl ) { 675 makeWritable(); 676 677 const std::string &id = decl->get_name(); 678 StructTable::iterator existing = tables->structTable.find( id ); 679 if ( existing == tables->structTable.end() ) { 680 StructDecl *parent = tables->base.lookupStructAtScope( id, scope ); 681 if ( ! parent || ! addedDeclConflicts( parent, decl ) ) { 682 tables->structTable.insert( existing, std::make_pair( id, decl ) ); 683 ++tables->size; 684 } 685 } else { 686 if ( ! addedDeclConflicts( existing->second, decl ) ) { 687 existing->second = decl; 688 } 689 } 690 } 691 692 void Indexer::addEnum( EnumDecl *decl ) { 693 makeWritable(); 694 695 const std::string &id = decl->get_name(); 696 EnumTable::iterator existing = tables->enumTable.find( id ); 697 if ( existing == tables->enumTable.end() ) { 698 EnumDecl *parent = tables->base.lookupEnumAtScope( id, scope ); 699 if ( ! parent || ! addedDeclConflicts( parent, decl ) ) { 700 tables->enumTable.insert( existing, std::make_pair( id, decl ) ); 701 ++tables->size; 702 } 703 } else { 704 if ( ! addedDeclConflicts( existing->second, decl ) ) { 705 existing->second = decl; 706 } 707 } 708 } 709 710 void Indexer::addUnion( const std::string &id ) { 711 addUnion( new UnionDecl( id ) ); 712 } 713 714 void Indexer::addUnion( UnionDecl *decl ) { 715 makeWritable(); 716 717 const std::string &id = decl->get_name(); 718 UnionTable::iterator existing = tables->unionTable.find( id ); 719 if ( existing == tables->unionTable.end() ) { 720 UnionDecl *parent = tables->base.lookupUnionAtScope( id, scope ); 721 if ( ! parent || ! addedDeclConflicts( parent, decl ) ) { 722 tables->unionTable.insert( existing, std::make_pair( id, decl ) ); 723 ++tables->size; 724 } 725 } else { 726 if ( ! addedDeclConflicts( existing->second, decl ) ) { 727 existing->second = decl; 728 } 729 } 730 } 731 732 void Indexer::addTrait( TraitDecl *decl ) { 733 makeWritable(); 734 735 const std::string &id = decl->get_name(); 736 TraitTable::iterator existing = tables->traitTable.find( id ); 737 if ( existing == tables->traitTable.end() ) { 738 TraitDecl *parent = tables->base.lookupTraitAtScope( id, scope ); 739 if ( ! parent || ! addedDeclConflicts( parent, decl ) ) { 740 tables->traitTable.insert( existing, std::make_pair( id, decl ) ); 741 ++tables->size; 742 } 743 } else { 744 if ( ! addedDeclConflicts( existing->second, decl ) ) { 745 existing->second = decl; 746 } 747 } 354 748 } 355 749 356 750 void Indexer::enterScope() { 751 ++scope; 752 357 753 if ( doDebug ) { 358 std::cout << "--- Entering scope" << std::endl; 359 } 360 idTable.enterScope(); 361 typeTable.enterScope(); 362 structTable.enterScope(); 363 enumTable.enterScope(); 364 unionTable.enterScope(); 365 contextTable.enterScope(); 754 std::cout << "--- Entering scope " << scope << std::endl; 755 } 366 756 } 367 757 368 758 void Indexer::leaveScope() { 369 759 using std::cout; 370 using std::endl; 371 372 if ( doDebug ) { 373 cout << "--- Leaving scope containing" << endl; 374 idTable.dump( cout ); 375 typeTable.dump( cout ); 376 structTable.dump( cout ); 377 enumTable.dump( cout ); 378 unionTable.dump( cout ); 379 contextTable.dump( cout ); 380 } 381 idTable.leaveScope(); 382 typeTable.leaveScope(); 383 structTable.leaveScope(); 384 enumTable.leaveScope(); 385 unionTable.leaveScope(); 386 contextTable.leaveScope(); 760 761 assert( scope > 0 && "cannot leave initial scope" ); 762 --scope; 763 764 while ( tables && tables->scope > scope ) { 765 if ( doDebug ) { 766 cout << "--- Leaving scope " << tables->scope << " containing" << std::endl; 767 dump( tables->idTable, cout ); 768 dump( tables->typeTable, cout ); 769 dump( tables->structTable, cout ); 770 dump( tables->enumTable, cout ); 771 dump( tables->unionTable, cout ); 772 dump( tables->traitTable, cout ); 773 } 774 775 // swap tables for base table until we find one at an appropriate scope 776 Indexer::Impl *base = newRef( tables->base.tables ); 777 deleteRef( tables ); 778 tables = base; 779 } 387 780 } 388 781 389 782 void Indexer::print( std::ostream &os, int indent ) const { 390 783 using std::cerr; 391 using std::endl; 392 393 cerr << "===idTable===" << endl; 394 idTable.dump( os ); 395 cerr << "===typeTable===" << endl; 396 typeTable.dump( os ); 397 cerr << "===structTable===" << endl; 398 structTable.dump( os ); 399 cerr << "===enumTable===" << endl; 400 enumTable.dump( os ); 401 cerr << "===unionTable===" << endl; 402 unionTable.dump( os ); 403 cerr << "===contextTable===" << endl; 404 contextTable.dump( os ); 405 #if 0 406 idTable.dump( os ); 407 typeTable.dump( os ); 408 structTable.dump( os ); 409 enumTable.dump( os ); 410 unionTable.dump( os ); 411 contextTable.dump( os ); 412 #endif 784 785 cerr << "===idTable===" << std::endl; 786 if ( tables ) dump( tables->idTable, os ); 787 cerr << "===typeTable===" << std::endl; 788 if ( tables ) dump( tables->typeTable, os ); 789 cerr << "===structTable===" << std::endl; 790 if ( tables ) dump( tables->structTable, os ); 791 cerr << "===enumTable===" << std::endl; 792 if ( tables ) dump( tables->enumTable, os ); 793 cerr << "===unionTable===" << std::endl; 794 if ( tables ) dump( tables->unionTable, os ); 795 cerr << "===contextTable===" << std::endl; 796 if ( tables ) dump( tables->traitTable, os ); 413 797 } 414 798 } // namespace SymTab
Note: See TracChangeset
for help on using the changeset viewer.