Changeset 52c2a72 for src

Timestamp:

Mar 8, 2016, 4:28:40 PM (8 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:

bed4c63e

Parents:

e8032b0

Message:

Fold StackTable? variants into indexer

Location:

src/SymTab

Files:

• AggregateTable.h (deleted)
• Indexer.cc (modified) (13 diffs)
• Indexer.h (modified) (3 diffs)
• StackTable.cc (deleted)
• StackTable.h (deleted)
• TypeTable.h (deleted)

src/SymTab/Indexer.cc

@@ -16 +16 @@
 #include "Indexer.h"
 
+#include <string>
+#include <typeinfo>
+#include <unordered_map>
+#include <utility>
+
 #include "IdTable.h"
-#include "AggregateTable.h"
-#include "TypeTable.h"
 
 #include "SynTree/Declaration.h"
@@ -26 +29 @@
 #include "SynTree/Statement.h"
 
-#include <typeinfo>
-#include <utility>
 #include "Common/utility.h"
 
@@ -40 +41 @@
         }
 
+        typedef std::unordered_map< std::string, NamedTypeDecl* > TypeTable;
+        typedef std::unordered_map< std::string, StructDecl* > StructTable;
+        typedef std::unordered_map< std::string, EnumDecl* > EnumTable;
+        typedef std::unordered_map< std::string, UnionDecl* > UnionTable;
+        typedef std::unordered_map< std::string, TraitDecl* > TraitTable;
+
+        template< typename Decl >
+        void dump( const std::unordered_map< std::string, Decl* > &table, std::ostream &os ) {
+                for ( typename std::unordered_map< std::string, Decl* >::const_iterator it = table.begin(); it != table.end(); ++it ) {
+                        os << it->second << std::endl;
+                } // for
+        }
+        
         struct Indexer::Impl {
-                Impl() : refCount(1), size(0), base(),
+                Impl( unsigned long _scope ) : refCount(1), scope( _scope ), size( 0 ), base(),
                                 idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {}
-                Impl( const Indexer &_base ) : refCount(1), size(0), base( _base ),
+                Impl( unsigned long _scope, Indexer &&_base ) : refCount(1), scope( _scope ), size( 0 ), base( _base ),
                                 idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {}
                 unsigned long refCount;   ///< Number of references to these tables
+                unsigned long scope;      ///< Scope these tables are associated with
                 unsigned long size;       ///< Number of elements stored in this table
                 const Indexer base;       ///< Base indexer this extends
@@ -75 +90 @@
         void Indexer::makeWritable() {
                 if ( ! tables ) {
-                        tables = new Indexer::Impl;
-                } else if ( tables->refCount > 1 ) {
-                        // tables->base inherits the ref that used to belong to this indexer
-                        // this is basically equivalent to std::move( *this ) as the argument
-                        tables = new Indexer::Impl( Indexer( tables, doDebug ) );
-                }
-        }
-
-        Indexer::Indexer( bool _doDebug ) : tables(0), doDebug( _doDebug ) {}
-
-        Indexer::Indexer( const Indexer &that ) : tables( newRef( that.tables ) ), doDebug( that.doDebug ) {}
-
-        Indexer::Indexer( Indexer &&that ) : tables( that.tables ), doDebug( that.doDebug ) {
+                        // create indexer if not yet set
+                        tables = new Indexer::Impl( scope );
+                } else if ( tables->refCount > 1 || tables->scope != scope ) {
+                        // make this indexer the base of a fresh indexer at the current scope
+                        tables = new Indexer::Impl( scope, std::move( *this ) );
+                }
+        }
+
+        Indexer::Indexer( bool _doDebug ) : tables( 0 ), scope( 0 ), doDebug( _doDebug ) {}
+
+        Indexer::Indexer( const Indexer &that ) : tables( newRef( that.tables ) ), scope( that.scope ), doDebug( that.doDebug ) {}
+
+        Indexer::Indexer( Indexer &&that ) : tables( that.tables ), scope( that.scope ), doDebug( that.doDebug ) {
                 that.tables = 0;
         }
@@ -99 +114 @@
 
                 tables = newRef( that.tables );
+                scope = that.scope;
                 doDebug = that.doDebug;
 
@@ -108 +124 @@
 
                 tables = that.tables;
+                scope = that.scope;
                 doDebug = that.doDebug;
 
@@ -421 +438 @@
                 if ( ! tables ) return 0;
 
-                NamedTypeDecl *ret = tables->typeTable.lookup( id );
-                return ret ? ret : tables->base.lookupType( id );
+                TypeTable::const_iterator ret = tables->typeTable.find( id );
+                return ret != tables->typeTable.end() ? ret->second : tables->base.lookupType( id );
         }
 
@@ -428 +445 @@
                 if ( ! tables ) return 0;
 
-                StructDecl *ret = tables->structTable.lookup( id );
-                return ret ? ret : tables->base.lookupStruct( id );
+                StructTable::const_iterator ret = tables->structTable.find( id );
+                return ret != tables->structTable.end() ? ret->second : tables->base.lookupStruct( id );
         }
 
@@ -435 +452 @@
                 if ( ! tables ) return 0;
 
-                EnumDecl *ret = tables->enumTable.lookup( id );
-                return ret ? ret : tables->base.lookupEnum( id );
+                EnumTable::const_iterator ret = tables->enumTable.find( id );
+                return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnum( id );
         }
 
@@ -442 +459 @@
                 if ( ! tables ) return 0;
 
-                UnionDecl *ret = tables->unionTable.lookup( id );
-                return ret ? ret : tables->base.lookupUnion( id );
+                UnionTable::const_iterator ret = tables->unionTable.find( id );
+                return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnion( id );
         }
 
@@ -449 +466 @@
                 if ( ! tables ) return 0;
 
-                TraitDecl *ret = tables->traitTable.lookup( id );
-                return ret ? ret : tables->base.lookupTrait( id );
+                TraitTable::const_iterator ret = tables->traitTable.find( id );
+                return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTrait( id );
+        }
+
+        NamedTypeDecl *Indexer::lookupTypeAtScope( const std::string &id, unsigned long scope ) const {
+                if ( ! tables ) return 0;
+                if ( tables->scope < scope ) return 0;
+
+                TypeTable::const_iterator ret = tables->typeTable.find( id );
+                return ret != tables->typeTable.end() ? ret->second : tables->base.lookupTypeAtScope( id, scope );
+        }
+        
+        StructDecl *Indexer::lookupStructAtScope( const std::string &id, unsigned long scope ) const {
+                if ( ! tables ) return 0;
+                if ( tables->scope < scope ) return 0;
+
+                StructTable::const_iterator ret = tables->structTable.find( id );
+                return ret != tables->structTable.end() ? ret->second : tables->base.lookupStructAtScope( id, scope );
+        }
+        
+        EnumDecl *Indexer::lookupEnumAtScope( const std::string &id, unsigned long scope ) const {
+                if ( ! tables ) return 0;
+                if ( tables->scope < scope ) return 0;
+
+                EnumTable::const_iterator ret = tables->enumTable.find( id );
+                return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnumAtScope( id, scope );
+        }
+        
+        UnionDecl *Indexer::lookupUnionAtScope( const std::string &id, unsigned long scope ) const {
+                if ( ! tables ) return 0;
+                if ( tables->scope < scope ) return 0;
+
+                UnionTable::const_iterator ret = tables->unionTable.find( id );
+                return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnionAtScope( id, scope );
+        }
+        
+        TraitDecl *Indexer::lookupTraitAtScope( const std::string &id, unsigned long scope ) const {
+                if ( ! tables ) return 0;
+                if ( tables->scope < scope ) return 0;
+
+                TraitTable::const_iterator ret = tables->traitTable.find( id );
+                return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTraitAtScope( id, scope );
         }
 
@@ -458 +515 @@
                 ++tables->size;
         }
+
+        bool addedTypeConflicts( NamedTypeDecl *existing, NamedTypeDecl *added ) {
+                if ( existing->get_base() == 0 ) {
+                        return false;
+                } else if ( added->get_base() == 0 ) {
+                        return true;
+                } else {
+                        throw SemanticError( "redeclaration of ", added );
+                }
+        }
         
         void Indexer::addType( NamedTypeDecl *decl ) {
                 makeWritable();
-                tables->typeTable.add( decl );
-                ++tables->size;
+
+                const std::string &id = decl->get_name();
+                TypeTable::iterator existing = tables->typeTable.find( id );
+                if ( existing == tables->typeTable.end() ) {
+                        NamedTypeDecl *parent = tables->base.lookupTypeAtScope( id, scope );
+                        if ( ! parent || ! addedTypeConflicts( parent, decl ) ) {
+                                tables->typeTable.insert( existing, std::make_pair( id, decl ) );
+                                ++tables->size;
+                        }
+                } else {
+                        if ( ! addedTypeConflicts( existing->second, decl ) ) {
+                                existing->second = decl;
+                        }
+                }
+        }
+
+        bool addedDeclConflicts( AggregateDecl *existing, AggregateDecl *added ) {
+                if ( existing->get_members().empty() ) {
+                        return false;
+                } else if ( ! added->get_members().empty() ) {
+                        throw SemanticError( "redeclaration of ", added );
+                } // if
+                return true;
         }
 
         void Indexer::addStruct( const std::string &id ) {
-                makeWritable();
-                tables->structTable.add( id );
-                ++tables->size;
+                addStruct( new StructDecl( id ) );
         }
         
         void Indexer::addStruct( StructDecl *decl ) {
                 makeWritable();
-                tables->structTable.add( decl );
-                ++tables->size;
+
+                const std::string &id = decl->get_name();
+                StructTable::iterator existing = tables->structTable.find( id );
+                if ( existing == tables->structTable.end() ) {
+                        StructDecl *parent = tables->base.lookupStructAtScope( id, scope );
+                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
+                                tables->structTable.insert( existing, std::make_pair( id, decl ) );
+                                ++tables->size;
+                        }
+                } else {
+                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
+                                existing->second = decl;
+                        }
+                }
         }
         
         void Indexer::addEnum( EnumDecl *decl ) {
                 makeWritable();
-                tables->enumTable.add( decl );
-                ++tables->size;
+
+                const std::string &id = decl->get_name();
+                EnumTable::iterator existing = tables->enumTable.find( id );
+                if ( existing == tables->enumTable.end() ) {
+                        EnumDecl *parent = tables->base.lookupEnumAtScope( id, scope );
+                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
+                                tables->enumTable.insert( existing, std::make_pair( id, decl ) );
+                                ++tables->size;
+                        }
+                } else {
+                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
+                                existing->second = decl;
+                        }
+                }
         }
 
         void Indexer::addUnion( const std::string &id ) {
-                makeWritable();
-                tables->unionTable.add( id );
-                ++tables->size;
+                addUnion( new UnionDecl( id ) );
         }
         
         void Indexer::addUnion( UnionDecl *decl ) {
                 makeWritable();
-                tables->unionTable.add( decl );
-                ++tables->size;
+
+                const std::string &id = decl->get_name();
+                UnionTable::iterator existing = tables->unionTable.find( id );
+                if ( existing == tables->unionTable.end() ) {
+                        UnionDecl *parent = tables->base.lookupUnionAtScope( id, scope );
+                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
+                                tables->unionTable.insert( existing, std::make_pair( id, decl ) );
+                                ++tables->size;
+                        }
+                } else {
+                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
+                                existing->second = decl;
+                        }
+                }
         }
         
         void Indexer::addTrait( TraitDecl *decl ) {
                 makeWritable();
-                tables->traitTable.add( decl );
-                ++tables->size;
+
+                const std::string &id = decl->get_name();
+                TraitTable::iterator existing = tables->traitTable.find( id );
+                if ( existing == tables->traitTable.end() ) {
+                        TraitDecl *parent = tables->base.lookupTraitAtScope( id, scope );
+                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
+                                tables->traitTable.insert( existing, std::make_pair( id, decl ) );
+                                ++tables->size;
+                        }
+                } else {
+                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
+                                existing->second = decl;
+                        }
+                }
         }
 
         void Indexer::enterScope() {
-                makeWritable();
+                ++scope;
                 
                 if ( doDebug ) {
-                        std::cout << "--- Entering scope" << std::endl;
-                }
-
-                tables->idTable.enterScope();
-                tables->typeTable.enterScope();
-                tables->structTable.enterScope();
-                tables->enumTable.enterScope();
-                tables->unionTable.enterScope();
-                tables->traitTable.enterScope();
+                        std::cout << "--- Entering scope " << scope << std::endl;
+                }
         }
 
         void Indexer::leaveScope() {
                 using std::cout;
-                
-                makeWritable();
-                
-                if ( doDebug ) {
-                        cout << "--- Leaving scope containing" << std::endl;
-                        tables->idTable.dump( cout );
-                        tables->typeTable.dump( cout );
-                        tables->structTable.dump( cout );
-                        tables->enumTable.dump( cout );
-                        tables->unionTable.dump( cout );
-                        tables->traitTable.dump( cout );
-                }
-                tables->idTable.leaveScope();
-                tables->typeTable.leaveScope();
-                tables->structTable.leaveScope();
-                tables->enumTable.leaveScope();
-                tables->unionTable.leaveScope();
-                tables->traitTable.leaveScope();
+
+                assert( scope > 0 && "cannot leave initial scope" );
+                --scope;
+
+                while ( tables && tables->scope > scope ) {
+                        if ( doDebug ) {
+                                cout << "--- Leaving scope " << tables->scope << " containing" << std::endl;
+                                tables->idTable.dump( cout );
+                                dump( tables->typeTable, cout );
+                                dump( tables->structTable, cout );
+                                dump( tables->enumTable, cout );
+                                dump( tables->unionTable, cout );
+                                dump( tables->traitTable, cout );
+                        }
+
+                        // swap tables for base table until we find one at an appropriate scope
+                        Indexer::Impl *base = newRef( tables->base.tables );
+                        deleteRef( tables );
+                        tables = base;
+                }
         }
 
@@ -544 +671 @@
             if ( tables ) tables->idTable.dump( os );
             cerr << "===typeTable===" << std::endl;
-            if ( tables ) tables->typeTable.dump( os );
+            if ( tables ) dump( tables->typeTable, os );
             cerr << "===structTable===" << std::endl;
-            if ( tables ) tables->structTable.dump( os );
+            if ( tables ) dump( tables->structTable, os );
             cerr << "===enumTable===" << std::endl;
-            if ( tables ) tables->enumTable.dump( os );
+            if ( tables ) dump( tables->enumTable, os );
             cerr << "===unionTable===" << std::endl;
-            if ( tables ) tables->unionTable.dump( os );
+            if ( tables ) dump( tables->unionTable, os );
             cerr << "===contextTable===" << std::endl;
-            if ( tables ) tables->traitTable.dump( os );
+            if ( tables ) dump( tables->traitTable, os );
         }
 } // namespace SymTab

src/SymTab/Indexer.h

@@ -90 +90 @@
                 void print( std::ostream &os, int indent = 0 ) const;
           private:
+                // equivalents to lookup functions that only look at tables at scope `scope` (which should be >= tables->scope)
+                NamedTypeDecl *lookupTypeAtScope( const std::string &id, unsigned long scope ) const;
+                StructDecl *lookupStructAtScope( const std::string &id, unsigned long scope ) const;
+                EnumDecl *lookupEnumAtScope( const std::string &id, unsigned long scope ) const;
+                UnionDecl *lookupUnionAtScope( const std::string &id, unsigned long scope ) const;
+                TraitDecl *lookupTraitAtScope( const std::string &id, unsigned long scope ) const;
+                
                 void addId( DeclarationWithType *decl );
                 void addType( NamedTypeDecl *decl );
@@ -100 +107 @@
                 
                 struct Impl;
-                Impl *tables;  ///< Copy-on-write instance of table data structure
-                bool doDebug;  ///< Display debugging trace?
-
-                Indexer( Impl *_tables, bool _doDebug ) : tables( _tables ), doDebug( _doDebug ) {}
+                Impl *tables;         ///< Copy-on-write instance of table data structure
+                unsigned long scope;  ///< Scope index of this pointer
+                bool doDebug;         ///< Display debugging trace?
 
                 /// Takes a new ref to a table (returns null if null)
@@ -110 +116 @@
                 static void deleteRef( Impl *toFree );
 
-                /// Ensures that tables variable is writable (i.e. allocated and uniquely owned by this Indexer)
+                /// Ensures that tables variable is writable (i.e. allocated, uniquely owned by this Indexer, and at the current scope)
                 void makeWritable();
         };