Changes in src/GenPoly/InstantiateGeneric.cc [63db3d76:5bf4712]

File:

• src/GenPoly/InstantiateGeneric.cc (modified) (8 diffs)

src/GenPoly/InstantiateGeneric.cc

@@ -77 +77 @@
                 std::list< Type* > params;  ///< Instantiation parameters
         };
-        
+
         /// Maps a concrete type to the instantiated struct type, accounting for scope
         class InstantiationMap {
@@ -143 +143 @@
         /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
         class Instantiate : public DeclMutator {
-                /// Map of (generic type, parameter list) pairs to concrete type instantiations
                 InstantiationMap instantiations;
-                /// Namer for concrete types
                 UniqueName typeNamer;
 
@@ -151 +149 @@
                 Instantiate() : DeclMutator(), instantiations(), typeNamer("_conc_") {}
 
+//              virtual Declaration* mutate( StructDecl *aggregateDecl );
+//              virtual Declaration* mutate( UnionDecl *aggregateDecl );
+
                 virtual Type* mutate( StructInstType *inst );
                 virtual Type* mutate( UnionInstType *inst );
-
-//              virtual Expression* mutate( MemberExpr *memberExpr );
                 
                 virtual void doBeginScope();
@@ -167 +166 @@
         /// Makes substitutions of params into baseParams; returns true if all parameters substituted for a concrete type
         bool makeSubstitutions( const std::list< TypeDecl* >& baseParams, const std::list< Expression* >& params, std::list< TypeExpr* >& out ) {
-                bool allConcrete = true;  // will finish the substitution list even if they're not all concrete
+                bool allConcrete = true;  // will finish the substitution list even if they're not all concrete
 
                 // substitute concrete types for given parameters, and incomplete types for placeholders
@@ -173 +172 @@
                 std::list< Expression* >::const_iterator param = params.begin();
                 for ( ; baseParam != baseParams.end() && param != params.end(); ++baseParam, ++param ) {
-//                      switch ( (*baseParam)->get_kind() ) {
-//                      case TypeDecl::Any: {   // any type is a valid substitution here; complete types can be used to instantiate generics
+                        switch ( (*baseParam)->get_kind() ) {
+                        case TypeDecl::Any: {   // any type is a valid substitution here; complete types can be used to instantiate generics
                                 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
                                 assert(paramType && "Aggregate parameters should be type expressions");
@@ -180 +179 @@
                                 // check that the substituted type isn't a type variable itself
                                 if ( dynamic_cast< TypeInstType* >( paramType->get_type() ) ) {
-                                        allConcrete = false;
+                                        allConcrete = false;
                                 }
-//                              break;
-//                      }
-//                      case TypeDecl::Dtype:  // dtype can be consistently replaced with void [only pointers, which become void*]
-//                              out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );
-//                              break;
-//                      case TypeDecl::Ftype:  // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype]
-//                              out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );
-//                              break;
-//                      }
-                }
-
-                // if any parameters left over, not done
-                if ( baseParam != baseParams.end() ) return false;
-//              // if not enough parameters given, substitute remaining incomplete types for placeholders
-//              for ( ; baseParam != baseParams.end(); ++baseParam ) {
-//                      switch ( (*baseParam)->get_kind() ) {
-//                      case TypeDecl::Any:    // no more substitutions here, fail early
-//                              return false;
-//                      case TypeDecl::Dtype:  // dtype can be consistently replaced with void [only pointers, which become void*]
-//                              out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );
-//                              break;
-//                      case TypeDecl::Ftype:  // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype]
-//                              out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );
-//                              break;
-//                      }
-//              }
-
-                return allConcrete;
-        }
-
+                                break;
+                        }
+                        case TypeDecl::Dtype:  // dtype can be consistently replaced with void [only pointers, which become void*]
+                                out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );
+                                break;
+                        case TypeDecl::Ftype:  // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype]
+                                out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );
+                                break;
+                        }
+                }
+
+                // if not enough parameters given, substitute remaining incomplete types for placeholders
+                for ( ; baseParam != baseParams.end(); ++baseParam ) {
+                        switch ( (*baseParam)->get_kind() ) {
+                        case TypeDecl::Any:    // no more substitutions here, fail early
+                                return false;
+                        case TypeDecl::Dtype:  // dtype can be consistently replaced with void [only pointers, which become void*]
+                                out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );
+                                break;
+                        case TypeDecl::Ftype:  // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype]
+                                out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );
+                                break;
+                        }
+                }
+
+                return allConcrete;
+        }
+        
         /// Substitutes types of members of in according to baseParams => typeSubs, appending the result to out
         void substituteMembers( const std::list< Declaration* >& in, const std::list< TypeDecl* >& baseParams, const std::list< TypeExpr* >& typeSubs, 
@@ -291 +288 @@
                 return newInst;
         }
-
-//      /// Gets the base struct or union declaration for a member expression; NULL if not applicable
-//      AggregateDecl* getMemberBaseDecl( MemberExpr *memberExpr ) {
-//              // get variable for member aggregate
-//              VariableExpr *varExpr = dynamic_cast< VariableExpr* >( memberExpr->get_aggregate() );
-//              if ( ! varExpr ) return NULL;
-// 
-//              // get object for variable
-//              ObjectDecl *objectDecl = dynamic_cast< ObjectDecl* >( varExpr->get_var() );
-//              if ( ! objectDecl ) return NULL;
-// 
-//              // get base declaration from object type
-//              Type *objectType = objectDecl->get_type();
-//              StructInstType *structType = dynamic_cast< StructInstType* >( objectType );
-//              if ( structType ) return structType->get_baseStruct();
-//              UnionInstType *unionType = dynamic_cast< UnionInstType* >( objectType );
-//              if ( unionType ) return unionType->get_baseUnion();
-// 
-//              return NULL;
-//      }
-// 
-//      /// Finds the declaration with the given name, returning decls.end() if none such
-//      std::list< Declaration* >::const_iterator findDeclNamed( const std::list< Declaration* > &decls, const std::string &name ) {
-//              for( std::list< Declaration* >::const_iterator decl = decls.begin(); decl != decls.end(); ++decl ) {
-//                      if ( (*decl)->get_name() == name ) return decl;
-//              }
-//              return decls.end();
-//      }
-//      
-//      Expression* Instantiate::mutate( MemberExpr *memberExpr ) {
-//              // mutate, exiting early if no longer MemberExpr
-//              Expression *expr = Mutator::mutate( memberExpr );
-//              memberExpr = dynamic_cast< MemberExpr* >( expr );
-//              if ( ! memberExpr ) return expr;
-// 
-//              // get declaration of member and base declaration of member, exiting early if not found
-//              AggregateDecl *memberBase = getMemberBaseDecl( memberExpr );
-//              if ( ! memberBase ) return memberExpr;
-//              DeclarationWithType *memberDecl = memberExpr->get_member();
-//              std::list< Declaration* >::const_iterator baseIt = findDeclNamed( memberBase->get_members(), memberDecl->get_name() );
-//              if ( baseIt == memberBase->get_members().end() ) return memberExpr;
-//              DeclarationWithType *baseDecl = dynamic_cast< DeclarationWithType* >( *baseIt );
-//              if ( ! baseDecl ) return memberExpr;
-// 
-//              // check if stated type of the member is not the type of the member's declaration; if so, need a cast
-//              // this *SHOULD* be safe, I don't think anything but the void-replacements I put in for dtypes would make it past the typechecker
-//              SymTab::Indexer dummy;
-//              if ( ResolvExpr::typesCompatible( memberDecl->get_type(), baseDecl->get_type(), dummy ) ) return memberExpr;
-//              else return new CastExpr( memberExpr, memberDecl->get_type() );
-//      }
         
         void Instantiate::doBeginScope() {
                 DeclMutator::doBeginScope();
+                // push a new concrete type scope
                 instantiations.beginScope();
         }
@@ -349 +297 @@
         void Instantiate::doEndScope() {
                 DeclMutator::doEndScope();
+                // pop the last concrete type scope
                 instantiations.endScope();
         }