Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/SymTab/Indexer.cc

    r743fbda r0cb1d61  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Indexer.cc --
     7// Indexer.cc -- 
    88//
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 21:37:33 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Fri Apr 22 15:25:43 2016
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Wed Mar  2 17:31:29 2016
    1313// Update Count     : 11
    1414//
    … …  
    5959                }
    6060        }
    61 
     61       
    6262        template< typename Decl >
    6363        void dump( const std::unordered_map< std::string, Decl* > &table, std::ostream &os ) {
    … …  
    6666                } // for
    6767        }
    68 
     68       
    6969        struct Indexer::Impl {
    7070                Impl( unsigned long _scope ) : refCount(1), scope( _scope ), size( 0 ), base(),
    … …  
    7676                unsigned long size;       ///< Number of elements stored in this table
    7777                const Indexer base;       ///< Base indexer this extends
    78 
     78               
    7979                IdTable idTable;          ///< Identifier namespace
    8080                TypeTable typeTable;      ///< Type namespace
    … …  
    213213        void Indexer::visit( StructDecl *aggregateDecl ) {
    214214                // make up a forward declaration and add it before processing the members
    215                 // needs to be on the heap because addStruct saves the pointer
    216                 StructDecl &fwdDecl = *new StructDecl( aggregateDecl->get_name() );
     215                StructDecl fwdDecl( aggregateDecl->get_name() );
    217216                cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
    218217                debugPrint( "Adding fwd decl for struct " << fwdDecl.get_name() << std::endl );
    219218                addStruct( &fwdDecl );
    220 
     219 
    221220                enterScope();
    222221                acceptAll( aggregateDecl->get_parameters(), *this );
    223222                acceptAll( aggregateDecl->get_members(), *this );
    224223                leaveScope();
    225 
     224 
    226225                debugPrint( "Adding struct " << aggregateDecl->get_name() << std::endl );
    227226                // this addition replaces the forward declaration
    … …  
    235234                debugPrint( "Adding fwd decl for union " << fwdDecl.get_name() << std::endl );
    236235                addUnion( &fwdDecl );
    237 
     236 
    238237                enterScope();
    239238                acceptAll( aggregateDecl->get_parameters(), *this );
    240239                acceptAll( aggregateDecl->get_members(), *this );
    241240                leaveScope();
    242 
     241 
    243242                debugPrint( "Adding union " << aggregateDecl->get_name() << std::endl );
    244243                addUnion( aggregateDecl );
    … …  
    257256                acceptAll( aggregateDecl->get_members(), *this );
    258257                leaveScope();
    259 
     258 
    260259                debugPrint( "Adding context " << aggregateDecl->get_name() << std::endl );
    261260                addTrait( aggregateDecl );
    … …  
    439438        }
    440439
    441 
     440       
    442441
    443442        void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &out ) const {
    444443                std::unordered_set< std::string > foundMangleNames;
    445 
     444               
    446445                Indexer::Impl *searchTables = tables;
    447446                while ( searchTables ) {
    … …  
    453452                                        // mark the mangled name as found, skipping this insertion if a declaration for that name has already been found
    454453                                        if ( foundMangleNames.insert( decl->first ).second == false ) continue;
    455 
     454                                       
    456455                                        out.push_back( decl->second );
    457456                                }
    458457                        }
    459 
     458                       
    460459                        // get declarations from base indexers
    461460                        searchTables = searchTables->base.tables;
    … …  
    520519                        const MangleTable &mangleTable = decls->second;
    521520                        for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
    522                                 // check for C decls with the same name, skipping
     521                                // check for C decls with the same name, skipping 
    523522                                // those with a compatible type (by mangleName)
    524523                                if ( decl->second->get_linkage() == LinkageSpec::C && decl->first != mangleName ) return true;
    … …  
    528527                return tables->base.hasIncompatibleCDecl( id, mangleName, scope );
    529528        }
    530 
     529       
    531530        NamedTypeDecl *Indexer::lookupTypeAtScope( const std::string &id, unsigned long scope ) const {
    532531                if ( ! tables ) return 0;
    … …  
    536535                return ret != tables->typeTable.end() ? ret->second : tables->base.lookupTypeAtScope( id, scope );
    537536        }
    538 
     537       
    539538        StructDecl *Indexer::lookupStructAtScope( const std::string &id, unsigned long scope ) const {
    540539                if ( ! tables ) return 0;
    … …  
    544543                return ret != tables->structTable.end() ? ret->second : tables->base.lookupStructAtScope( id, scope );
    545544        }
    546 
     545       
    547546        EnumDecl *Indexer::lookupEnumAtScope( const std::string &id, unsigned long scope ) const {
    548547                if ( ! tables ) return 0;
    … …  
    552551                return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnumAtScope( id, scope );
    553552        }
    554 
     553       
    555554        UnionDecl *Indexer::lookupUnionAtScope( const std::string &id, unsigned long scope ) const {
    556555                if ( ! tables ) return 0;
    … …  
    560559                return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnionAtScope( id, scope );
    561560        }
    562 
     561       
    563562        TraitDecl *Indexer::lookupTraitAtScope( const std::string &id, unsigned long scope ) const {
    564563                if ( ! tables ) return 0;
    … …  
    603602                return true;
    604603        }
    605 
     604       
    606605        void Indexer::addId( DeclarationWithType *decl ) {
    607606                makeWritable();
    … …  
    622621                        if ( decl->get_linkage() == LinkageSpec::C && hasIncompatibleCDecl( name, mangleName, scope ) ) {
    623622                                throw SemanticError( "invalid overload of C function ", decl );
    624                         } // NOTE this is broken in Richard's original code in such a way that it never triggers (it
    625                           // doesn't check decls that have the same manglename, and all C-linkage decls are defined to
     623                        } // NOTE this is broken in Richard's original code in such a way that it never triggers (it 
     624                          // doesn't check decls that have the same manglename, and all C-linkage decls are defined to 
    626625                          // have their name as their manglename, hence the error can never trigger).
    627                           // The code here is closer to correct, but name mangling would have to be completely
     626                          // The code here is closer to correct, but name mangling would have to be completely 
    628627                          // isomorphic to C type-compatibility, which it may not be.
    629 
     628                       
    630629                        tables->idTable[ name ][ mangleName ] = decl;
    631630                        ++tables->size;
    … …  
    642641                }
    643642        }
    644 
     643       
    645644        void Indexer::addType( NamedTypeDecl *decl ) {
    646645                makeWritable();
    … …  
    673672                addStruct( new StructDecl( id ) );
    674673        }
    675 
     674       
    676675        void Indexer::addStruct( StructDecl *decl ) {
    677676                makeWritable();
    … …  
    691690                }
    692691        }
    693 
     692       
    694693        void Indexer::addEnum( EnumDecl *decl ) {
    695694                makeWritable();
    … …  
    713712                addUnion( new UnionDecl( id ) );
    714713        }
    715 
     714       
    716715        void Indexer::addUnion( UnionDecl *decl ) {
    717716                makeWritable();
    … …  
    731730                }
    732731        }
    733 
     732       
    734733        void Indexer::addTrait( TraitDecl *decl ) {
    735734                makeWritable();
    … …  
    752751        void Indexer::enterScope() {
    753752                ++scope;
    754 
     753               
    755754                if ( doDebug ) {
    756755                        std::cout << "--- Entering scope " << scope << std::endl;
    … …  
    805804                        os << "--- end ---" << std::endl;
    806805                }
    807 
     806               
    808807        }
    809808} // namespace SymTab
Note: See TracChangeset for help on using the changeset viewer.