Changeset b3f9a0cb for src/SymTab/Indexer.cc

Timestamp:

Apr 4, 2016, 1:18:17 PM (10 years ago)

Author:

Aaron Moss <a3moss@…>

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, string, with_gc

Children:

afc1045

Parents:

89173242 (diff), 3cfe27f (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.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/SymTab/Indexer.cc (modified) (6 diffs)

src/SymTab/Indexer.cc

@@ -19 +19 @@
 #include <typeinfo>
 #include <unordered_map>
+#include <unordered_set>
 #include <utility>
 
@@ -435 +436 @@
 
         void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &out ) const {
-                if ( ! tables ) return;
-
-                IdTable::const_iterator decls = tables->idTable.find( id );
-                if ( decls != tables->idTable.end() ) {
-                        const MangleTable &mangleTable = decls->second;
-                        for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
-                                out.push_back( decl->second );
-                        }
-                }
+                std::unordered_set< std::string > foundMangleNames;
                 
-                // get declarations from base indexers
-                tables->base.lookupId( id, out );
+                Indexer::Impl *searchTables = tables;
+                while ( searchTables ) {
+
+                        IdTable::const_iterator decls = searchTables->idTable.find( id );
+                        if ( decls != searchTables->idTable.end() ) {
+                                const MangleTable &mangleTable = decls->second;
+                                for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
+                                        // mark the mangled name as found, skipping this insertion if a declaration for that name has already been found
+                                        if ( foundMangleNames.insert( decl->first ).second == false ) continue;
+                                        
+                                        out.push_back( decl->second );
+                                }
+                        }
+                        
+                        // get declarations from base indexers
+                        searchTables = searchTables->base.tables;
+                }
         }
 
@@ -498 +506 @@
         }
 
-        bool Indexer::hasCDeclWithName( const std::string &id ) const {
+        bool Indexer::hasIncompatibleCDecl( const std::string &id, const std::string &mangleName ) const {
                 if ( ! tables ) return false;
 
@@ -505 +513 @@
                         const MangleTable &mangleTable = decls->second;
                         for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
-                                if ( decl->second->get_linkage() == LinkageSpec::C ) return true;
-                        }
-                }
-
-                return tables->base.hasCDeclWithName( id );
+                                // check for C decls with the same name, skipping 
+                                // those with a compatible type (by mangleName)
+                                if ( decl->second->get_linkage() == LinkageSpec::C && decl->first != mangleName ) return true;
+                        }
+                }
+
+                return tables->base.hasIncompatibleCDecl( id, mangleName );
         }
         
@@ -592 +602 @@
                 const std::string &name = decl->get_name();
                 std::string mangleName;
-                if ( decl->get_linkage() == LinkageSpec::C ) {
-                        mangleName = name;
-                } else if ( LinkageSpec::isOverridable( decl->get_linkage() ) ) {
+                if ( LinkageSpec::isOverridable( decl->get_linkage() ) ) {
                         // mangle the name without including the appropriate suffix, so overridable routines are placed into the
                         // same "bucket" as their user defined versions.
@@ -605 +613 @@
                 if ( ! existing || ! addedIdConflicts( existing, decl ) ) {
                         // this ensures that no two declarations with the same unmangled name both have C linkage
-                        if ( decl->get_linkage() == LinkageSpec::C && hasCDeclWithName( name ) ) {
+                        if ( decl->get_linkage() == LinkageSpec::C && hasIncompatibleCDecl( name, mangleName ) ) {
                                 throw SemanticError( "invalid overload of C function ", decl );
-                        }
+                        } // NOTE this is broken in Richard's original code in such a way that it never triggers (it 
+                          // doesn't check decls that have the same manglename, and all C-linkage decls are defined to 
+                          // have their name as their manglename, hence the error can never trigger).
+                          // The code here is closer to correct, but name mangling would have to be completely 
+                          // isomorphic to C type-compatibility, which it may not be.
                         
                         tables->idTable[ name ][ mangleName ] = decl;