Changeset eba74ba for src/Parser/TypedefTable.cc

Timestamp:

May 25, 2018, 2:51:06 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env, with_gc

Children:

cdc4d43

Parents:

3ef35bd (diff), 58e822a (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 remote-tracking branch 'origin/master' into with_gc

File:

• src/Parser/TypedefTable.cc (modified) (2 diffs)

src/Parser/TypedefTable.cc

@@ -7 +7 @@
 // TypedefTable.cc -- 
 //
-// Author           : Rodolfo G. Esteves
+// Author           : Peter A. Buhr
 // Created On       : Sat May 16 15:20:13 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug 15 18:24:42 2016
-// Update Count     : 25
+// Last Modified On : Tue May 22 08:40:01 2018
+// Update Count     : 121
 //
 
-#include <ext/alloc_traits.h>    // for __alloc_traits<>::value_type
-#include <cassert>               // for assert
-#include <list>                  // for list, _List_iterator, list<>::iterator
-#include <map>                   // for _Rb_tree_iterator, _Rb_tree_const_it...
-#include <memory>                // for allocator_traits<>::value_type
-#include <utility>               // for pair
 
-#include "Parser/ParserTypes.h"  // for typedefTable
-#include "Parser/parser.hh"      // for IDENTIFIER
 #include "TypedefTable.h"
-
-using namespace std;
+#include <cassert>                                                                              // for assert
 
 #if 0
 #include <iostream>
-
 #define debugPrint( x ) cerr << x
 #else
@@ -35 +25 @@
 #endif
 
-TypedefTable::TypedefTable() : currentScope( 0 ) {}
+using namespace std;                                                                    // string, iostream
 
-bool TypedefTable::exists( const string &identifier ) {
-        return table.count( identifier ) > 0;
-}
+TypedefTable::~TypedefTable() {
+        if ( ! SemanticErrorThrow && kindTable.currentScope() != 0 ) {
+                // std::cerr << "scope failure " << kindTable.currentScope() << endl;
+        } // if
+} // TypedefTable::~TypedefTable
 
-int TypedefTable::isKind( const string &identifier ) const {
-        tableType::const_iterator id_pos = table.find( identifier );
+bool TypedefTable::exists( const string & identifier ) {
+        return kindTable.find( identifier ) != kindTable.end();
+} // TypedefTable::exists
+
+int TypedefTable::isKind( const string & identifier ) const {
+        KindTable::const_iterator posn = kindTable.find( identifier );
         // Name lookup defaults to identifier, and then the identifier's kind is set by the parser.
-        if ( id_pos == table.end() ) return IDENTIFIER;
-        return id_pos->second.begin()->kind;
-}
+        if ( posn == kindTable.end() ) return IDENTIFIER;
+        return posn->second;
+} // TypedefTable::isKind
 
-void TypedefTable::changeKind( const string &identifier, kind_t kind ) {
-        tableType::iterator id_pos = table.find( identifier );
-        if ( id_pos == table.end() ) return;
-        id_pos->second.begin()->kind = kind;
-}
+void TypedefTable::changeKind( const string & identifier, int kind ) {
+        KindTable::iterator posn = kindTable.find( identifier );
+        if ( posn != kindTable.end() ) posn->second = kind;     // exists => update
+} // TypedefTable::changeKind
 
 // SKULLDUGGERY: Generate a typedef for the aggregate name so the aggregate does not have to be qualified by
-// "struct". Only generate the typedef, if the name is not in use. The typedef is implicitly (silently) removed
-// if the name is explicitly used.
-void TypedefTable::makeTypedef( const string &name ) {
+// "struct". Only generate the typedef, if the name is not in use. The typedef is implicitly (silently) removed if the
+// name is explicitly used.
+void TypedefTable::makeTypedef( const string & name ) {
         if ( ! typedefTable.exists( name ) ) {
-                typedefTable.addToEnclosingScope( name, TypedefTable::TD );
+                typedefTable.addToEnclosingScope( name, TYPEDEFname );
         } // if
-}
+} // TypedefTable::makeTypedef
 
-void TypedefTable::addToScope( const std::string &identifier, kind_t kind, int scope ) {
-        if ( currentTrait != "" && scope == contextScope ) {
-                DeferredEntry entry = { identifier, kind };
-                contexts[currentTrait].push_back( entry );
-        } else {
-                debugPrint( "Adding " << identifier << " as kind " << kind << " scope " << scope << " from scope " << currentScope << endl );
-                Entry newEntry = { scope, kind };
-                tableType::iterator curPos = table.find( identifier );
-                if ( curPos == table.end()) {
-                        list< Entry > newList;
-                        newList.push_front( newEntry );
-                        table[identifier] = newList;
-                } else {
-                        list< Entry >::iterator listPos = (*curPos ).second.begin();
-                        while ( listPos != (*curPos ).second.end() && listPos->scope > scope ) {
-                                listPos++;
-                        } // while
-                        (*curPos ).second.insert( listPos, newEntry );
-                } // if
-        } // if
-}
-
-void TypedefTable::addToCurrentScope( const std::string &identifier, kind_t kind ) {
-        addToScope( identifier, kind, currentScope );
-}
-
-void TypedefTable::addToCurrentScope( kind_t kind ) {
-        addToCurrentScope( nextIdentifiers.top(), kind );
-}
-
-void TypedefTable::addToEnclosingScope( const std::string &identifier, kind_t kind ) {
-        assert( currentScope >= 1 );
-        addToScope( identifier, kind, currentScope - 1 );
-}
-
-void TypedefTable::addToEnclosingScope( kind_t kind ) {
-        addToEnclosingScope( nextIdentifiers.top(), kind );
-}
-
-void TypedefTable::addToEnclosingScope2( const std::string &identifier, kind_t kind ) {
-        assert( currentScope >= 2 );
-        addToScope( identifier, kind, currentScope - 2 );
-}
-
-void TypedefTable::addToEnclosingScope2( kind_t kind ) {
-        addToEnclosingScope2( nextIdentifiers.top(), kind );
-}
-
-void TypedefTable::setNextIdentifier( const std::string &identifier ) {
-        nextIdentifiers.top() = identifier;
-}
-
-void TypedefTable::openTrait( const std::string &contextName ) {
-        map< string, deferListType >::iterator i = contexts.find( contextName );
-        if ( i != contexts.end() ) {
-                deferListType &entries = i->second;
-                for ( deferListType::iterator i = entries.begin(); i != entries.end(); i++) {
-                        addToEnclosingScope( i->identifier, i->kind );
-                } // for
-        } // if
-}
+void TypedefTable::addToEnclosingScope( const std::string & identifier, int kind ) {
+        assert( kindTable.currentScope() >= 1 );
+        auto scope = kindTable.currentScope() - 1;
+        debugPrint( "Adding " << identifier << " as kind " << kind << " scope " << scope << endl );
+        auto ret = kindTable.insertAt( scope, identifier, kind );
+        if ( ! ret.second ) ret.first->second = kind;           // exists => update
+} // TypedefTable::addToEnclosingScope
 
 void TypedefTable::enterScope() {
-        currentScope += 1;
-        deferListStack.push( deferListType() );
-        nextIdentifiers.push( "" );
-        debugPrint( "Entering scope " << currentScope << ", nextIdentifiers size is " << nextIdentifiers.size() << endl );
-}
+        kindTable.beginScope();
+        debugPrint( "Entering scope " << kindTable.currentScope() << endl );
+} // TypedefTable::enterScope
 
 void TypedefTable::leaveScope() {
-        debugPrint( "Leaving scope " << currentScope << endl );
-        for ( tableType::iterator i = table.begin(); i != table.end(); ) {
-                list< Entry > &declList = (*i).second;
-                while ( ! declList.empty() && declList.front().scope == currentScope ) {
-                        declList.pop_front();
-                }
-                if ( declList.empty() ) {                                               // standard idom for erasing during traversal
-                        table.erase( i++ );
-                } else
-                        ++i;
-        } // for
-        currentScope -= 1;
-        for ( deferListType::iterator i = deferListStack.top().begin(); i != deferListStack.top().end(); i++ ) {
-                addToCurrentScope( i->identifier, i->kind );
-        } // for
-        deferListStack.pop();
-        debugPrint( "nextIdentifiers size is " << nextIdentifiers.size() << " top is " << nextIdentifiers.top() << endl );
-        nextIdentifiers.pop();
-}
+        debugPrint( "Leaving scope " << kindTable.currentScope() << endl );
+        kindTable.endScope();
+} // TypedefTable::leaveScope
 
-void TypedefTable::enterTrait( const std::string &contextName ) {
-        currentTrait = contextName;
-        contextScope = currentScope;
-}
-
-void TypedefTable::leaveTrait() {
-        currentTrait = "";
-}
-
-void TypedefTable::print( void ) const {
-        for ( tableType::const_iterator i = table.begin(); i != table.end(); i++) {
-                debugPrint( (*i ).first << ": " );
-                list< Entry > declList = (*i).second;
-                for ( list< Entry >::const_iterator j = declList.begin(); j != declList.end(); j++ ) {
-                        debugPrint( "(" << (*j).scope << " " << (*j).kind << ") " );
-                }
-                debugPrint( endl );
-        } // for
-}
+// void TypedefTable::print( void ) const {
+//      for ( KindTable::const_iterator i = table.begin(); i != table.end(); i++) {
+//              debugPrint( (*i ).first << ": " );
+//              list< Entry > declList = (*i).second;
+//              for ( list< Entry >::const_iterator j = declList.begin(); j != declList.end(); j++ ) {
+//                      debugPrint( "(" << (*j).scope << " " << (*j).kind << ") " );
+//              }
+//              debugPrint( endl );
+//      } // for
+// }
 
 // Local Variables: //