Index: src/CodeGen/FixMain.cc =================================================================== --- src/CodeGen/FixMain.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/CodeGen/FixMain.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -49,5 +49,5 @@ os << main_signature->get_scopedMangleName() << "("; - const auto& params = main_signature->get_functionType()->get_parameters(); + const auto& params = main_signature->get_functionType()->parameters; switch(params.size()) { case 3: os << "(" << genTypeAt(params, 0) << ")argc, (" << genTypeAt(params, 1) << ")argv, (" << genTypeAt(params, 2) << ")envp"; break; Index: src/CodeGen/FixNames.cc =================================================================== --- src/CodeGen/FixNames.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/CodeGen/FixNames.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -50,5 +50,5 @@ main_type = new FunctionType( Type::Qualifiers(), true ), nullptr ) }; - main_type->get_returnVals().push_back( + main_type->returnVals.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) ); @@ -63,13 +63,13 @@ main_type = new FunctionType( Type::Qualifiers(), false ), nullptr ) }; - main_type->get_returnVals().push_back( + main_type->returnVals.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) ); - main_type->get_parameters().push_back( + main_type->parameters.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) ); - main_type->get_parameters().push_back( + main_type->parameters.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Char ) ) ), @@ -116,5 +116,5 @@ if(is_main( SymTab::Mangler::mangle(functionDecl, true, true) )) { - int nargs = functionDecl->get_functionType()->get_parameters().size(); + int nargs = functionDecl->get_functionType()->parameters.size(); if( !(nargs == 0 || nargs == 2 || nargs == 3) ) { SemanticError(functionDecl, "Main expected to have 0, 2 or 3 arguments\n"); Index: src/CodeGen/GenType.cc =================================================================== --- src/CodeGen/GenType.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/CodeGen/GenType.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -186,5 +186,5 @@ /************* parameters ***************/ - const std::list &pars = funcType->parameters; + const auto & pars = funcType->parameters; if ( pars.empty() ) { Index: src/CodeTools/DeclStats.cc =================================================================== --- src/CodeTools/DeclStats.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/CodeTools/DeclStats.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -183,7 +183,8 @@ } - void analyzeSubtypes( std::list& tys, Stats& stats, + void analyzeSubtypes( std::vector& tys, Stats& stats, std::unordered_set& elSeen, unsigned& n_poly, bool& seen_poly, - unsigned& max_depth, unsigned depth, unsigned& n_subs ) { + unsigned& max_depth, unsigned depth, unsigned& n_subs ) + { for ( DeclarationWithType* dwt : tys ) { Type* ty = dwt->get_type(); @@ -204,5 +205,5 @@ } - void analyzeSubtypes( std::list& tys, Stats& stats, + void analyzeSubtypes( std::vector& tys, Stats& stats, std::unordered_set& elSeen, unsigned& n_poly, bool& seen_poly, unsigned& max_depth, unsigned depth ) { @@ -246,8 +247,8 @@ unsigned n_subs = 0; analyzeSubtypes( - ft->get_returnVals(), stats, elSeen, n_poly, seen_poly, max_depth, depth, + ft->returnVals, stats, elSeen, n_poly, seen_poly, max_depth, depth, n_subs ); analyzeSubtypes( - ft->get_parameters(), stats, elSeen, n_poly, seen_poly, max_depth, depth, + ft->parameters, stats, elSeen, n_poly, seen_poly, max_depth, depth, n_subs ); ++stats.n_generic_params.at( n_subs ); @@ -280,5 +281,5 @@ name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen); analyzeSubtypes( - tt->get_types(), stats, elSeen, n_poly, seen_poly, max_depth, depth ); + tt->types, stats, elSeen, n_poly, seen_poly, max_depth, depth ); ++stats.n_generic_params.at( tt->size() ); } else if ( dynamic_cast(ty) ) { @@ -299,7 +300,7 @@ /// Update arg pack stats based on a declaration list - void analyze( Stats& stats, std::unordered_set& seen, - std::unordered_set& elSeen, ArgPackStats& pstats, - std::list& decls ) { + void analyze( Stats& stats, std::unordered_set & seen, + std::unordered_set & elSeen, ArgPackStats & pstats, + std::vector & decls ) { std::unordered_set types; unsigned n = 0; ///< number of args/returns @@ -345,6 +346,6 @@ std::unordered_set seen; std::unordered_set elSeen; - analyze( stats, seen, elSeen, params, fnTy->get_parameters() ); - analyze( stats, seen, elSeen, returns, fnTy->get_returnVals() ); + analyze( stats, seen, elSeen, params , fnTy->parameters ); + analyze( stats, seen, elSeen, returns, fnTy->returnVals ); } Index: src/CodeTools/ResolvProtoDump.cc =================================================================== --- src/CodeTools/ResolvProtoDump.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/CodeTools/ResolvProtoDump.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -102,5 +102,5 @@ /// builds space-separated list of types template - static void build( V& visitor, const std::list< Type* >& tys, std::stringstream& ss, + static void build( V& visitor, const std::vector< Type* >& tys, std::stringstream& ss, septype mode = separated ) { if ( tys.empty() ) return; @@ -121,5 +121,5 @@ /// builds list of types wrapped as tuple type template - static void buildAsTuple( V& visitor, const std::list< Type* >& tys, + static void buildAsTuple( V& visitor, const std::vector< Type * > & tys, std::stringstream& ss ) { switch ( tys.size() ) { @@ -135,6 +135,6 @@ /// gets types from DWT list - static std::list< Type* > from_decls( const std::list< DeclarationWithType* >& decls ) { - std::list< Type* > tys; + static std::vector< Type * > from_decls( const std::vector< DeclarationWithType * > & decls ) { + std::vector< Type * > tys; for ( auto decl : decls ) { tys.emplace_back( decl->get_type() ); } return tys; @@ -142,6 +142,6 @@ /// gets types from TypeExpr list - static std::list< Type* > from_exprs( const std::list< Expression* >& exprs ) { - std::list< Type* > tys; + static std::vector< Type* > from_exprs( const std::list< Expression* >& exprs ) { + std::vector< Type* > tys; for ( auto expr : exprs ) { if ( TypeExpr* tyExpr = dynamic_cast(expr) ) { @@ -587,5 +587,5 @@ /// Adds all named declarations in a list to the local scope - void addAll( const std::list& decls ) { + void addAll( const std::vector& decls ) { for ( auto decl : decls ) { // skip anonymous decls @@ -644,5 +644,5 @@ // add body if available if ( decl->statements ) { - std::list rtns = from_decls( decl->type->returnVals ); + auto rtns = from_decls( decl->type->returnVals ); Type* rtn = nullptr; if ( rtns.size() == 1 ) { Index: src/Common/utility.h =================================================================== --- src/Common/utility.h (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/Common/utility.h (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -497,4 +497,18 @@ } +// ----------------------------------------------------------------------------- +/// Simple ranged-base standard algorithms +namespace std { + template< typename range, typename out > + static inline auto move( range & r, out o ) -> decltype(std::move( std::begin(r), std::end(r), o )) { + return std::move( std::begin(r), std::end(r), o ); + } + + template< typename range, typename out > + static inline auto copy( range & r, out o ) -> decltype(std::copy( std::begin(r), std::end(r), o )) { + return std::copy( std::begin(r), std::end(r), o ); + } +} + // Local Variables: // // tab-width: 4 // Index: src/Concurrency/Keywords.cc =================================================================== --- src/Concurrency/Keywords.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/Concurrency/Keywords.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -337,6 +337,6 @@ ); - get_type->get_parameters().push_back( this_decl->clone() ); - get_type->get_returnVals().push_back( + get_type->parameters.push_back( this_decl->clone() ); + get_type->returnVals.push_back( new ObjectDecl( "ret", @@ -371,5 +371,5 @@ FunctionType * main_type = new FunctionType( noQualifiers, false ); - main_type->get_parameters().push_back( this_decl->clone() ); + main_type->parameters.push_back( this_decl->clone() ); main_decl = new FunctionDecl( @@ -405,5 +405,5 @@ ); - decl->get_members().push_back( field ); + decl->members.push_back( field ); return field; @@ -418,6 +418,6 @@ field, new CastExpr( - new VariableExpr( func->get_functionType()->get_parameters().front() ), - func->get_functionType()->get_parameters().front()->get_type()->stripReferences()->clone() + new VariableExpr( func->get_functionType()->parameters.front() ), + func->get_functionType()->parameters.front()->get_type()->stripReferences()->clone() ) ) @@ -449,5 +449,5 @@ // If this is the destructor for a monitor it must be mutex if(isDtor) { - Type* ty = decl->get_functionType()->get_parameters().front()->get_type(); + Type* ty = decl->get_functionType()->parameters.front()->get_type(); // If it's a copy, it's not a mutex @@ -483,5 +483,5 @@ // Check if we need to instrument the body - CompoundStmt* body = decl->get_statements(); + CompoundStmt* body = decl->statements; if( ! body ) return; @@ -519,5 +519,5 @@ bool once = true; - for( auto arg : decl->get_functionType()->get_parameters()) { + for( auto arg : decl->get_functionType()->parameters) { //Find mutex arguments Type* ty = arg->get_type(); @@ -681,5 +681,5 @@ } - DeclarationWithType * param = decl->get_functionType()->get_parameters().front(); + DeclarationWithType * param = decl->get_functionType()->parameters.front(); auto type = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) ); if( type && type->get_baseStruct()->is_thread() ) { Index: src/ControlStruct/ExceptTranslate.cc =================================================================== --- src/ControlStruct/ExceptTranslate.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/ControlStruct/ExceptTranslate.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -187,11 +187,11 @@ unused_index_obj->attributes.push_back( new Attribute( "unused" ) ); - catch_func_t.get_parameters().push_back( index_obj.clone() ); - catch_func_t.get_parameters().push_back( exception_obj.clone() ); - match_func_t.get_returnVals().push_back( unused_index_obj ); - match_func_t.get_parameters().push_back( exception_obj.clone() ); - handle_func_t.get_returnVals().push_back( bool_obj.clone() ); - handle_func_t.get_parameters().push_back( exception_obj.clone() ); - finally_func_t.get_parameters().push_back( voidptr_obj.clone() ); + catch_func_t.parameters.push_back( index_obj.clone() ); + catch_func_t.parameters.push_back( exception_obj.clone() ); + match_func_t.returnVals.push_back( unused_index_obj ); + match_func_t.parameters.push_back( exception_obj.clone() ); + handle_func_t.returnVals.push_back( bool_obj.clone() ); + handle_func_t.parameters.push_back( exception_obj.clone() ); + finally_func_t.parameters.push_back( voidptr_obj.clone() ); } @@ -275,6 +275,6 @@ FunctionType *func_type = catch_func_t.clone(); - DeclarationWithType * index_obj = func_type->get_parameters().front(); - DeclarationWithType * except_obj = func_type->get_parameters().back(); + DeclarationWithType * index_obj = func_type->parameters.front(); + DeclarationWithType * except_obj = func_type->parameters.back(); // Index 1..{number of handlers} @@ -397,5 +397,5 @@ FunctionType * func_type = match_func_t.clone(); - DeclarationWithType * except_obj = func_type->get_parameters().back(); + DeclarationWithType * except_obj = func_type->parameters.back(); // Index 1..{number of handlers} @@ -451,5 +451,5 @@ FunctionType * func_type = handle_func_t.clone(); - DeclarationWithType * except_obj = func_type->get_parameters().back(); + DeclarationWithType * except_obj = func_type->parameters.back(); CatchList::iterator it; Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/GenPoly/Box.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -286,6 +286,6 @@ TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param ); std::string paramName = mangleType( ¶mType ); - layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) ); - layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( paramName ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) ); + layoutFnType->parameters.push_back( new ObjectDecl( sizeofName( paramName ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) ); + layoutFnType->parameters.push_back( new ObjectDecl( alignofName( paramName ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) ); } } @@ -367,9 +367,9 @@ ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 ); - layoutFnType->get_parameters().push_back( sizeParam ); + layoutFnType->parameters.push_back( sizeParam ); ObjectDecl *alignParam = new ObjectDecl( alignofName( structDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 ); - layoutFnType->get_parameters().push_back( alignParam ); + layoutFnType->parameters.push_back( alignParam ); ObjectDecl *offsetParam = new ObjectDecl( offsetofName( structDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 ); - layoutFnType->get_parameters().push_back( offsetParam ); + layoutFnType->parameters.push_back( offsetParam ); addOtypeParams( layoutFnType, otypeParams ); @@ -428,7 +428,7 @@ ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 ); - layoutFnType->get_parameters().push_back( sizeParam ); + layoutFnType->parameters.push_back( sizeParam ); ObjectDecl *alignParam = new ObjectDecl( alignofName( unionDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 ); - layoutFnType->get_parameters().push_back( alignParam ); + layoutFnType->parameters.push_back( alignParam ); addOtypeParams( layoutFnType, otypeParams ); @@ -468,6 +468,6 @@ // to take those polymorphic types as pointers. Therefore, there can be two different functions // with the same mangled name, so we need to further mangle the names. - for ( std::list< DeclarationWithType *>::iterator retval = function->get_returnVals().begin(); retval != function->get_returnVals().end(); ++retval ) { - if ( isPolyType( (*retval)->get_type(), tyVars ) ) { + for ( auto retval : function->returnVals ) { + if ( isPolyType( retval->get_type(), tyVars ) ) { name << "P"; } else { @@ -476,7 +476,7 @@ } name << "_"; - std::list< DeclarationWithType *> ¶mList = function->get_parameters(); - for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) { - if ( isPolyType( (*arg)->get_type(), tyVars ) ) { + auto & paramList = function->parameters; + for ( auto arg : paramList ) { + if ( isPolyType( arg->get_type(), tyVars ) ) { name << "P"; } else { @@ -518,20 +518,20 @@ makeTyVarMap( functionType, scopeTyVars ); - std::list< DeclarationWithType *> ¶mList = functionType->parameters; - std::list< FunctionType *> functions; - for ( Type::ForallList::iterator tyVar = functionType->forall.begin(); tyVar != functionType->forall.end(); ++tyVar ) { - for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) { - findFunction( (*assert)->get_type(), functions, scopeTyVars, needsAdapter ); + auto & paramList = functionType->parameters; + std::vector< FunctionType *> functions; + for ( auto tyVar : functionType->forall ) { + for ( auto assert : tyVar->assertions ) { + findFunction( assert->get_type(), functions, scopeTyVars, needsAdapter ); } // for } // for - for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) { - findFunction( (*arg)->get_type(), functions, scopeTyVars, needsAdapter ); + for ( auto arg : paramList ) { + findFunction( arg->get_type(), functions, scopeTyVars, needsAdapter ); } // for - for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) { - std::string mangleName = mangleAdapterName( *funType, scopeTyVars ); + for ( auto funType : functions ) { + std::string mangleName = mangleAdapterName( funType, scopeTyVars ); if ( adapters.find( mangleName ) == adapters.end() ) { std::string adapterName = makeAdapterName( mangleName ); - adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), nullptr ) ) ); + adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( funType, scopeTyVars ) ), nullptr ) ) ); } // if } // for @@ -612,5 +612,5 @@ assert( funcType ); - std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin(); + std::vector< DeclarationWithType* >::const_iterator fnParm = funcType->parameters.begin(); std::list< Expression* >::const_iterator fnArg = arg; std::set< std::string > seenTypes; ///< names for generic types we've seen @@ -624,5 +624,5 @@ // add type information args for presently unseen types in parameter list - for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) { + for ( ; fnParm != funcType->parameters.end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) { if ( ! (*fnArg)->get_result() ) continue; Type * argType = (*fnArg)->get_result(); @@ -708,5 +708,5 @@ // if ( ! function->get_returnVals().empty() && isPolyType( function->get_returnVals().front()->get_type(), tyVars ) ) { if ( isDynRet( function, tyVars ) ) { - ret = addRetParam( appExpr, function->get_returnVals().front()->get_type(), arg ); + ret = addRetParam( appExpr, function->returnVals.front()->get_type(), arg ); } // if std::string mangleName = mangleAdapterName( function, tyVars ); @@ -786,9 +786,10 @@ } - void Pass1::boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) { - for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->parameters.end(); ++param, ++arg ) { - assertf( arg != appExpr->args.end(), "boxParams: missing argument for param %s to %s in %s", toString( *param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() ); - addCast( *arg, (*param)->get_type(), exprTyVars ); - boxParam( (*param)->get_type(), *arg, exprTyVars ); + void Pass1::boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator & arg, const TyVarMap &exprTyVars ) { + for ( auto param : function->parameters ) { + assertf( arg != appExpr->args.end(), "boxParams: missing argument for param %s to %s in %s", toString( param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() ); + addCast( *arg, param->get_type(), exprTyVars ); + boxParam( param->get_type(), *arg, exprTyVars ); + ++arg; } // for } @@ -796,11 +797,11 @@ void Pass1::addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ) { std::list< Expression *>::iterator cur = arg; - for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) { - for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) { - InferredParams::const_iterator inferParam = appExpr->inferParams.find( (*assert)->get_uniqueId() ); - assertf( inferParam != appExpr->inferParams.end(), "addInferredParams missing inferred parameter: %s in: %s", toString( *assert ).c_str(), toString( appExpr ).c_str() ); + for ( auto tyVar : functionType->forall ) { + for ( auto assert : tyVar->assertions ) { + InferredParams::const_iterator inferParam = appExpr->inferParams.find( assert->get_uniqueId() ); + assertf( inferParam != appExpr->inferParams.end(), "addInferredParams missing inferred parameter: %s in: %s", toString( assert ).c_str(), toString( appExpr ).c_str() ); Expression *newExpr = inferParam->second.expr->clone(); - addCast( newExpr, (*assert)->get_type(), tyVars ); - boxParam( (*assert)->get_type(), newExpr, tyVars ); + addCast( newExpr, assert->get_type(), tyVars ); + boxParam( assert->get_type(), newExpr, tyVars ); appExpr->get_args().insert( cur, newExpr ); } // for @@ -813,8 +814,8 @@ // make a new parameter that is a pointer to the type of the old return value retParm->set_type( new PointerType( Type::Qualifiers(), retParm->get_type() ) ); - funcType->get_parameters().push_front( retParm ); + funcType->parameters.insert( funcType->parameters.begin(), retParm ); // we don't need the return value any more - funcType->get_returnVals().clear(); + funcType->returnVals.clear(); } @@ -825,5 +826,5 @@ makeRetParm( adapter ); } // if - adapter->get_parameters().push_front( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) ); + adapter->parameters.insert( adapter->parameters.begin(), new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) ); return adapter; } @@ -844,5 +845,5 @@ } - void addAdapterParams( ApplicationExpr *adapteeApp, std::list< DeclarationWithType *>::iterator arg, std::list< DeclarationWithType *>::iterator param, std::list< DeclarationWithType *>::iterator paramEnd, std::list< DeclarationWithType *>::iterator realParam, const TyVarMap &tyVars ) { + void addAdapterParams( ApplicationExpr *adapteeApp, std::vector< DeclarationWithType *>::iterator arg, std::vector< DeclarationWithType *>::iterator param, std::vector< DeclarationWithType *>::iterator paramEnd, std::vector< DeclarationWithType *>::iterator realParam, const TyVarMap &tyVars ) { UniqueName paramNamer( "_p" ); for ( ; param != paramEnd; ++param, ++arg, ++realParam ) { @@ -858,5 +859,5 @@ FunctionType *adapterType = makeAdapterType( adaptee, tyVars ); adapterType = ScrubTyVars::scrub( adapterType, tyVars ); - DeclarationWithType *adapteeDecl = adapterType->get_parameters().front(); + DeclarationWithType *adapteeDecl = adapterType->parameters.front(); adapteeDecl->set_name( "_adaptee" ); // do not carry over attributes to real type parameters/return values @@ -877,22 +878,22 @@ for ( ; tyParam != adapterType->get_forall().end(); ++tyArg, ++tyParam, ++realTyParam ) { assert( tyArg != realType->get_forall().end() ); - std::list< DeclarationWithType *>::iterator assertArg = (*tyArg)->get_assertions().begin(); - std::list< DeclarationWithType *>::iterator assertParam = (*tyParam)->get_assertions().begin(); - std::list< DeclarationWithType *>::iterator realAssertParam = (*realTyParam)->get_assertions().begin(); - for ( ; assertParam != (*tyParam)->get_assertions().end(); ++assertArg, ++assertParam, ++realAssertParam ) { - assert( assertArg != (*tyArg)->get_assertions().end() ); + std::vector< DeclarationWithType *>::iterator assertArg = (*tyArg)->assertions.begin(); + std::vector< DeclarationWithType *>::iterator assertParam = (*tyParam)->assertions.begin(); + std::vector< DeclarationWithType *>::iterator realAssertParam = (*realTyParam)->assertions.begin(); + for ( ; assertParam != (*tyParam)->assertions.end(); ++assertArg, ++assertParam, ++realAssertParam ) { + assert( assertArg != (*tyArg)->assertions.end() ); adapteeApp->get_args().push_back( makeAdapterArg( *assertParam, *assertArg, *realAssertParam, tyVars ) ); } // for } // for - std::list< DeclarationWithType *>::iterator arg = realType->get_parameters().begin(); - std::list< DeclarationWithType *>::iterator param = adapterType->get_parameters().begin(); - std::list< DeclarationWithType *>::iterator realParam = adaptee->get_parameters().begin(); + std::vector< DeclarationWithType *>::iterator arg = realType->parameters.begin(); + std::vector< DeclarationWithType *>::iterator param = adapterType->parameters.begin(); + std::vector< DeclarationWithType *>::iterator realParam = adaptee->parameters.begin(); param++; // skip adaptee parameter in the adapter type - if ( realType->get_returnVals().empty() ) { + if ( realType->returnVals.empty() ) { // void return - addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars ); + addAdapterParams( adapteeApp, arg, param, adapterType->parameters.end(), realParam, tyVars ); bodyStmt = new ExprStmt( adapteeApp ); - } else if ( isDynType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) { + } else if ( isDynType( adaptee->returnVals.front()->get_type(), tyVars ) ) { // return type T if ( (*param)->get_name() == "" ) { @@ -901,12 +902,12 @@ } // if UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); - UntypedExpr *deref = UntypedExpr::createDeref( new CastExpr( new VariableExpr( *param++ ), new PointerType( Type::Qualifiers(), realType->get_returnVals().front()->get_type()->clone() ) ) ); + UntypedExpr *deref = UntypedExpr::createDeref( new CastExpr( new VariableExpr( *param++ ), new PointerType( Type::Qualifiers(), realType->returnVals.front()->get_type()->clone() ) ) ); assign->get_args().push_back( deref ); - addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars ); + addAdapterParams( adapteeApp, arg, param, adapterType->parameters.end(), realParam, tyVars ); assign->get_args().push_back( adapteeApp ); bodyStmt = new ExprStmt( assign ); } else { // adapter for a function that returns a monomorphic value - addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars ); + addAdapterParams( adapteeApp, arg, param, adapterType->parameters.end(), realParam, tyVars ); bodyStmt = new ReturnStmt( adapteeApp ); } // if @@ -919,13 +920,13 @@ void Pass1::passAdapters( ApplicationExpr * appExpr, FunctionType * functionType, const TyVarMap & exprTyVars ) { // collect a list of function types passed as parameters or implicit parameters (assertions) - std::list< DeclarationWithType *> ¶mList = functionType->get_parameters(); - std::list< FunctionType *> functions; - for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) { - for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) { - findFunction( (*assert)->get_type(), functions, exprTyVars, needsAdapter ); + auto & paramList = functionType->parameters; + std::vector< FunctionType *> functions; + for ( auto tyVar : functionType->forall ) { + for ( auto assert : tyVar->assertions ) { + findFunction( assert->get_type(), functions, exprTyVars, needsAdapter ); } // for } // for - for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) { - findFunction( (*arg)->get_type(), functions, exprTyVars, needsAdapter ); + for ( auto arg : paramList ) { + findFunction( arg->get_type(), functions, exprTyVars, needsAdapter ); } // for @@ -934,7 +935,7 @@ std::set< std::string > adaptersDone; - for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) { - FunctionType *originalFunction = (*funType)->clone(); - FunctionType *realFunction = (*funType)->clone(); + for ( auto funType : functions ) { + FunctionType * originalFunction = funType->clone(); + FunctionType * realFunction = funType->clone(); std::string mangleName = SymTab::Mangler::mangle( realFunction ); @@ -954,5 +955,5 @@ if ( adapter == adapters.end() ) { // adapter has not been created yet in the current scope, so define it - FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars ); + FunctionDecl *newAdapter = makeAdapter( funType, realFunction, mangleName, exprTyVars ); std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) ); adapter = answer.first; @@ -1255,22 +1256,21 @@ void Pass2::addAdapters( FunctionType *functionType ) { - std::list< DeclarationWithType *> ¶mList = functionType->parameters; - std::list< FunctionType *> functions; - for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) { - Type *orig = (*arg)->get_type(); + auto & paramList = functionType->parameters; + std::vector< FunctionType *> functions; + for ( auto arg : paramList ) { + Type *orig = arg->get_type(); findAndReplaceFunction( orig, functions, scopeTyVars, needsAdapter ); - (*arg)->set_type( orig ); + arg->set_type( orig ); } std::set< std::string > adaptersDone; - for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) { - std::string mangleName = mangleAdapterName( *funType, scopeTyVars ); + for ( auto funType : functions ) { + std::string mangleName = mangleAdapterName( funType, scopeTyVars ); if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) { std::string adapterName = makeAdapterName( mangleName ); // adapter may not be used in body, pass along with unused attribute. - paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0, { new Attribute( "unused" ) } ) ); + paramList.insert( paramList.begin(), new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( funType, scopeTyVars ) ), 0, { new Attribute( "unused" ) } ) ); adaptersDone.insert( adaptersDone.begin(), mangleName ); } } -// deleteAll( functions ); } @@ -1324,4 +1324,23 @@ void Pass2::premutate( FunctionType *funcType ) { + + + + + + + + + + + + + + + + + + + GuardScope( scopeTyVars ); makeTyVarMap( funcType, scopeTyVars ); @@ -1329,14 +1348,21 @@ // move polymorphic return type to parameter list if ( isDynRet( funcType ) ) { - ObjectDecl *ret = strict_dynamic_cast< ObjectDecl* >( funcType->get_returnVals().front() ); + ObjectDecl *ret = strict_dynamic_cast< ObjectDecl* >( funcType->returnVals.front() ); ret->set_type( new PointerType( Type::Qualifiers(), ret->get_type() ) ); - funcType->get_parameters().push_front( ret ); - funcType->get_returnVals().pop_front(); + funcType->parameters.insert( funcType->parameters.begin(), ret ); + funcType->returnVals.erase(funcType->returnVals.begin()); ret->set_init( nullptr ); // xxx - memory leak? } - // add size/align and assertions for type parameters to parameter list - std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin(); - std::list< DeclarationWithType *> inferredParams; + // create a list of parameters after adding new ones + std::vector newParams; + std::vector inferredParams; + + // reserve some memory for these vectors + // Number of elements needed should be somewhat linear with the number of parameters / forall + // "somewhat linear" == 2X + newParams.reserve(funcType->parameters.size() * 2 + funcType->forall.size() * 2); + inferredParams.reserve(funcType->forall.size() * 2); + // size/align/offset parameters may not be used in body, pass along with unused attribute. ObjectDecl newObj( "", Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, @@ -1344,56 +1370,50 @@ ObjectDecl newPtr( "", Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 ); - for ( Type::ForallList::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) { - ObjectDecl *sizeParm, *alignParm; + + // We do this several time, create a functor for it + auto pushObj = [&newObj, &newParams]( const std::string & name ) { + auto parm = newObj.clone(); + parm->set_name( name ); + newParams.push_back( parm ); + }; + + // add size/align and assertions for type parameters to parameter list + for ( auto tyParm : funcType->forall ) { // add all size and alignment parameters to parameter list - if ( (*tyParm)->isComplete() ) { - TypeInstType parmType( Type::Qualifiers(), (*tyParm)->get_name(), *tyParm ); + if ( tyParm->isComplete() ) { + TypeInstType parmType( Type::Qualifiers(), tyParm->get_name(), tyParm ); std::string parmName = mangleType( &parmType ); - - sizeParm = newObj.clone(); - sizeParm->set_name( sizeofName( parmName ) ); - last = funcType->get_parameters().insert( last, sizeParm ); - ++last; - - alignParm = newObj.clone(); - alignParm->set_name( alignofName( parmName ) ); - last = funcType->get_parameters().insert( last, alignParm ); - ++last; + pushObj( sizeofName( parmName ) ); + pushObj( alignofName( parmName ) ); } // move all assertions into parameter list - for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) { + // move all assertions into parameter list + for ( auto assert : tyParm->assertions ) { // assertion parameters may not be used in body, pass along with unused attribute. - (*assert)->get_attributes().push_back( new Attribute( "unused" ) ); - inferredParams.push_back( *assert ); - } - (*tyParm)->get_assertions().clear(); + assert->attributes.push_back( new Attribute( "unused" ) ); + inferredParams.push_back( assert ); + } + tyParm->assertions.clear(); } // add size/align for generic parameter types to parameter list std::set< std::string > seenTypes; // sizeofName for generic types we've seen - for ( std::list< DeclarationWithType* >::const_iterator fnParm = last; fnParm != funcType->get_parameters().end(); ++fnParm ) { - Type *polyType = isPolyType( (*fnParm)->get_type(), scopeTyVars ); - if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) { + for ( DeclarationWithType * fnParm : funcType->parameters ) + { + Type *polyType = isPolyType( fnParm->get_type(), scopeTyVars ); + if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) + { std::string typeName = mangleType( polyType ); if ( seenTypes.count( typeName ) ) continue; - ObjectDecl *sizeParm, *alignParm, *offsetParm; - sizeParm = newObj.clone(); - sizeParm->set_name( sizeofName( typeName ) ); - last = funcType->get_parameters().insert( last, sizeParm ); - ++last; - - alignParm = newObj.clone(); - alignParm->set_name( alignofName( typeName ) ); - last = funcType->get_parameters().insert( last, alignParm ); - ++last; + pushObj( sizeofName ( typeName ) ); + pushObj( alignofName( typeName ) ); if ( StructInstType *polyBaseStruct = dynamic_cast< StructInstType* >( polyType ) ) { // NOTE zero-length arrays are illegal in C, so empty structs have no offset array if ( ! polyBaseStruct->get_baseStruct()->get_members().empty() ) { - offsetParm = newPtr.clone(); - offsetParm->set_name( offsetofName( typeName ) ); - last = funcType->get_parameters().insert( last, offsetParm ); - ++last; + auto offset = newPtr.clone(); + offset->set_name( offsetofName( typeName ) ); + newParams.push_back( offset ); } } @@ -1403,5 +1423,9 @@ // splice assertion parameters into parameter list - funcType->get_parameters().splice( last, inferredParams ); + std::copy( inferredParams , std::back_inserter(newParams) ); + std::copy( funcType->parameters, std::back_inserter(newParams) ); + + funcType->parameters.swap(newParams); + addAdapters( funcType ); } @@ -1470,7 +1494,7 @@ // make sure that any type information passed into the function is accounted for - for ( std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin(); fnParm != funcType->get_parameters().end(); ++fnParm ) { + for ( auto fnParm : funcType->parameters ) { // condition here duplicates that in Pass2::mutate( FunctionType* ) - Type *polyType = isPolyType( (*fnParm)->get_type(), scopeTyVars ); + Type *polyType = isPolyType( fnParm->get_type(), scopeTyVars ); if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) { knownLayouts.insert( mangleType( polyType ) ); Index: src/GenPoly/FindFunction.cc =================================================================== --- src/GenPoly/FindFunction.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/GenPoly/FindFunction.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -29,5 +29,5 @@ class FindFunction : public WithGuards, public WithVisitorRef, public WithShortCircuiting { public: - FindFunction( std::list< FunctionType* > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate ); + FindFunction( std::vector< FunctionType* > & functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate ); void premutate( FunctionType * functionType ); @@ -37,5 +37,5 @@ void handleForall( const Type::ForallList &forall ); - std::list< FunctionType* > &functions; + std::vector< FunctionType* > &functions; TyVarMap tyVars; bool replaceMode; @@ -43,15 +43,15 @@ }; - void findFunction( Type *type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) { + void findFunction( Type *type, std::vector< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) { PassVisitor finder( functions, tyVars, false, predicate ); type->acceptMutator( finder ); } - void findAndReplaceFunction( Type *&type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) { + void findAndReplaceFunction( Type *&type, std::vector< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) { PassVisitor finder( functions, tyVars, true, predicate ); type = type->acceptMutator( finder ); } - FindFunction::FindFunction( std::list< FunctionType* > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate ) + FindFunction::FindFunction( std::vector< FunctionType* > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate ) : functions( functions ), tyVars( tyVars ), replaceMode( replaceMode ), predicate( predicate ) { } @@ -70,5 +70,5 @@ GuardScope( tyVars ); handleForall( functionType->get_forall() ); - mutateAll( functionType->get_returnVals(), *visitor ); + mutateAll( functionType->returnVals, *visitor ); } Index: src/GenPoly/FindFunction.h =================================================================== --- src/GenPoly/FindFunction.h (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/GenPoly/FindFunction.h (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// FindFunction.h -- +// FindFunction.h -- // // Author : Richard C. Bilson @@ -27,7 +27,7 @@ /// 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 ); + void findFunction( Type *type, std::vector< 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 ); + void findAndReplaceFunction( Type *&type, std::vector< FunctionType* > & functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ); } // namespace GenPoly Index: src/GenPoly/GenPoly.cc =================================================================== --- src/GenPoly/GenPoly.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/GenPoly/GenPoly.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -144,26 +144,22 @@ ReferenceToType *isDynRet( FunctionType *function, const TyVarMap &forallTypes ) { - if ( function->get_returnVals().empty() ) return 0; - - return (ReferenceToType*)isDynType( function->get_returnVals().front()->get_type(), forallTypes ); + if ( function->returnVals.empty() ) return 0; + + return (ReferenceToType*)isDynType( function->returnVals.front()->get_type(), forallTypes ); } ReferenceToType *isDynRet( FunctionType *function ) { - if ( function->get_returnVals().empty() ) return 0; + if ( function->returnVals.empty() ) return 0; TyVarMap forallTypes( TypeDecl::Data{} ); makeTyVarMap( function, forallTypes ); - return (ReferenceToType*)isDynType( function->get_returnVals().front()->get_type(), forallTypes ); + return (ReferenceToType*)isDynType( function->returnVals.front()->get_type(), forallTypes ); } bool needsAdapter( FunctionType *adaptee, const TyVarMap &tyVars ) { -// if ( ! adaptee->get_returnVals().empty() && isPolyType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) { -// return true; -// } // if if ( isDynRet( adaptee, tyVars ) ) return true; - for ( std::list< DeclarationWithType* >::const_iterator innerArg = adaptee->get_parameters().begin(); innerArg != adaptee->get_parameters().end(); ++innerArg ) { -// if ( isPolyType( (*innerArg)->get_type(), tyVars ) ) { - if ( isDynType( (*innerArg)->get_type(), tyVars ) ) { + for ( auto innerArg : adaptee->parameters ) { + if ( isDynType( innerArg->get_type(), tyVars ) ) { return true; } // if @@ -315,5 +311,5 @@ /// Flattens a declaration list template - void flattenList( list< DeclarationWithType* > src, Output out ) { + void flattenList( vector< DeclarationWithType* > src, Output out ) { for ( DeclarationWithType* decl : src ) { ResolvExpr::flatten( decl->get_type(), out ); @@ -323,5 +319,5 @@ /// Flattens a list of types template - void flattenList( list< Type* > src, Output out ) { + void flattenList( vector< Type* > src, Output out ) { for ( Type* ty : src ) { ResolvExpr::flatten( ty, out ); @@ -395,11 +391,11 @@ vector aparams, bparams; - flattenList( af->get_parameters(), back_inserter( aparams ) ); - flattenList( bf->get_parameters(), back_inserter( bparams ) ); + flattenList( af->parameters, back_inserter( aparams ) ); + flattenList( bf->parameters, back_inserter( bparams ) ); if ( aparams.size() != bparams.size() ) return false; vector areturns, breturns; - flattenList( af->get_returnVals(), back_inserter( areturns ) ); - flattenList( bf->get_returnVals(), back_inserter( breturns ) ); + flattenList( af->returnVals, back_inserter( areturns ) ); + flattenList( bf->returnVals, back_inserter( breturns ) ); if ( areturns.size() != breturns.size() ) return false; @@ -429,6 +425,6 @@ vector atypes, btypes; - flattenList( at->get_types(), back_inserter( atypes ) ); - flattenList( bt->get_types(), back_inserter( btypes ) ); + flattenList( at->types, back_inserter( atypes ) ); + flattenList( bt->types, back_inserter( btypes ) ); if ( atypes.size() != btypes.size() ) return false; Index: src/GenPoly/Specialize.cc =================================================================== --- src/GenPoly/Specialize.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/GenPoly/Specialize.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -91,5 +91,5 @@ if ( tuple1 && tuple2 ) { if ( tuple1->size() != tuple2->size() ) return false; - for ( auto types : group_iterate( tuple1->get_types(), tuple2->get_types() ) ) { + for ( auto types : group_iterate( tuple1->types, tuple2->types ) ) { if ( ! matchingTupleStructure( std::get<0>( types ), std::get<1>( types ) ) ) return false; } @@ -115,5 +115,5 @@ size_t functionParameterSize( FunctionType * ftype ) { size_t sz = 0; - for ( DeclarationWithType * p : ftype->get_parameters() ) { + for ( DeclarationWithType * p : ftype->parameters ) { sz += singleParameterSize( p->get_type() ); } @@ -227,9 +227,9 @@ } std::unique_ptr< FunctionType > actualTypeManager( actualType ); // for RAII - std::list< DeclarationWithType * >::iterator actualBegin = actualType->get_parameters().begin(); - std::list< DeclarationWithType * >::iterator actualEnd = actualType->get_parameters().end(); + auto actualBegin = actualType->parameters.begin(); + auto actualEnd = actualType->parameters.end(); std::list< Expression * > args; - for ( DeclarationWithType* param : thunkFunc->get_functionType()->get_parameters() ) { + for ( DeclarationWithType* param : thunkFunc->get_functionType()->parameters ) { // name each thunk parameter and explode it - these are then threaded back into the actual function call. param->set_name( paramNamer.newName() ); @@ -281,7 +281,7 @@ FunctionType *function = getFunctionType( appExpr->function->result ); assert( function ); - std::list< DeclarationWithType* >::iterator formal; + std::vector< DeclarationWithType* >::iterator formal; std::list< Expression* >::iterator actual; - for ( formal = function->get_parameters().begin(), actual = appExpr->get_args().begin(); formal != function->get_parameters().end() && actual != appExpr->get_args().end(); ++formal, ++actual ) { + for ( formal = function->parameters.begin(), actual = appExpr->get_args().begin(); formal != function->parameters.end() && actual != appExpr->get_args().end(); ++formal, ++actual ) { *actual = doSpecialization( (*formal)->get_type(), *actual, &appExpr->inferParams ); } Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/InitTweak/FixInit.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -1042,6 +1042,6 @@ if ( checkWarnings( function ) ) { FunctionType * type = function->get_functionType(); - assert( ! type->get_parameters().empty() ); - thisParam = strict_dynamic_cast< ObjectDecl * >( type->get_parameters().front() ); + assert( ! type->parameters.empty() ); + thisParam = strict_dynamic_cast< ObjectDecl * >( type->parameters.front() ); Type * thisType = getPointerBase( thisParam->get_type() ); StructInstType * structType = dynamic_cast< StructInstType * >( thisType ); @@ -1099,5 +1099,5 @@ if ( isCopyConstructor( function ) ) { // if copy ctor, need to pass second-param-of-this-function.field - std::list< DeclarationWithType * > & params = function->get_functionType()->get_parameters(); + auto & params = function->get_functionType()->parameters; assert( params.size() == 2 ); arg2 = new MemberExpr( field, new VariableExpr( params.back() ) ); Index: src/InitTweak/GenInit.cc =================================================================== --- src/InitTweak/GenInit.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/InitTweak/GenInit.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -127,5 +127,5 @@ void ReturnFixer::premutate( ReturnStmt *returnStmt ) { - std::list< DeclarationWithType * > & returnVals = ftype->get_returnVals(); + auto & returnVals = ftype->returnVals; assert( returnVals.size() == 0 || returnVals.size() == 1 ); // hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address @@ -242,5 +242,5 @@ // if this function is a user-defined constructor or destructor, mark down the type as "managed" if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && CodeGen::isCtorDtor( dwt->get_name() ) ) { - std::list< DeclarationWithType * > & params = GenPoly::getFunctionType( dwt->get_type() )->get_parameters(); + auto & params = GenPoly::getFunctionType( dwt->get_type() )->parameters; assert( ! params.empty() ); Type * type = InitTweak::getPointerBase( params.front()->get_type() ); @@ -335,5 +335,5 @@ // go through assertions and recursively add seen ctor/dtors for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) { - for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) { + for ( DeclarationWithType *& assertion : tyDecl->assertions ) { managedTypes.handleDWT( assertion ); } Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/InitTweak/InitTweak.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -410,5 +410,5 @@ FunctionType *funcType = GenPoly::getFunctionType( appExpr->function->result ); assert( funcType ); - return funcType->get_parameters().size() == 1; + return funcType->parameters.size() == 1; } return false; @@ -616,5 +616,5 @@ if ( ftype->parameters.size() != 2 ) return nullptr; - Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() ); + Type * t1 = getPointerBase( ftype->parameters.front()->get_type() ); Type * t2 = ftype->parameters.back()->get_type(); assert( t1 ); Index: src/MakeLibCfa.cc =================================================================== --- src/MakeLibCfa.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/MakeLibCfa.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -103,15 +103,15 @@ UntypedExpr *newExpr = new UntypedExpr( new NameExpr( funcDecl->get_name() ) ); UniqueName paramNamer( "_p" ); - std::list< DeclarationWithType* >::iterator param = funcDecl->get_functionType()->get_parameters().begin(); - assert( param != funcDecl->get_functionType()->get_parameters().end() ); + auto & params = funcDecl->get_functionType()->parameters; + assert( !params.empty() ); - for ( ; param != funcDecl->get_functionType()->get_parameters().end(); ++param ) { + for ( auto param : params ) { // name each unnamed parameter - if ( (*param)->get_name() == "" ) { - (*param)->set_name( paramNamer.newName() ); - (*param)->set_linkage( LinkageSpec::C ); + if ( param->get_name() == "" ) { + param->set_name( paramNamer.newName() ); + param->set_linkage( LinkageSpec::C ); } // add parameter to the expression - newExpr->get_args().push_back( new VariableExpr( *param ) ); + newExpr->get_args().push_back( new VariableExpr( param ) ); } // for Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/Parser/DeclarationNode.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -1065,7 +1065,7 @@ } // buildList -void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > & outputList ) { +void buildTypeList( const DeclarationNode * firstNode, std::vector< Type * > & outputList ) { SemanticErrorException errors; - std::back_insert_iterator< std::list< Type * > > out( outputList ); + std::back_insert_iterator< std::vector< Type * > > out( outputList ); const DeclarationNode * cur = firstNode; @@ -1097,5 +1097,5 @@ assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." ); TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.tyClass == Otype, variable.initializer ? variable.initializer->buildType() : nullptr ); - buildList( variable.assertions, ret->get_assertions() ); + buildList( variable.assertions, ret->assertions ); return ret; } // if Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/Parser/ParseNode.h (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -467,5 +467,5 @@ void buildList( const DeclarationNode * firstNode, std::list< Declaration * > & outputList ); void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > & outputList ); -void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > & outputList ); +void buildTypeList( const DeclarationNode * firstNode, std::vector< Type * > & outputList ); template< typename SynTreeType, typename NodeType > Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/Parser/TypeData.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -493,24 +493,24 @@ // add dtor: void ^?{}(T *) FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false ); - dtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); - td->get_assertions().push_front( new FunctionDecl( "^?{}", Type::StorageClasses(), LinkageSpec::Cforall, dtorType, nullptr ) ); + dtorType->parameters.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + td->assertions.insert( td->assertions.begin(), new FunctionDecl( "^?{}", Type::StorageClasses(), LinkageSpec::Cforall, dtorType, nullptr ) ); // add copy ctor: void ?{}(T *, T) FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false ); - copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); - copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); - td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, copyCtorType, nullptr ) ); + copyCtorType->parameters.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + copyCtorType->parameters.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); + td->assertions.insert( td->assertions.begin(), new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, copyCtorType, nullptr ) ); // add default ctor: void ?{}(T *) FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false ); - ctorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); - td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, ctorType, nullptr ) ); + ctorType->parameters.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + td->assertions.insert( td->assertions.begin(), new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, ctorType, nullptr ) ); // add assignment operator: T * ?=?(T *, T) FunctionType * assignType = new FunctionType( Type::Qualifiers(), false ); - assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); - assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); - assignType->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); - td->get_assertions().push_front( new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Cforall, assignType, nullptr ) ); + assignType->parameters.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + assignType->parameters.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); + assignType->returnVals.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); + td->assertions.insert( td->assertions.begin(), new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Cforall, assignType, nullptr ) ); } // if } // for @@ -897,5 +897,5 @@ } // if buildList( td->symbolic.params, ret->get_parameters() ); - buildList( td->symbolic.assertions, ret->get_assertions() ); + buildList( td->symbolic.assertions, ret->assertions ); ret->base->attributes.insert( ret->base->attributes.end(), attributes.begin(), attributes.end() ); return ret; @@ -930,5 +930,5 @@ TupleType * buildTuple( const TypeData * td ) { assert( td->kind == TypeData::Tuple ); - std::list< Type * > types; + std::vector< Type * > types; buildTypeList( td->tuple, types ); TupleType * ret = new TupleType( buildQualifiers( td ), types ); @@ -983,8 +983,8 @@ break; default: - ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", Type::StorageClasses(), nullptr, Type::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) ); + ft->returnVals.push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", Type::StorageClasses(), nullptr, Type::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) ); } // switch } else { - ft->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) ); + ft->returnVals.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) ); } // if return ft; Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/ResolvExpr/AlternativeFinder.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -434,7 +434,7 @@ Cost convCost = Cost::zero; - std::list< DeclarationWithType* >& formals = function->parameters; - std::list< DeclarationWithType* >::iterator formal = formals.begin(); - std::list< Expression* >& actuals = appExpr->args; + auto & formals = function->parameters; + auto formal = formals.begin(); + auto & actuals = appExpr->args; for ( Expression*& actualExpr : actuals ) { @@ -493,8 +493,8 @@ /// Adds type variables to the open variable set and marks their assertions void makeUnifiableVars( Type *type, OpenVarSet &unifiableVars, AssertionSet &needAssertions ) { - for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) { - unifiableVars[ (*tyvar)->get_name() ] = TypeDecl::Data{ *tyvar }; - for ( std::list< DeclarationWithType* >::iterator assert = (*tyvar)->assertions.begin(); assert != (*tyvar)->assertions.end(); ++assert ) { - needAssertions[ *assert ].isUsed = true; + for ( auto tyvar : type->forall ) { + unifiableVars[ tyvar->get_name() ] = TypeDecl::Data{ tyvar }; + for ( auto assert : tyvar->assertions ) { + needAssertions[ assert ].isUsed = true; } } @@ -1407,5 +1407,5 @@ // assume no polymorphism // assume no implicit conversions - assert( function->get_parameters().size() == 1 ); + assert( function->parameters.size() == 1 ); PRINT( std::cerr << "resolvAttr: funcDecl is "; @@ -1417,5 +1417,5 @@ const SymTab::Indexer & indexer = finder.get_indexer(); AltList & alternatives = finder.get_alternatives(); - if ( typesCompatibleIgnoreQualifiers( argType, function->get_parameters().front()->get_type(), indexer, env ) ) { + if ( typesCompatibleIgnoreQualifiers( argType, function->parameters.front()->get_type(), indexer, env ) ) { Cost cost = Cost::zero; Expression * newExpr = data.combine( cost ); @@ -1442,5 +1442,5 @@ if ( FunctionType *function = dynamic_cast< FunctionType* >( id->get_type() ) ) { // assume exactly one parameter - if ( function->get_parameters().size() == 1 ) { + if ( function->parameters.size() == 1 ) { if ( attrExpr->get_isType() ) { resolveAttr( data, function, attrExpr->get_type(), env, altFinder); Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/ResolvExpr/ConversionCost.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -388,6 +388,6 @@ Cost c = Cost::zero; if ( TupleType * destAsTuple = dynamic_cast< TupleType * >( dest ) ) { - std::list< Type * >::const_iterator srcIt = tupleType->types.begin(); - std::list< Type * >::const_iterator destIt = destAsTuple->types.begin(); + std::vector< Type * >::const_iterator srcIt = tupleType->types.begin(); + std::vector< Type * >::const_iterator destIt = destAsTuple->types.begin(); while ( srcIt != tupleType->types.end() && destIt != destAsTuple->types.end() ) { Cost newCost = costFunc( *srcIt++, *destIt++, indexer, env ); Index: src/ResolvExpr/FindOpenVars.cc =================================================================== --- src/ResolvExpr/FindOpenVars.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/ResolvExpr/FindOpenVars.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -50,28 +50,18 @@ void FindOpenVars::common_action( Type *type ) { if ( nextIsOpen ) { - for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) { - openVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) }; - for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) { - needAssertions[ *assert ].isUsed = false; + for ( const auto i : type->get_forall() ) { + openVars[ i->get_name() ] = TypeDecl::Data{ i }; + for ( const auto assert : i->assertions ) { + needAssertions[ assert ].isUsed = false; } -/// cloneAll( (*i)->get_assertions(), needAssertions ); -/// needAssertions.insert( needAssertions.end(), (*i)->get_assertions().begin(), (*i)->get_assertions().end() ); } } else { - for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) { - closedVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) }; - for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) { - haveAssertions[ *assert ].isUsed = false; + for ( const auto i : type->get_forall() ) { + closedVars[ i->get_name() ] = TypeDecl::Data{ i }; + for ( const auto assert : i->assertions ) { + haveAssertions[ assert ].isUsed = false; } -/// cloneAll( (*i)->get_assertions(), haveAssertions ); -/// haveAssertions.insert( haveAssertions.end(), (*i)->get_assertions().begin(), (*i)->get_assertions().end() ); } // for } // if -/// std::cerr << "type is "; -/// type->print( std::cerr ); -/// std::cerr << std::endl << "need is" << std::endl; -/// printAssertionSet( needAssertions, std::cerr ); -/// std::cerr << std::endl << "have is" << std::endl; -/// printAssertionSet( haveAssertions, std::cerr ); } Index: src/ResolvExpr/SpecCost.cc =================================================================== --- src/ResolvExpr/SpecCost.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/ResolvExpr/SpecCost.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -42,5 +42,5 @@ private: // takes minimum non-negative count over parameter/return list - void takeminover( int& mincount, std::list& dwts ) { + void takeminover( int& mincount, std::vector & dwts ) { for ( DeclarationWithType* dwt : dwts ) { count = -1; @@ -61,5 +61,5 @@ visit_children = false; } - + private: // returns minimum non-negative count + 1 over type parameters (-1 if none such) @@ -80,5 +80,5 @@ visit_children = false; } - + // look for polymorphic parameters void previsit(UnionInstType* uty) { Index: src/ResolvExpr/Unify.cc =================================================================== --- src/ResolvExpr/Unify.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/ResolvExpr/Unify.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -283,5 +283,5 @@ void markAssertions( AssertionSet &assertion1, AssertionSet &assertion2, Type *type ) { for ( auto tyvar : type->get_forall() ) { - for ( auto assert : tyvar->get_assertions() ) { + for ( auto assert : tyvar->assertions ) { markAssertionSet( assertion1, assert ); markAssertionSet( assertion2, assert ); @@ -336,5 +336,5 @@ template< typename Iterator, typename Func > std::unique_ptr combineTypes( Iterator begin, Iterator end, Func & toType ) { - std::list< Type * > types; + std::vector< Type * > types; for ( ; begin != end; ++begin ) { // it's guaranteed that a ttype variable will be bound to a flat tuple, so ensure that this results in a flat tuple @@ -404,5 +404,5 @@ /// flattens a list of declarations, so that each tuple type has a single declaration. /// makes use of TtypeExpander to ensure ttypes are flat as well. - void flattenList( std::list< DeclarationWithType * > src, std::list< DeclarationWithType * > & dst, TypeEnvironment & env ) { + void flattenList( std::vector< DeclarationWithType * > src, std::vector< DeclarationWithType * > & dst, TypeEnvironment & env ) { dst.clear(); for ( DeclarationWithType * dcl : src ) { @@ -429,6 +429,6 @@ std::unique_ptr flatFunc( functionType->clone() ); std::unique_ptr flatOther( otherFunction->clone() ); - flattenList( flatFunc->get_parameters(), flatFunc->get_parameters(), env ); - flattenList( flatOther->get_parameters(), flatOther->get_parameters(), env ); + flattenList( flatFunc ->parameters, flatFunc ->parameters, env ); + flattenList( flatOther->parameters, flatOther->parameters, env ); // sizes don't have to match if ttypes are involved; need to be more precise wrt where the ttype is to prevent errors @@ -481,5 +481,5 @@ } else if ( tupleParam ) { // bundle other parameters into tuple to match - std::list< Type * > binderTypes; + std::vector< Type * > binderTypes; do { @@ -497,5 +497,5 @@ } else if ( otherTupleParam ) { // bundle parameters into tuple to match other - std::list< Type * > binderTypes; + std::vector< Type * > binderTypes; do { @@ -626,11 +626,11 @@ // xxx - compute once and store in the FunctionType? Type * extractResultType( FunctionType * function ) { - if ( function->get_returnVals().size() == 0 ) { + if ( function->returnVals.size() == 0 ) { return new VoidType( Type::Qualifiers() ); - } else if ( function->get_returnVals().size() == 1 ) { - return function->get_returnVals().front()->get_type()->clone(); + } else if ( function->returnVals.size() == 1 ) { + return function->returnVals.front()->get_type()->clone(); } else { - std::list< Type * > types; - for ( DeclarationWithType * decl : function->get_returnVals() ) { + std::vector< Type * > types; + for ( DeclarationWithType * decl : function->returnVals ) { types.push_back( decl->get_type()->clone() ); } // for Index: src/ResolvExpr/typeops.h =================================================================== --- src/ResolvExpr/typeops.h (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/ResolvExpr/typeops.h (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -73,5 +73,5 @@ // in AlternativeFinder.cc - Cost computeConversionCost( Type *actualType, Type *formalType, + Cost computeConversionCost( Type *actualType, Type *formalType, const SymTab::Indexer &indexer, const TypeEnvironment &env ); @@ -112,5 +112,5 @@ bool occurs( Type *type, std::string varName, const TypeEnvironment &env ); - template + template bool occursIn( Type* ty, Iter begin, Iter end, const TypeEnvironment &env ) { while ( begin != end ) { @@ -128,5 +128,5 @@ void flatten( Type * type, OutputIterator out ) { if ( TupleType * tupleType = dynamic_cast< TupleType * >( type ) ) { - for ( Type * t : tupleType->get_types() ) { + for ( Type * t : tupleType->types ) { flatten( t, out ); } Index: src/SymTab/Autogen.cc =================================================================== --- src/SymTab/Autogen.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/SymTab/Autogen.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -410,9 +410,9 @@ } - assert( ! func->get_functionType()->get_parameters().empty() ); - ObjectDecl * dstParam = dynamic_cast( func->get_functionType()->get_parameters().front() ); + assert( ! func->get_functionType()->parameters.empty() ); + ObjectDecl * dstParam = dynamic_cast( func->get_functionType()->parameters.front() ); ObjectDecl * srcParam = nullptr; - if ( func->get_functionType()->get_parameters().size() == 2 ) { - srcParam = dynamic_cast( func->get_functionType()->get_parameters().back() ); + if ( func->get_functionType()->parameters.size() == 2 ) { + srcParam = dynamic_cast( func->get_functionType()->parameters.back() ); } @@ -429,5 +429,5 @@ void StructFuncGenerator::makeFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func ) { FunctionType * ftype = func->type; - std::list & params = ftype->parameters; + auto & params = ftype->parameters; assert( params.size() >= 2 ); // should not call this function for default ctor, etc. @@ -435,5 +435,5 @@ ObjectDecl * dstParam = dynamic_cast( params.front() ); assert( dstParam ); - std::list::iterator parameter = params.begin()+1; + auto parameter = params.begin()+1; for ( ; member != end; ++member ) { if ( DeclarationWithType * field = dynamic_cast( *member ) ) { @@ -656,15 +656,15 @@ void makeTupleFunctionBody( FunctionDecl * function ) { FunctionType * ftype = function->get_functionType(); - assertf( ftype->get_parameters().size() == 1 || ftype->get_parameters().size() == 2, "too many parameters in generated tuple function" ); + assertf( ftype->parameters.size() == 1 || ftype->parameters.size() == 2, "too many parameters in generated tuple function" ); UntypedExpr * untyped = new UntypedExpr( new NameExpr( function->get_name() ) ); /// xxx - &* is used to make this easier for later passes to handle - untyped->get_args().push_back( new AddressExpr( UntypedExpr::createDeref( new VariableExpr( ftype->get_parameters().front() ) ) ) ); - if ( ftype->get_parameters().size() == 2 ) { - untyped->get_args().push_back( new VariableExpr( ftype->get_parameters().back() ) ); - } - function->get_statements()->get_kids().push_back( new ExprStmt( untyped ) ); - function->get_statements()->get_kids().push_back( new ReturnStmt( UntypedExpr::createDeref( new VariableExpr( ftype->get_parameters().front() ) ) ) ); + untyped->get_args().push_back( new AddressExpr( UntypedExpr::createDeref( new VariableExpr( ftype->parameters.front() ) ) ) ); + if ( ftype->parameters.size() == 2 ) { + untyped->get_args().push_back( new VariableExpr( ftype->parameters.back() ) ); + } + function->statements->get_kids().push_back( new ExprStmt( untyped ) ); + function->statements->get_kids().push_back( new ReturnStmt( UntypedExpr::createDeref( new VariableExpr( ftype->parameters.front() ) ) ) ); } @@ -691,11 +691,11 @@ TypeDecl * newDecl = new TypeDecl( ty->get_baseType()->get_name(), Type::StorageClasses(), nullptr, TypeDecl::Dtype, true ); TypeInstType * inst = new TypeInstType( Type::Qualifiers(), newDecl->get_name(), newDecl ); - newDecl->get_assertions().push_back( new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Cforall, genAssignType( inst ), nullptr, + newDecl->assertions.push_back( new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Cforall, genAssignType( inst ), nullptr, std::vector< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) ); - newDecl->get_assertions().push_back( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr, + newDecl->assertions.push_back( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr, std::vector< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) ); - newDecl->get_assertions().push_back( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, genCopyType( inst ), nullptr, + newDecl->assertions.push_back( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, genCopyType( inst ), nullptr, std::vector< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) ); - newDecl->get_assertions().push_back( new FunctionDecl( "^?{}", Type::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr, + newDecl->assertions.push_back( new FunctionDecl( "^?{}", Type::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr, std::vector< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) ); typeParams.push_back( newDecl ); Index: src/SymTab/Demangle.cc =================================================================== --- src/SymTab/Demangle.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/SymTab/Demangle.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -173,5 +173,5 @@ /************* parameters ***************/ - const std::list &pars = funcType->parameters; + const std::vector &pars = funcType->parameters; if ( pars.empty() ) { @@ -476,5 +476,5 @@ Type * StringView::parseTuple(Type::Qualifiers tq) { PRINT( std::cerr << "tuple..." << std::endl; ) - std::list< Type * > types; + std::vector< Type * > types; size_t ncomponents; if (! extractNumber(ncomponents)) return nullptr; Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/SymTab/Indexer.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -142,5 +142,5 @@ for ( auto decl : copy ) { if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl.id ) ) { - std::list< DeclarationWithType * > & params = function->type->parameters; + auto & params = function->type->parameters; assert( ! params.empty() ); // use base type of pointer, so that qualifiers on the pointer type aren't considered. @@ -668,5 +668,5 @@ } - void Indexer::addIds( const std::list< DeclarationWithType * > & decls ) { + void Indexer::addIds( const std::vector< DeclarationWithType * > & decls ) { for ( auto d : decls ) { addId( d ); Index: src/SymTab/Indexer.h =================================================================== --- src/SymTab/Indexer.h (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/SymTab/Indexer.h (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -117,5 +117,5 @@ /// convenience function for adding a list of Ids to the indexer - void addIds( const std::list< DeclarationWithType * > & decls ); + void addIds( const std::vector< DeclarationWithType * > & decls ); /// convenience function for adding a list of forall parameters to the indexer Index: src/SymTab/Mangler.cc =================================================================== --- src/SymTab/Mangler.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/SymTab/Mangler.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -79,6 +79,6 @@ public: - Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams, - int nextVarNum, const ResolvExpr::TypeEnvironment* env, + Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams, + int nextVarNum, const ResolvExpr::TypeEnvironment* env, const VarMapType& varNums ); @@ -109,5 +109,5 @@ } - std::string mangleAssnKey( DeclarationWithType* decl, + std::string mangleAssnKey( DeclarationWithType* decl, const ResolvExpr::TypeEnvironment& env ) { PassVisitor mangler( env ); @@ -118,17 +118,17 @@ namespace { Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams ) - : nextVarNum( 0 ), env(nullptr), isTopLevel( true ), - mangleOverridable( mangleOverridable ), typeMode( typeMode ), + : nextVarNum( 0 ), env(nullptr), isTopLevel( true ), + mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {} - + Mangler::Mangler( const ResolvExpr::TypeEnvironment& env ) : nextVarNum( 0 ), env( &env ), isTopLevel( true ), mangleOverridable( false ), typeMode( false ), mangleGenericParams( true ) {} - - Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams, - int nextVarNum, const ResolvExpr::TypeEnvironment* env, + + Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams, + int nextVarNum, const ResolvExpr::TypeEnvironment* env, const VarMapType& varNums ) - : varNums( varNums ), nextVarNum( nextVarNum ), env( env ), isTopLevel( false ), - mangleOverridable( mangleOverridable ), typeMode( typeMode ), + : varNums( varNums ), nextVarNum( nextVarNum ), env( env ), isTopLevel( false ), + mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {} @@ -207,6 +207,6 @@ namespace { - inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) { - std::list< Type* > ret; + inline std::vector< Type* > getTypes( const std::vector< DeclarationWithType* > decls ) { + std::vector< Type* > ret; std::transform( decls.begin(), decls.end(), std::back_inserter( ret ), std::mem_fun( &DeclarationWithType::get_type ) ); @@ -223,9 +223,9 @@ GuardValue( inFunctionType ); inFunctionType = true; - std::list< Type* > returnTypes = getTypes( functionType->returnVals ); + std::vector< Type* > returnTypes = getTypes( functionType->returnVals ); if (returnTypes.empty()) mangleName << Encoding::void_t; else acceptAll( returnTypes, *visitor ); mangleName << "_"; - std::list< Type* > paramTypes = getTypes( functionType->parameters ); + std::vector< Type* > paramTypes = getTypes( functionType->parameters ); acceptAll( paramTypes, *visitor ); mangleName << "_"; @@ -238,10 +238,10 @@ if ( mangleGenericParams ) { - std::list< Expression* >& params = refType->parameters; + std::list< Expression* > & params = refType->parameters; if ( ! params.empty() ) { mangleName << "_"; - for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) { - TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param ); - assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(*param)); + for ( auto param : params ) { + TypeExpr *paramType = dynamic_cast< TypeExpr* >( param ); + assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(param)); maybeAccept( paramType->type, *visitor ); } @@ -364,5 +364,5 @@ if ( varClass && varClass->type ) { PassVisitor sub_mangler( - mangleOverridable, typeMode, mangleGenericParams, nextVarNum, + mangleOverridable, typeMode, mangleGenericParams, nextVarNum, env, varNums ); varClass->type->accept( sub_mangler ); @@ -375,9 +375,9 @@ } varNums[ (*i)->name ] = std::make_pair( varName, (int)(*i)->get_kind() ); - for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) { - PassVisitor sub_mangler( - mangleOverridable, typeMode, mangleGenericParams, nextVarNum, env, + for ( auto assert : (*i)->assertions ) { + PassVisitor sub_mangler( + mangleOverridable, typeMode, mangleGenericParams, nextVarNum, env, varNums ); - (*assert)->accept( sub_mangler ); + assert->accept( sub_mangler ); assertionNames.push_back( sub_mangler.pass.get_mangleName() ); acount++; Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/SymTab/Validate.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -179,6 +179,5 @@ void previsit( ReturnStmt * returnStmt ); - typedef std::list< DeclarationWithType * > ReturnVals; - ReturnVals returnVals; + std::vector< DeclarationWithType * > returnVals; }; @@ -866,5 +865,5 @@ void ReturnChecker::previsit( FunctionDecl * functionDecl ) { GuardValue( returnVals ); - returnVals = functionDecl->get_functionType()->get_returnVals(); + returnVals = functionDecl->get_functionType()->returnVals; } @@ -1121,6 +1120,6 @@ void VerifyCtorDtorAssign::previsit( FunctionDecl * funcDecl ) { FunctionType * funcType = funcDecl->get_functionType(); - std::list< DeclarationWithType * > &returnVals = funcType->get_returnVals(); - std::list< DeclarationWithType * > ¶ms = funcType->get_parameters(); + auto & returnVals = funcType->returnVals; + auto & params = funcType->parameters; if ( CodeGen::isCtorDtorAssign( funcDecl->get_name() ) ) { // TODO: also check /=, etc. @@ -1205,5 +1204,5 @@ void ReturnTypeFixer::postvisit( FunctionDecl * functionDecl ) { FunctionType * ftype = functionDecl->get_functionType(); - std::list< DeclarationWithType * > & retVals = ftype->get_returnVals(); + auto & retVals = ftype->returnVals; assertf( retVals.size() == 0 || retVals.size() == 1, "Function %s has too many return values: %zu", functionDecl->get_name().c_str(), retVals.size() ); if ( retVals.size() == 1 ) { @@ -1223,5 +1222,5 @@ // Note that this pass needs to happen early so that other passes which look for tuple types // find them in all of the right places, including function return types. - std::list< DeclarationWithType * > & retVals = ftype->get_returnVals(); + auto & retVals = ftype->returnVals; if ( retVals.size() > 1 ) { // generate a single return parameter which is the tuple of all of the return values @@ -1320,5 +1319,5 @@ if ( funcDecl->get_name() == "*?" && funcDecl->get_linkage() == LinkageSpec::Intrinsic ) { FunctionType * ftype = funcDecl->get_functionType(); - if ( ftype->get_parameters().size() == 1 && ftype->get_parameters().front()->get_type()->get_qualifiers() == Type::Qualifiers() ) { + if ( ftype->parameters.size() == 1 && ftype->parameters.front()->get_type()->get_qualifiers() == Type::Qualifiers() ) { dereferenceOperator = funcDecl; } Index: src/SynTree/Declaration.h =================================================================== --- src/SynTree/Declaration.h (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/SynTree/Declaration.h (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -182,5 +182,5 @@ Type *base; std::list< TypeDecl* > parameters; - std::list< DeclarationWithType* > assertions; + std::vector< DeclarationWithType* > assertions; NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *type ); @@ -191,5 +191,4 @@ void set_base( Type *newValue ) { base = newValue; } std::list< TypeDecl* >& get_parameters() { return parameters; } - std::list< DeclarationWithType* >& get_assertions() { return assertions; } virtual std::string typeString() const = 0; Index: src/SynTree/FunctionType.cc =================================================================== --- src/SynTree/FunctionType.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/SynTree/FunctionType.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -39,5 +39,5 @@ namespace { - bool containsTtype( const std::list & l ) { + bool containsTtype( const std::vector & l ) { if ( ! l.empty() ) { return Tuples::isTtype( l.back()->get_type() ); Index: src/SynTree/TupleExpr.cc =================================================================== --- src/SynTree/TupleExpr.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/SynTree/TupleExpr.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -66,5 +66,5 @@ TupleType * type = strict_dynamic_cast< TupleType * >( tuple->get_result() ); assertf( type->size() > index, "TupleIndexExpr index out of bounds: tuple size %d, requested index %d in expr %s", type->size(), index, toString( tuple ).c_str() ); - set_result( (*std::next( type->get_types().begin(), index ))->clone() ); + set_result( (*std::next( type->types.begin(), index ))->clone() ); // like MemberExpr, TupleIndexExpr is always an lvalue get_result()->set_lvalue( true ); Index: src/SynTree/TupleType.cc =================================================================== --- src/SynTree/TupleType.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/SynTree/TupleType.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -25,5 +25,5 @@ class Attribute; -TupleType::TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ), types( types ) { +TupleType::TupleType( const Type::Qualifiers &tq, const std::vector< Type * > & types, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ), types( types ) { for ( Type * t : *this ) { // xxx - this is very awkward. TupleTypes should contain objects so that members can be named, but if they don't have an initializer node then Index: src/SynTree/Type.h =================================================================== --- src/SynTree/Type.h (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/SynTree/Type.h (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -359,6 +359,6 @@ class FunctionType : public Type { public: - std::list returnVals; - std::list parameters; + std::vector returnVals; + std::vector parameters; // Does the function accept a variable number of arguments following the arguments specified in the parameters list. @@ -372,6 +372,4 @@ virtual ~FunctionType(); - std::list & get_returnVals() { return returnVals; } - std::list & get_parameters() { return parameters; } bool get_isVarArgs() const { return isVarArgs; } void set_isVarArgs( bool newValue ) { isVarArgs = newValue; } @@ -564,15 +562,14 @@ class TupleType : public Type { public: - std::list types; + std::vector types; std::list members; - TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() ); + TupleType( const Type::Qualifiers & tq, const std::vector< Type * > & types, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() ); TupleType( const TupleType& ); virtual ~TupleType(); - typedef std::list value_type; + typedef std::vector< Type * > value_type; typedef value_type::iterator iterator; - std::list & get_types() { return types; } virtual unsigned size() const override { return types.size(); }; Index: src/Tuples/TupleExpansion.cc =================================================================== --- src/Tuples/TupleExpansion.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/Tuples/TupleExpansion.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -217,5 +217,5 @@ StructDecl * decl = typeMap[tupleSize]; StructInstType * newType = new StructInstType( qualifiers, decl ); - for ( auto p : group_iterate( tupleType->get_types(), decl->get_parameters() ) ) { + for ( auto p : group_iterate( tupleType->types, decl->get_parameters() ) ) { Type * t = std::get<0>(p); newType->get_parameters().push_back( new TypeExpr( t->clone() ) ); @@ -298,5 +298,6 @@ Type * makeTupleType( const std::list< Expression * > & exprs ) { // produce the TupleType which aggregates the types of the exprs - std::list< Type * > types; + std::vector< Type * > types; + types.reserve(exprs.size()); Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex ); for ( Expression * expr : exprs ) {