Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision cf16f94d500fdd6115ce4918ac612fd7946e7f19) +++ src/CodeGen/CodeGenerator.cc (revision 43899667c202e39bf5ce46a74a02658953fe5bfb) @@ -442,4 +442,15 @@ output << ")"; } + + void CodeGenerator::visit( AlignofExpr *sizeofExpr ) { + // use GCC extension to avoid bumping std to C11 + output << "__alignof__("; + if ( sizeofExpr->get_isType() ) { + output << genType( sizeofExpr->get_type(), "" ); + } else { + sizeofExpr->get_expr()->accept( *this ); + } // if + output << ")"; + } void CodeGenerator::visit( LogicalExpr *logicalExpr ) { Index: src/CodeGen/CodeGenerator.h =================================================================== --- src/CodeGen/CodeGenerator.h (revision cf16f94d500fdd6115ce4918ac612fd7946e7f19) +++ src/CodeGen/CodeGenerator.h (revision 43899667c202e39bf5ce46a74a02658953fe5bfb) @@ -60,4 +60,5 @@ virtual void visit( ConstantExpr *constantExpr ); virtual void visit( SizeofExpr *sizeofExpr ); + virtual void visit( AlignofExpr *alignofExpr ); virtual void visit( LogicalExpr *logicalExpr ); virtual void visit( ConditionalExpr *conditionalExpr ); Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision cf16f94d500fdd6115ce4918ac612fd7946e7f19) +++ src/GenPoly/Box.cc (revision 43899667c202e39bf5ce46a74a02658953fe5bfb) @@ -28,4 +28,5 @@ #include "Parser/ParseNode.h" +#include "SynTree/Constant.h" #include "SynTree/Type.h" #include "SynTree/Expression.h" @@ -50,4 +51,5 @@ FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars ); + /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call class Pass1 : public PolyMutator { public: @@ -88,7 +90,7 @@ }; + /// Moves polymorphic returns in function types to pointer-type parameters, adds type size and assertion parameters to parameter lists as well class Pass2 : public PolyMutator { public: - Pass2(); template< typename DeclClass > DeclClass *handleDecl( DeclClass *decl, Type *type ); @@ -105,4 +107,5 @@ }; + /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, and sizeof expressions of polymorphic types with the proper variable class Pass3 : public PolyMutator { public: @@ -178,6 +181,5 @@ } - Pass1::Pass1() - : useRetval( false ), tempNamer( "_temp" ) { + Pass1::Pass1() : useRetval( false ), tempNamer( "_temp" ) { adapters.push(AdapterMap()); } @@ -312,4 +314,6 @@ if ( concrete ) { arg = appExpr->get_args().insert( arg, new SizeofExpr( concrete->clone() ) ); + arg++; + arg = appExpr->get_args().insert( arg, new AlignofExpr( concrete->clone() ) ); arg++; } else { @@ -647,5 +651,5 @@ } - Expression *makeIncrDecrExpr( ApplicationExpr *appExpr, std::string polyName, bool isIncr ) { + Expression *makeIncrDecrExpr( ApplicationExpr *appExpr, Type *polyType, bool isIncr ) { NameExpr *opExpr; if ( isIncr ) { @@ -660,5 +664,5 @@ addAssign->get_args().push_back( appExpr->get_args().front() ); } // if - addAssign->get_args().push_back( new NameExpr( polyName ) ); + addAssign->get_args().push_back( new NameExpr( sizeofName( polyType ) ) ); addAssign->get_results().front() = appExpr->get_results().front()->clone(); if ( appExpr->get_env() ) { @@ -687,5 +691,5 @@ UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) ); multiply->get_args().push_back( appExpr->get_args().back() ); - multiply->get_args().push_back( new NameExpr( typeInst1->get_name() ) ); + multiply->get_args().push_back( new NameExpr( sizeofName( typeInst1 ) ) ); ret->get_args().push_back( appExpr->get_args().front() ); ret->get_args().push_back( multiply ); @@ -693,5 +697,5 @@ UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) ); multiply->get_args().push_back( appExpr->get_args().front() ); - multiply->get_args().push_back( new NameExpr( typeInst2->get_name() ) ); + multiply->get_args().push_back( new NameExpr( sizeofName( typeInst2 ) ) ); ret->get_args().push_back( multiply ); ret->get_args().push_back( appExpr->get_args().back() ); @@ -739,5 +743,5 @@ assignExpr->get_args().push_back( appExpr->get_args().front()->clone() ); } // if - CommaExpr *firstComma = new CommaExpr( assignExpr, makeIncrDecrExpr( appExpr, typeInst->get_name(), varExpr->get_var()->get_name() == "?++" ) ); + CommaExpr *firstComma = new CommaExpr( assignExpr, makeIncrDecrExpr( appExpr, typeInst, varExpr->get_var()->get_name() == "?++" ) ); return new CommaExpr( firstComma, tempExpr ); } // if @@ -746,5 +750,5 @@ assert( appExpr->get_args().size() == 1 ); if ( TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars ) ) { - return makeIncrDecrExpr( appExpr, typeInst->get_name(), varExpr->get_var()->get_name() == "++?" ); + return makeIncrDecrExpr( appExpr, typeInst, varExpr->get_var()->get_name() == "++?" ); } // if } else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) { @@ -756,5 +760,5 @@ UntypedExpr *divide = new UntypedExpr( new NameExpr( "?/?" ) ); divide->get_args().push_back( appExpr ); - divide->get_args().push_back( new NameExpr( typeInst1->get_name() ) ); + divide->get_args().push_back( new NameExpr( sizeofName( typeInst1 ) ) ); divide->get_results().push_front( appExpr->get_results().front()->clone() ); if ( appExpr->get_env() ) { @@ -766,10 +770,10 @@ UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) ); multiply->get_args().push_back( appExpr->get_args().back() ); - multiply->get_args().push_back( new NameExpr( typeInst1->get_name() ) ); + multiply->get_args().push_back( new NameExpr( sizeofName( typeInst1 ) ) ); appExpr->get_args().back() = multiply; } else if ( typeInst2 ) { UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) ); multiply->get_args().push_back( appExpr->get_args().front() ); - multiply->get_args().push_back( new NameExpr( typeInst2->get_name() ) ); + multiply->get_args().push_back( new NameExpr( sizeofName( typeInst2 ) ) ); appExpr->get_args().front() = multiply; } // if @@ -781,5 +785,5 @@ UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) ); multiply->get_args().push_back( appExpr->get_args().back() ); - multiply->get_args().push_back( new NameExpr( typeInst->get_name() ) ); + multiply->get_args().push_back( new NameExpr( sizeofName( typeInst ) ) ); appExpr->get_args().back() = multiply; } // if @@ -963,6 +967,4 @@ ////////////////////////////////////////// Pass2 //////////////////////////////////////////////////// - Pass2::Pass2() {} - void Pass2::addAdapters( FunctionType *functionType ) { std::list< DeclarationWithType *> ¶mList = functionType->get_parameters(); @@ -1037,23 +1039,29 @@ std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin(); std::list< DeclarationWithType *> inferredParams; - ObjectDecl *newObj = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 ); -/// ObjectDecl *newFunPtr = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ); + ObjectDecl newObj( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 ); +// ObjectDecl *newFunPtr = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ); for ( std::list< TypeDecl *>::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) { - ObjectDecl *thisParm; - // add all size parameters to parameter list + ObjectDecl *sizeParm, *alignParm; + // add all size and alignment parameters to parameter list if ( (*tyParm)->get_kind() == TypeDecl::Any ) { - thisParm = newObj->clone(); - thisParm->set_name( (*tyParm)->get_name() ); - last = funcType->get_parameters().insert( last, thisParm ); + TypeInstType parmType( Type::Qualifiers(), (*tyParm)->get_name(), *tyParm ); + + sizeParm = newObj.clone(); + sizeParm->set_name( sizeofName( &parmType ) ); + last = funcType->get_parameters().insert( last, sizeParm ); + ++last; + + alignParm = newObj.clone(); + alignParm->set_name( alignofName( &parmType ) ); + last = funcType->get_parameters().insert( last, alignParm ); ++last; } // move all assertions into parameter list for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) { -/// *assert = (*assert)->acceptMutator( *this ); +// *assert = (*assert)->acceptMutator( *this ); inferredParams.push_back( *assert ); } (*tyParm)->get_assertions().clear(); } - delete newObj; funcType->get_parameters().splice( last, inferredParams ); addAdapters( funcType ); @@ -1092,11 +1100,11 @@ TypeDecl * Pass3::mutate( TypeDecl *typeDecl ) { -/// Initializer *init = 0; -/// std::list< Expression *> designators; -/// scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind(); -/// if ( typeDecl->get_base() ) { -/// init = new SimpleInit( new SizeofExpr( handleDecl( typeDecl, typeDecl->get_base() ) ), designators ); -/// } -/// return new ObjectDecl( typeDecl->get_name(), Declaration::Extern, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ), init ); +// Initializer *init = 0; +// std::list< Expression *> designators; +// scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind(); +// if ( typeDecl->get_base() ) { +// init = new SimpleInit( new SizeofExpr( handleDecl( typeDecl, typeDecl->get_base() ) ), designators ); +// } +// return new ObjectDecl( typeDecl->get_name(), Declaration::Extern, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ), init ); scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind(); @@ -1131,5 +1139,5 @@ assert( typeInst ); UntypedExpr *alloc = new UntypedExpr( new NameExpr( "__builtin_alloca" ) ); - alloc->get_args().push_back( new NameExpr( typeInst->get_name() ) ); + alloc->get_args().push_back( new NameExpr( sizeofName( typeInst ) ) ); delete objectDecl->get_init(); Index: src/GenPoly/FindFunction.h =================================================================== --- src/GenPoly/FindFunction.h (revision cf16f94d500fdd6115ce4918ac612fd7946e7f19) +++ src/GenPoly/FindFunction.h (revision 43899667c202e39bf5ce46a74a02658953fe5bfb) @@ -23,5 +23,7 @@ typedef bool (*FindFunctionPredicate)( FunctionType*, const TyVarMap& ); + /// recursively walk `type`, placing all functions that match `predicate` under `tyVars` into `functions` void findFunction( Type *type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ); + /// like `findFunction`, but also replaces the function type with void ()(void) void findAndReplaceFunction( Type *&type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ); } // namespace GenPoly Index: src/GenPoly/GenPoly.cc =================================================================== --- src/GenPoly/GenPoly.cc (revision cf16f94d500fdd6115ce4918ac612fd7946e7f19) +++ src/GenPoly/GenPoly.cc (revision 43899667c202e39bf5ce46a74a02658953fe5bfb) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Dec 1 15:18:54 2015 -// Update Count : 12 +// Last Modified On : Tue Dec 15 16:11:18 2015 +// Update Count : 13 // @@ -21,5 +21,5 @@ namespace GenPoly { - // A function needs an adapter if it returns a polymorphic value or if any of its parameters have polymorphic type + /// A function needs an adapter if it returns a polymorphic value or if any of its parameters have polymorphic type bool needsAdapter( FunctionType *adaptee, const TyVarMap &tyVars ) { if ( ! adaptee->get_returnVals().empty() && isPolyVal( adaptee->get_returnVals().front()->get_type(), tyVars ) ) { Index: src/GenPoly/InstantiateGeneric.cc =================================================================== --- src/GenPoly/InstantiateGeneric.cc (revision cf16f94d500fdd6115ce4918ac612fd7946e7f19) +++ src/GenPoly/InstantiateGeneric.cc (revision 43899667c202e39bf5ce46a74a02658953fe5bfb) @@ -44,10 +44,8 @@ ConcreteType(const ConcreteType& that) : base(that.base), params() { cloneAll(that.params, params); } - /// Extracts types from a list of Expression* (which should be TypeExpr*) - ConcreteType(AggregateDecl *_base, const std::list< Expression* >& _params) : base(_base), params() { - for ( std::list< Expression* >::const_iterator it = _params.begin(); it != _params.end(); ++it ) { - TypeExpr *param = dynamic_cast< TypeExpr* >(*it); - assert(param && "Aggregate parameters should be type expressions"); - params.push_back( param->get_type()->clone() ); + /// Extracts types from a list of TypeExpr* + ConcreteType(AggregateDecl *_base, const std::list< TypeExpr* >& _params) : base(_base), params() { + for ( std::list< TypeExpr* >::const_iterator param = _params.begin(); param != _params.end(); ++param ) { + params.push_back( (*param)->get_type()->clone() ); } } @@ -66,7 +64,7 @@ bool operator== (const ConcreteType& that) const { + if ( base != that.base ) return false; + SymTab::Indexer dummy; - - if ( base != that.base ) return false; if ( params.size() != that.params.size() ) return false; for ( std::list< Type* >::const_iterator it = params.begin(), jt = that.params.begin(); it != params.end(); ++it, ++jt ) { @@ -79,9 +77,15 @@ std::list< Type* > params; ///< Instantiation parameters }; - + /// Maps a concrete type to the instantiated struct type, accounting for scope class InstantiationMap { - /// Pair of concrete type and declaration that instantiates it - typedef std::pair< ConcreteType, AggregateDecl* > Instantiation; + /// Instantiation of a generic type, with key information to find it + struct Instantiation { + ConcreteType key; ///< Instantiation parameters for this type + AggregateDecl *decl; ///< Declaration of the instantiated generic type + + Instantiation() : key(), decl(0) {} + Instantiation(const ConcreteType &_key, AggregateDecl *_decl) : key(_key), decl(_decl) {} + }; /// Map of generic types to instantiations of them typedef std::map< AggregateDecl*, std::vector< Instantiation > > Scope; @@ -107,5 +111,5 @@ /// Gets the declaration for the concrete instantiation of this type, assuming it has already been instantiated in the current scope. /// Returns NULL on none such. - AggregateDecl* lookup( AggregateDecl *generic, std::list< Expression* >& params ) { + AggregateDecl* lookup( AggregateDecl *generic, const std::list< TypeExpr* >& params ) { ConcreteType key(generic, params); // scan scopes from innermost out @@ -116,5 +120,5 @@ // look through instantiations for matches to concrete type for ( std::vector< Instantiation >::const_iterator inst = insts->second.begin(); inst != insts->second.end(); ++inst ) { - if ( inst->first == key ) return inst->second; + if ( inst->key == key ) return inst->decl; } } @@ -123,21 +127,23 @@ } public: - StructDecl* lookup( StructInstType *inst ) { return (StructDecl*)lookup( inst->get_baseStruct(), inst->get_parameters() ); } - UnionDecl* lookup( UnionInstType *inst ) { return (UnionDecl*)lookup( inst->get_baseUnion(), inst->get_parameters() ); } + StructDecl* lookup( StructInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (StructDecl*)lookup( inst->get_baseStruct(), typeSubs ); } + UnionDecl* lookup( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (UnionDecl*)lookup( inst->get_baseUnion(), typeSubs ); } private: /// Adds a declaration for a concrete type to the current scope - void insert( AggregateDecl *generic, std::list< Expression* >& params, AggregateDecl *decl ) { + void insert( AggregateDecl *generic, const std::list< TypeExpr* > ¶ms, AggregateDecl *decl ) { ConcreteType key(generic, params); - scopes.back()[generic].push_back( std::make_pair( key, decl ) ); + scopes.back()[generic].push_back( Instantiation( key, decl ) ); } public: - void insert( StructInstType *inst, StructDecl *decl ) { insert( inst->get_baseStruct(), inst->get_parameters(), decl ); } - void insert( UnionInstType *inst, UnionDecl *decl ) { insert( inst->get_baseUnion(), inst->get_parameters(), decl ); } + void insert( StructInstType *inst, const std::list< TypeExpr* > &typeSubs, StructDecl *decl ) { insert( inst->get_baseStruct(), typeSubs, decl ); } + void insert( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs, UnionDecl *decl ) { insert( inst->get_baseUnion(), typeSubs, decl ); } }; /// 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; @@ -147,4 +153,6 @@ virtual Type* mutate( StructInstType *inst ); virtual Type* mutate( UnionInstType *inst ); + +// virtual Expression* mutate( MemberExpr *memberExpr ); virtual void doBeginScope(); @@ -157,10 +165,56 @@ } - /// Substitutes types of members of in according to baseParams => params, appending the result to out - void substituteMembers( const std::list< Declaration* >& in, - const std::list< TypeDecl * >& baseParams, const std::list< Expression* >& params, + /// 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 + + // substitute concrete types for given parameters, and incomplete types for placeholders + std::list< TypeDecl* >::const_iterator baseParam = baseParams.begin(); + 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 + TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param ); + assert(paramType && "Aggregate parameters should be type expressions"); + out.push_back( paramType->clone() ); + // check that the substituted type isn't a type variable itself + if ( dynamic_cast< TypeInstType* >( paramType->get_type() ) ) { + 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; + } + + /// 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, std::list< Declaration* >& out ) { // substitute types into new members - TypeSubstitution subs( baseParams.begin(), baseParams.end(), params.begin() ); + TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() ); for ( std::list< Declaration* >::const_iterator member = in.begin(); member != in.end(); ++member ) { Declaration *newMember = (*member)->clone(); @@ -178,19 +232,26 @@ // exit early if no need for further mutation if ( inst->get_parameters().empty() ) return inst; + assert( inst->get_baseParameters() && "Base struct has parameters" ); + + // check if type can be concretely instantiated; put substitutions into typeSubs + std::list< TypeExpr* > typeSubs; + if ( ! makeSubstitutions( *inst->get_baseParameters(), inst->get_parameters(), typeSubs ) ) { + deleteAll( typeSubs ); + return inst; + } // make concrete instantiation of generic type - StructDecl *concDecl = instantiations.lookup( inst ); + StructDecl *concDecl = instantiations.lookup( inst, typeSubs ); if ( ! concDecl ) { - assert( inst->get_baseParameters() && "Base struct has parameters" ); // set concDecl to new type, insert type declaration into statements to add concDecl = new StructDecl( typeNamer.newName( inst->get_name() ) ); - substituteMembers( inst->get_baseStruct()->get_members(), - *inst->get_baseParameters(), inst->get_parameters(), - concDecl->get_members() ); + substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() ); DeclMutator::addDeclaration( concDecl ); - instantiations.insert( inst, concDecl ); + instantiations.insert( inst, typeSubs, concDecl ); } StructInstType *newInst = new StructInstType( inst->get_qualifiers(), concDecl->get_name() ); newInst->set_baseStruct( concDecl ); + + deleteAll( typeSubs ); delete inst; return newInst; @@ -205,26 +266,82 @@ // exit early if no need for further mutation if ( inst->get_parameters().empty() ) return inst; - + assert( inst->get_baseParameters() && "Base union has parameters" ); + + // check if type can be concretely instantiated; put substitutions into typeSubs + std::list< TypeExpr* > typeSubs; + if ( ! makeSubstitutions( *inst->get_baseParameters(), inst->get_parameters(), typeSubs ) ) { + deleteAll( typeSubs ); + return inst; + } + // make concrete instantiation of generic type - UnionDecl *concDecl = instantiations.lookup( inst ); + UnionDecl *concDecl = instantiations.lookup( inst, typeSubs ); if ( ! concDecl ) { // set concDecl to new type, insert type declaration into statements to add - assert( inst->get_baseParameters() && "Base union has parameters" ); concDecl = new UnionDecl( typeNamer.newName( inst->get_name() ) ); - substituteMembers( inst->get_baseUnion()->get_members(), - *inst->get_baseParameters(), inst->get_parameters(), - concDecl->get_members() ); + substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() ); DeclMutator::addDeclaration( concDecl ); - instantiations.insert( inst, concDecl ); + instantiations.insert( inst, typeSubs, concDecl ); } UnionInstType *newInst = new UnionInstType( inst->get_qualifiers(), concDecl->get_name() ); newInst->set_baseUnion( concDecl ); + + deleteAll( typeSubs ); delete inst; 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(); } @@ -232,5 +349,4 @@ void Instantiate::doEndScope() { DeclMutator::doEndScope(); - // pop the last concrete type scope instantiations.endScope(); } Index: src/GenPoly/Lvalue.cc =================================================================== --- src/GenPoly/Lvalue.cc (revision cf16f94d500fdd6115ce4918ac612fd7946e7f19) +++ src/GenPoly/Lvalue.cc (revision 43899667c202e39bf5ce46a74a02658953fe5bfb) @@ -35,4 +35,5 @@ const std::list