Changes in src/SymTab/Validate.cc [82dd287:85c4ef0]

File:

• src/SymTab/Validate.cc (modified) (21 diffs)

src/SymTab/Validate.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Tue Jul 07 10:41:23 2015
-// Update Count     : 136
+// Last Modified On : Mon Jul 13 14:38:19 2015
+// Update Count     : 184
 //
 
@@ -48 +48 @@
 #include "Indexer.h"
 #include "FixFunction.h"
-#include "ImplementationType.h"
+// #include "ImplementationType.h"
 #include "utility.h"
 #include "UniqueName.h"
 #include "AddVisit.h"
 #include "MakeLibCfa.h"
-
+#include "TypeEquality.h"
 
 #define debugPrint( x ) if ( doDebug ) { std::cout << x; }
@@ -60 +60 @@
         class HoistStruct : public Visitor {
           public:
-                /// Flattens nested struct types
                 static void hoistStruct( std::list< Declaration * > &translationUnit );
   
@@ -85 +84 @@
         };
 
-        /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers
         class Pass1 : public Visitor {
                 typedef Visitor Parent;
@@ -91 +89 @@
                 virtual void visit( FunctionType *func );
         };
-
-        /// Associates forward declarations of aggregates with their definitions
+  
         class Pass2 : public Indexer {
                 typedef Indexer Parent;
@@ -113 +110 @@
         };
 
-        /// Replaces array and function types in forall lists by appropriate pointer type
         class Pass3 : public Indexer {
                 typedef Indexer Parent;
@@ -127 +123 @@
         class AddStructAssignment : public Visitor {
           public:
-                /// Generates assignment operators for aggregate types as required
                 static void addStructAssignment( std::list< Declaration * > &translationUnit );
 
@@ -162 +157 @@
         class EliminateTypedef : public Mutator {
           public:
+          EliminateTypedef() : scopeLevel( 0 ) {}
                 static void eliminateTypedef( std::list< Declaration * > &translationUnit );
           private:
@@ -171 +167 @@
                 virtual Type *mutate( TypeInstType *aggregateUseType );
                 virtual Expression *mutate( CastExpr *castExpr );
-  
-                std::map< std::string, TypedefDecl * > typedefNames;
+
+                virtual Declaration *mutate( StructDecl * structDecl );
+                virtual Declaration *mutate( UnionDecl * unionDecl );
+                virtual Declaration *mutate( EnumDecl * enumDecl );
+                virtual Declaration *mutate( ContextDecl * contextDecl );
+
+                template<typename AggDecl>
+                AggDecl *handleAggregate( AggDecl * aggDecl );
+
+                typedef std::map< std::string, std::pair< TypedefDecl *, int > > TypedefMap;
+                TypedefMap typedefNames;
+                int scopeLevel;
         };
 
@@ -438 +444 @@
         }
 
-        /// Fix up assertions
         void forallFixer( Type *func ) {
+                // Fix up assertions
                 for ( std::list< TypeDecl * >::iterator type = func->get_forall().begin(); type != func->get_forall().end(); ++type ) {
                         std::list< DeclarationWithType * > toBeDone, nextRound;
@@ -589 +595 @@
                 assignDecl2->fixUniqueId();
 
+                // these should be built in the same way that the prelude
+                // functions are, so build a list containing the prototypes
+                // and allow MakeLibCfa to autogenerate the bodies.
                 std::list< Declaration * > assigns;
                 assigns.push_back( assignDecl );
@@ -595 +604 @@
                 LibCfa::makeLibCfa( assigns );
 
-                // need to remove the prototypes, since these can appear nested in a routine
+                // need to remove the prototypes, since this may be nested in a routine
                 for (int start = 0, end = assigns.size()/2; start < end; start++) {
                         delete assigns.front();
@@ -602 +611 @@
 
                 declsToAdd.insert( declsToAdd.begin(), assigns.begin(), assigns.end() );
-
-                // return assignDecl;
         }
 
@@ -801 +808 @@
         }
 
-        Type *EliminateTypedef::mutate( TypeInstType *typeInst ) {
-                std::map< std::string, TypedefDecl * >::const_iterator def = typedefNames.find( typeInst->get_name() );
+        Type *EliminateTypedef::mutate( TypeInstType * typeInst ) {
+                // instances of typedef types will come here. If it is an instance 
+                // of a typdef type, link the instance to its actual type.
+                TypedefMap::const_iterator def = typedefNames.find( typeInst->get_name() );
                 if ( def != typedefNames.end() ) {
-                        Type *ret = def->second->get_base()->clone();
+                        Type *ret = def->second.first->get_base()->clone();
                         ret->get_qualifiers() += typeInst->get_qualifiers();
                         delete typeInst;
@@ -812 +821 @@
         }
 
-        Declaration *EliminateTypedef::mutate( TypedefDecl *tyDecl ) {
+        Declaration *EliminateTypedef::mutate( TypedefDecl * tyDecl ) {
                 Declaration *ret = Mutator::mutate( tyDecl );
-                typedefNames[ tyDecl->get_name() ] = tyDecl;
+                if ( typedefNames.count( tyDecl->get_name() ) == 1 && typedefNames[ tyDecl->get_name() ].second == scopeLevel ) {
+                        // typedef to the same name from the same scope 
+                        // must be from the same type
+
+                        Type * t1 = tyDecl->get_base();
+                        Type * t2 = typedefNames[ tyDecl->get_name() ].first->get_base();
+                        if ( ! typeEquals( t1, t2, true ) ) {
+                                throw SemanticError( "cannot redefine typedef: " + tyDecl->get_name() );
+                        }
+                } else {
+                        typedefNames[ tyDecl->get_name() ] = std::make_pair( tyDecl, scopeLevel );
+                } // if
+
                 // When a typedef is a forward declaration:
                 //    typedef struct screen SCREEN;
@@ -832 +853 @@
         }
 
-        TypeDecl *EliminateTypedef::mutate( TypeDecl *typeDecl ) {
-                std::map< std::string, TypedefDecl * >::iterator i = typedefNames.find( typeDecl->get_name() );
+        TypeDecl *EliminateTypedef::mutate( TypeDecl * typeDecl ) {
+                TypedefMap::iterator i = typedefNames.find( typeDecl->get_name() );
                 if ( i != typedefNames.end() ) {
                         typedefNames.erase( i ) ;
@@ -840 +861 @@
         }
 
-        DeclarationWithType *EliminateTypedef::mutate( FunctionDecl *funcDecl ) {
-                std::map< std::string, TypedefDecl * > oldNames = typedefNames;
+        DeclarationWithType *EliminateTypedef::mutate( FunctionDecl * funcDecl ) {
+                TypedefMap oldNames = typedefNames;
                 DeclarationWithType *ret = Mutator::mutate( funcDecl );
                 typedefNames = oldNames;
@@ -847 +868 @@
         }
 
-        ObjectDecl *EliminateTypedef::mutate( ObjectDecl *objDecl ) {
-                std::map< std::string, TypedefDecl * > oldNames = typedefNames;
+        ObjectDecl *EliminateTypedef::mutate( ObjectDecl * objDecl ) {
+                TypedefMap oldNames = typedefNames;
                 ObjectDecl *ret = Mutator::mutate( objDecl );
                 typedefNames = oldNames;
@@ -854 +875 @@
         }
 
-        Expression *EliminateTypedef::mutate( CastExpr *castExpr ) {
-                std::map< std::string, TypedefDecl * > oldNames = typedefNames;
+        Expression *EliminateTypedef::mutate( CastExpr * castExpr ) {
+                TypedefMap oldNames = typedefNames;
                 Expression *ret = Mutator::mutate( castExpr );
                 typedefNames = oldNames;
@@ -861 +882 @@
         }
 
-        CompoundStmt *EliminateTypedef::mutate( CompoundStmt *compoundStmt ) {
-                std::map< std::string, TypedefDecl * > oldNames = typedefNames;
+        CompoundStmt *EliminateTypedef::mutate( CompoundStmt * compoundStmt ) {
+                TypedefMap oldNames = typedefNames;
+                scopeLevel += 1;
                 CompoundStmt *ret = Mutator::mutate( compoundStmt );
+                scopeLevel -= 1;
                 std::list< Statement * >::iterator i = compoundStmt->get_kids().begin();
                 while ( i != compoundStmt->get_kids().end() ) {
-                        std::list< Statement * >::iterator next = i;
-                        ++next;
+                        std::list< Statement * >::iterator next = i+1;
                         if ( DeclStmt *declStmt = dynamic_cast< DeclStmt * >( *i ) ) {
                                 if ( dynamic_cast< TypedefDecl * >( declStmt->get_decl() ) ) {
@@ -879 +901 @@
                 return ret;
         }
+
+        // there may be typedefs nested within aggregates
+        // in order for everything to work properly, these
+        // should be removed as well
+        template<typename AggDecl>
+        AggDecl *EliminateTypedef::handleAggregate( AggDecl * aggDecl ) {
+                std::list<Declaration *>::iterator it = aggDecl->get_members().begin();
+                for ( ; it != aggDecl->get_members().end(); ) {
+                        std::list< Declaration * >::iterator next = it+1;
+                        if ( dynamic_cast< TypedefDecl * >( *it ) ) {
+                                delete *it;
+                                aggDecl->get_members().erase( it );
+                        } // if
+                        it = next;
+                }
+                return aggDecl;
+        }
+
+        Declaration *EliminateTypedef::mutate( StructDecl * structDecl ) {
+                Mutator::mutate( structDecl );
+                return handleAggregate( structDecl );
+        }
+
+        Declaration *EliminateTypedef::mutate( UnionDecl * unionDecl ) {
+                Mutator::mutate( unionDecl );
+                return handleAggregate( unionDecl );
+        }
+
+        Declaration *EliminateTypedef::mutate( EnumDecl * enumDecl ) {
+                Mutator::mutate( enumDecl );
+                return handleAggregate( enumDecl );
+        }
+
+                Declaration *EliminateTypedef::mutate( ContextDecl * contextDecl ) {
+                Mutator::mutate( contextDecl );
+                return handleAggregate( contextDecl );
+        }
+
 } // namespace SymTab