Changes in src/SymTab/Validate.cc [32d281d:1cbca6e]

File:

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

src/SymTab/Validate.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:50:04 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Fri Nov 20 16:33:52 2015
-// Update Count     : 201
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Aug 11 16:59:35 2015
+// Update Count     : 196
 //
 
@@ -126 +126 @@
         };
 
-        class AutogenerateRoutines : public Visitor {
+        class AddStructAssignment : public Visitor {
           public:
                 /// Generates assignment operators for aggregate types as required
-                static void autogenerateRoutines( std::list< Declaration * > &translationUnit );
+                static void addStructAssignment( std::list< Declaration * > &translationUnit );
 
                 std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
@@ -152 +152 @@
                 virtual void visit( CatchStmt *catchStmt );
 
-                AutogenerateRoutines() : functionNesting( 0 ) {}
+                AddStructAssignment() : functionNesting( 0 ) {}
           private:
                 template< typename StmtClass > void visitStatement( StmtClass *stmt );
@@ -196 +196 @@
                 acceptAll( translationUnit, pass1 );
                 acceptAll( translationUnit, pass2 );
-                AutogenerateRoutines::autogenerateRoutines( translationUnit );
+                // need to collect all of the assignment operators prior to
+                // this point and only generate assignment operators if one doesn't exist
+                AddStructAssignment::addStructAssignment( translationUnit );
                 acceptAll( translationUnit, pass3 );
         }
@@ -500 +502 @@
         static const std::list< std::string > noLabels;
 
-        void AutogenerateRoutines::autogenerateRoutines( std::list< Declaration * > &translationUnit ) {
-                AutogenerateRoutines visitor;
+        void AddStructAssignment::addStructAssignment( std::list< Declaration * > &translationUnit ) {
+                AddStructAssignment visitor;
                 acceptAndAdd( translationUnit, visitor, false );
         }
@@ -625 +627 @@
         }
 
-        /// Clones a reference type, replacing any parameters it may have with a clone of the provided list
-        template< typename GenericInstType >
-        GenericInstType *cloneWithParams( GenericInstType *refType, const std::list< Expression* >& params ) {
-                GenericInstType *clone = refType->clone();
-                clone->get_parameters().clear();
-                cloneAll( params, clone->get_parameters() );
-                return clone;
-        }
 
         Declaration *makeStructAssignment( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting ) {
                 FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
-
-                // Make function polymorphic in same parameters as generic struct, if applicable
-                std::list< TypeDecl* >& genericParams = aggregateDecl->get_parameters();
-                std::list< Expression* > structParams;  // List of matching parameters to put on types
-                for ( std::list< TypeDecl* >::const_iterator param = genericParams.begin(); param != genericParams.end(); ++param ) {
-                        TypeDecl *typeParam = (*param)->clone();
-                        assignType->get_forall().push_back( typeParam );
-                        structParams.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam ) ) );
-                }
-  
-                ObjectDecl *returnVal = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, structParams ), 0 );
+  
+                ObjectDecl *returnVal = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
                 assignType->get_returnVals().push_back( returnVal );
   
-                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), cloneWithParams( refType, structParams ) ), 0 );
+                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), refType->clone() ), 0 );
                 assignType->get_parameters().push_back( dstParam );
   
-                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, structParams ), 0 );
+                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, refType, 0 );
                 assignType->get_parameters().push_back( srcParam );
 
@@ -688 +673 @@
         Declaration *makeUnionAssignment( UnionDecl *aggregateDecl, UnionInstType *refType, unsigned int functionNesting ) {
                 FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
-
-                // Make function polymorphic in same parameters as generic union, if applicable
-                std::list< TypeDecl* >& genericParams = aggregateDecl->get_parameters();
-                std::list< Expression* > unionParams;  // List of matching parameters to put on types
-                for ( std::list< TypeDecl* >::const_iterator param = genericParams.begin(); param != genericParams.end(); ++param ) {
-                        TypeDecl *typeParam = (*param)->clone();
-                        assignType->get_forall().push_back( typeParam );
-                        unionParams.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam ) ) );
-                }
-  
-                ObjectDecl *returnVal = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, unionParams ), 0 );
+  
+                ObjectDecl *returnVal = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
                 assignType->get_returnVals().push_back( returnVal );
   
-                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), cloneWithParams( refType, unionParams ) ), 0 );
+                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), refType->clone() ), 0 );
                 assignType->get_parameters().push_back( dstParam );
   
-                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, unionParams ), 0 );
+                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, refType, 0 );
                 assignType->get_parameters().push_back( srcParam );
   
@@ -715 +691 @@
                 copy->get_args().push_back( new VariableExpr( dstParam ) );
                 copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
-                copy->get_args().push_back( new SizeofExpr( cloneWithParams( refType, unionParams ) ) );
+                copy->get_args().push_back( new SizeofExpr( refType->clone() ) );
 
                 assignDecl->get_statements()->get_kids().push_back( new ExprStmt( noLabels, copy ) );
@@ -723 +699 @@
         }
 
-        void AutogenerateRoutines::visit( EnumDecl *enumDecl ) {
+        void AddStructAssignment::visit( EnumDecl *enumDecl ) {
                 if ( ! enumDecl->get_members().empty() ) {
                         EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() );
@@ -732 +708 @@
         }
 
-        void AutogenerateRoutines::visit( StructDecl *structDecl ) {
+        void AddStructAssignment::visit( StructDecl *structDecl ) {
                 if ( ! structDecl->get_members().empty() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
-                        StructInstType structInst( Type::Qualifiers(), structDecl->get_name() );
-                        structInst.set_baseStruct( structDecl );
-                        declsToAdd.push_back( makeStructAssignment( structDecl, &structInst, functionNesting ) );
+                        StructInstType *structInst = new StructInstType( Type::Qualifiers(), structDecl->get_name() );
+                        structInst->set_baseStruct( structDecl );
+                        declsToAdd.push_back( makeStructAssignment( structDecl, structInst, functionNesting ) );
                         structsDone.insert( structDecl->get_name() );
                 } // if
         }
 
-        void AutogenerateRoutines::visit( UnionDecl *unionDecl ) {
+        void AddStructAssignment::visit( UnionDecl *unionDecl ) {
                 if ( ! unionDecl->get_members().empty() ) {
-                        UnionInstType unionInst( Type::Qualifiers(), unionDecl->get_name() );
-                        unionInst.set_baseUnion( unionDecl );
-                        declsToAdd.push_back( makeUnionAssignment( unionDecl, &unionInst, functionNesting ) );
-                } // if
-        }
-
-        void AutogenerateRoutines::visit( TypeDecl *typeDecl ) {
+                        UnionInstType *unionInst = new UnionInstType( Type::Qualifiers(), unionDecl->get_name() );
+                        unionInst->set_baseUnion( unionDecl );
+                        declsToAdd.push_back( makeUnionAssignment( unionDecl, unionInst, functionNesting ) );
+                } // if
+        }
+
+        void AddStructAssignment::visit( TypeDecl *typeDecl ) {
                 CompoundStmt *stmts = 0;
                 TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false );
@@ -777 +753 @@
         }
 
-        void AutogenerateRoutines::visit( FunctionType *) {
+        void AddStructAssignment::visit( FunctionType *) {
                 // ensure that we don't add assignment ops for types defined as part of the function
         }
 
-        void AutogenerateRoutines::visit( PointerType *) {
+        void AddStructAssignment::visit( PointerType *) {
                 // ensure that we don't add assignment ops for types defined as part of the pointer
         }
 
-        void AutogenerateRoutines::visit( ContextDecl *) {
+        void AddStructAssignment::visit( ContextDecl *) {
                 // ensure that we don't add assignment ops for types defined as part of the context
         }
 
         template< typename StmtClass >
-        inline void AutogenerateRoutines::visitStatement( StmtClass *stmt ) {
+        inline void AddStructAssignment::visitStatement( StmtClass *stmt ) {
                 std::set< std::string > oldStructs = structsDone;
                 addVisit( stmt, *this );
@@ -796 +772 @@
         }
 
-        void AutogenerateRoutines::visit( FunctionDecl *functionDecl ) {
+        void AddStructAssignment::visit( FunctionDecl *functionDecl ) {
                 maybeAccept( functionDecl->get_functionType(), *this );
                 acceptAll( functionDecl->get_oldDecls(), *this );
@@ -804 +780 @@
         }
 
-        void AutogenerateRoutines::visit( CompoundStmt *compoundStmt ) {
+        void AddStructAssignment::visit( CompoundStmt *compoundStmt ) {
                 visitStatement( compoundStmt );
         }
 
-        void AutogenerateRoutines::visit( IfStmt *ifStmt ) {
+        void AddStructAssignment::visit( IfStmt *ifStmt ) {
                 visitStatement( ifStmt );
         }
 
-        void AutogenerateRoutines::visit( WhileStmt *whileStmt ) {
+        void AddStructAssignment::visit( WhileStmt *whileStmt ) {
                 visitStatement( whileStmt );
         }
 
-        void AutogenerateRoutines::visit( ForStmt *forStmt ) {
+        void AddStructAssignment::visit( ForStmt *forStmt ) {
                 visitStatement( forStmt );
         }
 
-        void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) {
+        void AddStructAssignment::visit( SwitchStmt *switchStmt ) {
                 visitStatement( switchStmt );
         }
 
-        void AutogenerateRoutines::visit( ChooseStmt *switchStmt ) {
+        void AddStructAssignment::visit( ChooseStmt *switchStmt ) {
                 visitStatement( switchStmt );
         }
 
-        void AutogenerateRoutines::visit( CaseStmt *caseStmt ) {
+        void AddStructAssignment::visit( CaseStmt *caseStmt ) {
                 visitStatement( caseStmt );
         }
 
-        void AutogenerateRoutines::visit( CatchStmt *cathStmt ) {
+        void AddStructAssignment::visit( CatchStmt *cathStmt ) {
                 visitStatement( cathStmt );
         }