Changeset 0531b5d for src/GenPoly

Timestamp:

Mar 9, 2016, 3:11:25 PM (9 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:

89173242

Parents:

d1caa6c

Message:

Fixed ScopedMap?'s const find, refactored InstantionMap? to use ScopedMap?

Location:

src/GenPoly

Files:

• Box.cc (modified) (2 diffs)
• ScopedMap.h (modified) (5 diffs)

src/GenPoly/Box.cc

@@ -115 +115 @@
                         /// Wraps value for a specific (Key, TypeList) combination
                         typedef std::pair< TypeList, Value* > Instantiation;
-                        /// Map of keys to instantiations of them
-                        typedef std::map< Key*, std::vector< Instantiation > > Scope;
-
-                        std::vector< Scope > scopes;  ///< list of scopes, from outermost to innermost
+                        /// List of TypeLists paired with their appropriate values
+                        typedef std::vector< Instantiation > ValueList;
+                        /// Underlying map type; maps keys to a linear list of corresponding TypeLists and values
+                        typedef ScopedMap< Key*, std::vector< Instantiation > > InnerMap;
+
+                        InnerMap instantiations;  ///< instantiations
 
                 public:
                         /// Starts a new scope
-                        void beginScope() {
-                                Scope scope;
-                                scopes.push_back(scope);
-                        }
+                        void beginScope() { instantiations.beginScope(); }
 
                         /// Ends a scope
-                        void endScope() {
-                                scopes.pop_back();
-                        }
-
-                        /// Default constructor initializes with one scope
-                        InstantiationMap() { beginScope(); }
+                        void endScope() { instantiations.endScope(); }
 
                         /// Gets the value for the (key, typeList) pair, returns NULL on none such.
-                        Value *lookup( Key *key, const std::list< TypeExpr* >& params ) {
-                                TypeList typeList( params );
-                                
-                                // scan scopes from innermost out
-                                for ( typename std::vector< Scope >::const_reverse_iterator scope = scopes.rbegin(); scope != scopes.rend(); ++scope ) {
-                                        // skip scope if nothing for this key
-                                        typename Scope::const_iterator insts = scope->find( key );
-                                        if ( insts == scope->end() ) continue;
-                                        // look through instantiations for matches to typeList
-                                        for ( typename std::vector< Instantiation >::const_iterator inst = insts->second.begin(); inst != insts->second.end(); ++inst ) {
+                        Value *lookup( Key *key, const std::list< TypeExpr* >& params ) const {
+                                TypeList typeList( params );
+                                
+                                // scan scopes for matches to the key
+                                for ( typename InnerMap::const_iterator insts = instantiations.find( key ); insts != instantiations.end(); insts = instantiations.findNext( insts, key ) ) {
+                                        for ( typename ValueList::const_reverse_iterator inst = insts->second.rbegin(); inst != insts->second.rend(); ++inst ) {
                                                 if ( inst->first == typeList ) return inst->second;
                                         }
                                 }
-                                // no matching instantiation found
+                                // no matching instantiations found
                                 return 0;
                         }
@@ -155 +145 @@
                         /// Adds a value for a (key, typeList) pair to the current scope
                         void insert( Key *key, const std::list< TypeExpr* > &params, Value *value ) {
-                                scopes.back()[key].push_back( Instantiation( TypeList( params ), value ) );
+                                instantiations[ key ].push_back( Instantiation( TypeList( params ), value ) );
                         }
                 };

src/GenPoly/ScopedMap.h

@@ -17 +17 @@
 #define _SCOPEDMAP_H
 
+#include <cassert>
 #include <iterator>
 #include <map>
@@ -164 +165 @@
                 void endScope() {
                         scopes.pop_back();
+                        assert( ! scopes.empty() );
                 }
 
@@ -188 +190 @@
                         return end();
                 }
-                const_iterator find( const Key &key ) const { return const_iterator( find( key ) ); }
+                const_iterator find( const Key &key ) const {
+                                return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->find( key ) );
+                }
                 
                 /// Finds the given key in the outermost scope inside the given scope where it occurs
@@ -200 +204 @@
                         return end();
                 }
-                const_iterator findNext( const_iterator &it, const Key &key ) const { return const_iterator( findNext( it, key ) ); }
+                const_iterator findNext( const_iterator &it, const Key &key ) const {
+                                return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->findNext( it, key ) );
+                }
 
                 /// Inserts the given key-value pair into the outermost scope
@@ -208 +214 @@
                 }
                 std::pair< iterator, bool > insert( const Key &key, const Value &value ) { return insert( std::make_pair( key, value ) ); }
-                
+
+                Value& operator[] ( const Key &key ) {
+                        iterator slot = find( key );
+                        if ( slot != end() ) return slot->second;
+                        return insert( key, Value() ).first->second;
+                }
         };
 } // namespace GenPoly