Changeset 65197c2 for src/SymTab

Timestamp:

Dec 5, 2017, 2:17:17 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

971d9f2, a85e44c, c13e8dc8

Parents:

12d2dc8 (diff), 866f560 (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

Location:

src/SymTab

Files:

• Indexer.cc (modified) (15 diffs)
• Indexer.h (modified) (4 diffs)

src/SymTab/Indexer.cc

@@ -40 +40 @@
 
 namespace SymTab {
-        typedef std::unordered_map< std::string, DeclarationWithType* > MangleTable;
+        std::ostream & operator<<( std::ostream & out, const Indexer::IdData & data ) {
+                return out << "(" << data.id << "," << data.baseExpr << ")";
+        }
+
+        typedef std::unordered_map< std::string, Indexer::IdData > MangleTable;
         typedef std::unordered_map< std::string, MangleTable > IdTable;
         typedef std::unordered_map< std::string, NamedTypeDecl* > TypeTable;
@@ -97 +101 @@
         }
 
-        void Indexer::removeSpecialOverrides( const std::string &id, std::list< DeclarationWithType * > & out ) const {
+        void Indexer::removeSpecialOverrides( const std::string &id, std::list< IdData > & out ) const {
                 // only need to perform this step for constructors, destructors, and assignment functions
                 if ( ! CodeGen::isCtorDtorAssign( id ) ) return;
@@ -104 +108 @@
                 struct ValueType {
                         struct DeclBall {
-                                FunctionDecl * decl;
+                                IdData decl;
                                 bool isUserDefinedFunc; // properties for this particular decl
                                 bool isDefaultCtor;
@@ -120 +124 @@
                         // another FunctionDecl for the current type was found - determine
                         // if it has special properties and update data structure accordingly
-                        ValueType & operator+=( FunctionDecl * function ) {
+                        ValueType & operator+=( IdData data ) {
+                                DeclarationWithType * function = data.id;
                                 bool isUserDefinedFunc = ! LinkageSpec::isOverridable( function->get_linkage() );
                                 bool isDefaultCtor = InitTweak::isDefaultConstructor( function );
                                 bool isDtor = InitTweak::isDestructor( function );
                                 bool isCopyFunc = InitTweak::isCopyFunction( function, function->get_name() );
-                                decls.push_back( DeclBall{ function, isUserDefinedFunc, isDefaultCtor, isDtor, isCopyFunc } );
+                                decls.push_back( DeclBall{ data, isUserDefinedFunc, isDefaultCtor, isDtor, isCopyFunc } );
                                 existsUserDefinedFunc = existsUserDefinedFunc || isUserDefinedFunc;
                                 existsUserDefinedCtor = existsUserDefinedCtor || (isUserDefinedFunc && CodeGen::isConstructor( function->get_name() ) );
@@ -135 +140 @@
                 }; // ValueType
 
-                std::list< DeclarationWithType * > copy;
+                std::list< IdData > copy;
                 copy.splice( copy.end(), out );
 
                 // organize discovered declarations by type
                 std::unordered_map< std::string, ValueType > funcMap;
-                for ( DeclarationWithType * decl : copy ) {
-                        if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl ) ) {
+                for ( auto decl : copy ) {
+                        if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl.id ) ) {
                                 std::list< DeclarationWithType * > & params = function->get_functionType()->get_parameters();
                                 assert( ! params.empty() );
@@ -147 +152 @@
                                 Type * base = InitTweak::getPointerBase( params.front()->get_type() );
                                 assert( base );
-                                funcMap[ Mangler::mangle( base ) ] += function;
+                                funcMap[ Mangler::mangle( base ) ] += decl;
                         } else {
                                 out.push_back( decl );
@@ -164 +169 @@
                                 bool noUserDefinedFunc = ! val.existsUserDefinedFunc;
                                 bool isUserDefinedFunc = ball.isUserDefinedFunc;
-                                bool isAcceptableDefaultCtor = (! val.existsUserDefinedCtor || (! val.existsUserDefinedDefaultCtor && ball.decl->get_linkage() == LinkageSpec::Intrinsic)) && ball.isDefaultCtor; // allow default constructors only when no user-defined constructors exist, except in the case of intrinsics, which require exact overrides
+                                bool isAcceptableDefaultCtor = (! val.existsUserDefinedCtor || (! val.existsUserDefinedDefaultCtor && ball.decl.id->get_linkage() == LinkageSpec::Intrinsic)) && ball.isDefaultCtor; // allow default constructors only when no user-defined constructors exist, except in the case of intrinsics, which require exact overrides
                                 bool isAcceptableCopyFunc = ! val.existsUserDefinedCopyFunc && ball.isCopyFunc; // handles copy ctor and assignment operator
                                 bool isAcceptableDtor = ! val.existsUserDefinedDtor && ball.isDtor;
@@ -219 +224 @@
         }
 
-        void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &out ) const {
+        void Indexer::lookupId( const std::string &id, std::list< IdData > &out ) const {
                 std::unordered_set< std::string > foundMangleNames;
 
@@ -289 +294 @@
                         const MangleTable &mangleTable = decls->second;
                         MangleTable::const_iterator decl = mangleTable.find( mangleName );
-                        if ( decl != mangleTable.end() ) return decl->second;
+                        if ( decl != mangleTable.end() ) return decl->second.id;
                 }
 
@@ -304 +309 @@
                         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)
-                                if ( ! LinkageSpec::isMangled( decl->second->get_linkage() ) && decl->first != mangleName ) return true;
+                                if ( ! LinkageSpec::isMangled( decl->second.id->get_linkage() ) && decl->first != mangleName ) return true;
                         }
                 }
@@ -321 +326 @@
                                 // check for C decls with the same name, skipping
                                 // those with an incompatible type (by mangleName)
-                                if ( ! LinkageSpec::isMangled( decl->second->get_linkage() ) && decl->first == mangleName ) return true;
+                                if ( ! LinkageSpec::isMangled( decl->second.id->get_linkage() ) && decl->first == mangleName ) return true;
                         }
                 }
@@ -403 +408 @@
         }
 
-        void Indexer::addId( DeclarationWithType *decl ) {
+        void Indexer::addId( DeclarationWithType *decl, Expression * baseExpr ) {
                 debugPrint( "Adding Id " << decl->name << std::endl );
                 makeWritable();
@@ -439 +444 @@
 
                 // add to indexer
-                tables->idTable[ name ][ mangleName ] = decl;
+                tables->idTable[ name ][ mangleName ] = { decl, baseExpr };
                 ++tables->size;
         }
@@ -563 +568 @@
                         if ( ! addedDeclConflicts( existing->second, decl ) ) {
                                 existing->second = decl;
+                        }
+                }
+        }
+
+        void Indexer::addWith( WithStmt * stmt ) {
+                for ( Expression * expr : stmt->exprs ) {
+                        if ( expr->result ) {
+                                AggregateDecl * aggr = expr->result->stripReferences()->getAggr();
+                                assertf( aggr, "WithStmt expr has non-aggregate type: %s", toString( expr->result ).c_str() );
+
+                                for ( Declaration * decl : aggr->members ) {
+                                        if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
+                                                addId( dwt, expr );
+                                        }
+                                }
                         }
                 }
@@ -645 +665 @@
 
         }
+
+        Expression * Indexer::IdData::combine() const {
+                if ( baseExpr ) {
+                        Expression * base = baseExpr->clone();
+                        ResolvExpr::referenceToRvalueConversion( base );
+                        Expression * ret = new MemberExpr( id, base );
+                        // xxx - this introduces hidden environments, for now remove them.
+                        // std::swap( base->env, ret->env );
+                        delete base->env;
+                        base->env = nullptr;
+                        return ret;
+                } else {
+                        return new VariableExpr( id );
+                }
+        }
 } // namespace SymTab
 

src/SymTab/Indexer.h

@@ -39 +39 @@
                 void leaveScope();
 
+                struct IdData {
+                        DeclarationWithType * id;
+                        Expression * baseExpr; // WithExpr
+
+                        Expression * combine() const;
+                };
+
                 /// Gets all declarations with the given ID
-                void lookupId( const std::string &id, std::list< DeclarationWithType* > &out ) const;
+                void lookupId( const std::string &id, std::list< IdData > &out ) const;
                 /// Gets the top-most type declaration with the given ID
                 NamedTypeDecl *lookupType( const std::string &id ) const;
@@ -67 +74 @@
                 TraitDecl *lookupTraitAtScope( const std::string &id, unsigned long scope ) const;
 
-                void addId( DeclarationWithType *decl );
+                void addId( DeclarationWithType *decl, Expression * baseExpr = nullptr );
                 void addType( NamedTypeDecl *decl );
                 void addStruct( const std::string &id );
@@ -75 +82 @@
                 void addUnion( UnionDecl *decl );
                 void addTrait( TraitDecl *decl );
+
+                /// adds all of the IDs from WithStmt exprs
+                void addWith( WithStmt * );
 
                 /// convenience function for adding a list of Ids to the indexer
@@ -100 +110 @@
                 // so that they will not be selected
                 // void removeSpecialOverrides( FunctionDecl *decl );
-                void removeSpecialOverrides( const std::string &id, std::list< DeclarationWithType * > & out ) const;
+                void removeSpecialOverrides( const std::string &id, std::list< IdData > & out ) const;
 
                 /// Ensures that tables variable is writable (i.e. allocated, uniquely owned by this Indexer, and at the current scope)