Changes in src/SymTab/Indexer.cc [4e06c1e:8884112]

File:

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

src/SymTab/Indexer.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:37:33 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jul 12 17:47:47 2016
-// Update Count     : 12
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri Apr 22 15:25:43 2016
+// Update Count     : 11
 //
 
@@ -520 +520 @@
                         const MangleTable &mangleTable = decls->second;
                         for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
-                                // check for C decls with the same name, skipping those with a compatible type (by mangleName)
+                                // 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;
                         }
@@ -526 +527 @@
 
                 return tables->base.hasIncompatibleCDecl( id, mangleName, scope );
+        }
+
+        bool Indexer::hasCompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
+                if ( ! tables ) return false;
+                if ( tables->scope < scope ) return false;
+
+                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 ) {
+                                // check for C decls with the same name, skipping
+                                // those with an incompatible type (by mangleName)
+                                if ( decl->second->get_linkage() == LinkageSpec::C && decl->first == mangleName ) return true;
+                        }
+                }
+
+                return tables->base.hasCompatibleCDecl( id, mangleName, scope );
         }
 
@@ -616 +634 @@
                 } // if
 
+                // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage
+                if ( decl->get_linkage() == LinkageSpec::C ) {
+                        // 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.
+                        if ( hasIncompatibleCDecl( name, mangleName, scope ) ) {
+                                throw SemanticError( "conflicting overload of C function ", decl );
+                        }
+                } else {
+                        // Check that a Cforall declaration doesn't overload any C declaration
+                        if ( hasCompatibleCDecl( name, mangleName, scope ) ) {
+                                throw SemanticError( "Cforall declaration hides C function ", decl );
+                        }
+                }
+
+                // Skip repeat declarations of the same identifier
                 DeclarationWithType *existing = lookupIdAtScope( name, mangleName, scope );
-                if ( ! existing || ! addedIdConflicts( existing, decl ) ) {
-                        // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage
-                        if ( decl->get_linkage() == LinkageSpec::C && hasIncompatibleCDecl( name, mangleName, scope ) ) {
-                                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;
-                        ++tables->size;
-                }
+                if ( existing && addedIdConflicts( existing, decl ) ) return;
+
+                // add to indexer
+                tables->idTable[ name ][ mangleName ] = decl;
+                ++tables->size;
         }