Changes in src/SymTab/Validate.cc [98735ef:7528ba1]

File:

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

src/SymTab/Validate.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:50:04 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jan 27 22:03:12 2016
-// Update Count     : 225
+// Last Modified By : Rob Schluntz
+// Last Modified On : Mon Feb 22 12:26:37 2016
+// Update Count     : 297
 //
 
@@ -202 +202 @@
         };
 
+        class VerifyCtorDtor : public Visitor {
+        public:
+                /// ensure that constructors and destructors have at least one
+                /// parameter, the first of which must be a pointer, and no
+                /// return values.
+                static void verify( std::list< Declaration * > &translationUnit );
+
+                // VerifyCtorDtor() {}
+
+                virtual void visit( FunctionDecl *funcDecl );
+        private:
+        };
+
         void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
                 Pass1 pass1;
@@ -213 +226 @@
                 AutogenerateRoutines::autogenerateRoutines( translationUnit );
                 acceptAll( translationUnit, pass3 );
+                VerifyCtorDtor::verify( translationUnit );
         }
 
@@ -382 +396 @@
                 // it's not a semantic error if the struct is not found, just an implicit forward declaration
                 if ( st ) {
-                        //assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
+                        assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
                         structInst->set_baseStruct( st );
                 } // if
@@ -659 +673 @@
         }
 
-        /// Creates a new type decl that's the same as src, but renamed and with only the ?=? assertion (for complete types only)
-        TypeDecl *cloneAndRename( TypeDecl *src, const std::string &name ) {
-                TypeDecl *dst = new TypeDecl( name, src->get_storageClass(), 0, src->get_kind() );
-
-                if ( src->get_kind() == TypeDecl::Any ) {
-                        // just include assignment operator assertion
-                        TypeInstType *assignParamType = new TypeInstType( Type::Qualifiers(), name, dst );
-                        FunctionType *assignFunctionType = new FunctionType( Type::Qualifiers(), false );
-                        assignFunctionType->get_returnVals().push_back(
-                                new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, assignParamType->clone(), 0 ) );
-                        assignFunctionType->get_parameters().push_back(
-                                new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), assignParamType->clone() ), 0 ) );
-                        assignFunctionType->get_parameters().push_back(
-                                new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, assignParamType, 0 ) );
-                        FunctionDecl *assignAssert = new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignFunctionType, 0, false, false );
-                        dst->get_assertions().push_back( assignAssert );
-                }
-
-                return dst;
-        }
-
         Declaration *makeStructAssignment( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting ) {
                 FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
@@ -687 +680 @@
                 std::list< TypeDecl* >& genericParams = aggregateDecl->get_parameters();
                 std::list< Expression* > structParams;  // List of matching parameters to put on types
-                TypeSubstitution genericSubs; // Substitutions to make to member types of struct
                 for ( std::list< TypeDecl* >::const_iterator param = genericParams.begin(); param != genericParams.end(); ++param ) {
                         isGeneric = true;
-                        TypeDecl *typeParam = cloneAndRename( *param, "_autoassign_" + aggregateDecl->get_name() + "_" + (*param)->get_name() );
+                        TypeDecl *typeParam = (*param)->clone();
                         assignType->get_forall().push_back( typeParam );
-                        TypeInstType *newParamType = new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam );
-                        genericSubs.add( (*param)->get_name(), newParamType );
-                        structParams.push_back( new TypeExpr( newParamType ) );
+                        structParams.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam ) ) );
                 }
 
@@ -725 +715 @@
                                 }
 
-                                if ( isGeneric ) {
-                                        // rewrite member type in terms of the type variables on this operator
-                                        DeclarationWithType *fixedMember = dwt->clone();
-                                        genericSubs.apply( fixedMember );
-
-                                        // assign to both destination and return value
-                                        if ( ArrayType *array = dynamic_cast< ArrayType * >( fixedMember->get_type() ) ) {
-                                                makeArrayAssignment( srcParam, dstParam, fixedMember, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                                makeArrayAssignment( srcParam, returnVal, fixedMember, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                        } else {
-                                                makeScalarAssignment( srcParam, dstParam, fixedMember, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                                makeScalarAssignment( srcParam, returnVal, fixedMember, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                        } // if
+                                if ( ArrayType *array = dynamic_cast< ArrayType * >( dwt->get_type() ) ) {
+                                        makeArrayAssignment( srcParam, dstParam, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                                        if ( isGeneric ) makeArrayAssignment( srcParam, returnVal, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
                                 } else {
-                                        // assign to destination
-                                        if ( ArrayType *array = dynamic_cast< ArrayType * >( dwt->get_type() ) ) {
-                                                makeArrayAssignment( srcParam, dstParam, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                        } else {
-                                                makeScalarAssignment( srcParam, dstParam, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                        } // if
+                                        makeScalarAssignment( srcParam, dstParam, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                                        if ( isGeneric ) makeScalarAssignment( srcParam, returnVal, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
                                 } // if
                         } // if
@@ -751 +727 @@
 
                 return assignDecl;
+        }
+
+
+        void makeStructCtorDtor( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd ) {
+                FunctionType *ctorType = new FunctionType( Type::Qualifiers(), false );
+
+                // Make function polymorphic in same parameters as generic struct, if applicable
+                bool isGeneric = false;  // NOTE this flag is an incredibly ugly kludge; we should fix the assignment signature instead (ditto for union)
+                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 ) {
+                        isGeneric = true;
+                        TypeDecl *typeParam = (*param)->clone();
+                        ctorType->get_forall().push_back( typeParam );
+                        structParams.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam ) ) );
+                }
+
+                ObjectDecl *thisParam = new ObjectDecl( "_this", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), cloneWithParams( refType, structParams ) ), 0 );
+                ctorType->get_parameters().push_back( thisParam );
+
+                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
+                // because each unit generates copies of the default routines for each aggregate.
+                FunctionDecl *ctorDecl = new FunctionDecl( "?{}", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, ctorType, 0, true, false );
+                FunctionDecl *dtorDecl = new FunctionDecl( "^?{}", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, ctorType, 0, true, false );
+                ctorDecl->fixUniqueId();
+                dtorDecl->fixUniqueId();
+
+                // add definitions
+                // TODO: add in calls to default constructors and destructors for fields
+                ctorDecl->set_statements( new CompoundStmt( noLabels ) );
+                dtorDecl->set_statements( new CompoundStmt( noLabels ) );
+                declsToAdd.push_back( ctorDecl );
+                declsToAdd.push_back( dtorDecl );
+
+
+                // for ( std::list< Declaration * >::const_iterator member = aggregateDecl->get_members().begin(); member != aggregateDecl->get_members().end(); ++member ) {
+                //      if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member ) ) {
+                //              // query the type qualifiers of this field and skip assigning it if it is marked const.
+                //              // If it is an array type, we need to strip off the array layers to find its qualifiers.
+                //              Type * type = dwt->get_type();
+                //              while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
+                //                      type = at->get_base();
+                //              }
+
+                //              if ( type->get_qualifiers().isConst ) {
+                //                      // don't assign const members
+                //                      continue;
+                //              }
+
+                //              if ( ArrayType *array = dynamic_cast< ArrayType * >( dwt->get_type() ) ) {
+                //                      makeArrayAssignment( srcParam, dstParam, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                //                      if ( isGeneric ) makeArrayAssignment( srcParam, returnVal, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                //              } else {
+                //                      makeScalarAssignment( srcParam, dstParam, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                //                      if ( isGeneric ) makeScalarAssignment( srcParam, returnVal, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                //              } // if
+                //      } // if
+                // } // for
+                // if ( ! isGeneric ) assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+
+                // return assignDecl;
         }
 
@@ -762 +799 @@
                 for ( std::list< TypeDecl* >::const_iterator param = genericParams.begin(); param != genericParams.end(); ++param ) {
                         isGeneric = true;
-                        TypeDecl *typeParam = cloneAndRename( *param, "_autoassign_" + aggregateDecl->get_name() + "_" + (*param)->get_name() );
+                        TypeDecl *typeParam = (*param)->clone();
                         assignType->get_forall().push_back( typeParam );
                         unionParams.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam ) ) );
@@ -783 +820 @@
                 makeUnionFieldsAssignment( srcParam, dstParam, cloneWithParams( refType, unionParams ), back_inserter( assignDecl->get_statements()->get_kids() ) );
                 if ( isGeneric ) makeUnionFieldsAssignment( srcParam, returnVal, cloneWithParams( refType, unionParams ), back_inserter( assignDecl->get_statements()->get_kids() ) );
-                
+
                 if ( ! isGeneric ) assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
 
@@ -802 +839 @@
                         StructInstType structInst( Type::Qualifiers(), structDecl->get_name() );
                         structInst.set_baseStruct( structDecl );
+
                         declsToAdd.push_back( makeStructAssignment( structDecl, &structInst, functionNesting ) );
+                        makeStructCtorDtor( structDecl, &structInst, functionNesting, declsToAdd );
                         structsDone.insert( structDecl->get_name() );
                 } // if
@@ -1080 +1119 @@
         }
 
+        void VerifyCtorDtor::verify( std::list< Declaration * > & translationUnit ) {
+                VerifyCtorDtor verifier;
+                acceptAll( translationUnit, verifier );
+        }
+
+        void VerifyCtorDtor::visit( FunctionDecl * funcDecl ) {
+                FunctionType * funcType = funcDecl->get_functionType();
+                std::list< DeclarationWithType * > &returnVals = funcType->get_returnVals();
+                std::list< DeclarationWithType * > &params = funcType->get_parameters();
+
+                if ( funcDecl->get_name() == "?{}" || funcDecl->get_name() == "^?{}" ) {
+                        if ( params.size() == 0 ) {
+                                throw SemanticError( "Constructors and destructors require at least one parameter ", funcDecl );
+                        }
+                        if ( ! dynamic_cast< PointerType * >( params.front()->get_type() ) ) {
+                                throw SemanticError( "First parameter of a constructor or destructor must be a pointer ", funcDecl );
+                        }
+                        if ( returnVals.size() != 0 ) {
+                                throw SemanticError( "Constructors and destructors cannot have explicit return values ", funcDecl );
+                        }
+                }
+
+                Visitor::visit( funcDecl );
+                // original idea: modify signature of ctor/dtors and insert appropriate return statements
+                // to cause desired behaviour
+                // new idea: add comma exprs to every ctor call to produce first parameter.
+                // this requires some memoization of the first parameter, because it can be a
+                // complicated expression with side effects (see: malloc). idea: add temporary variable
+                // that is assigned address of constructed object in ctor argument position and
+                // return the temporary. It should also be done after all implicit ctors are
+                // added, so not in this pass!
+        }
 } // namespace SymTab