Index: src/Concurrency/Keywords.cc =================================================================== --- src/Concurrency/Keywords.cc (revision bee06942613823dfa3adc6451bf356922ada830e) +++ src/Concurrency/Keywords.cc (revision bbbc067e84adc59b31d39e97991980bf6379934a) @@ -621,5 +621,5 @@ ), new ListInit( - map_range < std::list > ( args, [](DeclarationWithType * var ){ + map_range < std::vector< Initializer * > > ( args, [](DeclarationWithType * var ){ Type * type = var->get_type()->clone(); type->set_mutex( false ); Index: src/Concurrency/Waitfor.cc =================================================================== --- src/Concurrency/Waitfor.cc (revision bee06942613823dfa3adc6451bf356922ada830e) +++ src/Concurrency/Waitfor.cc (revision bbbc067e84adc59b31d39e97991980bf6379934a) @@ -371,5 +371,5 @@ ), new ListInit( - map_range < std::list > ( clause.target.arguments, [this](Expression * expr ){ + map_range < std::vector< Initializer * > > ( clause.target.arguments, [this](Expression * expr ){ Expression * init = new CastExpr( new UntypedExpr( Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision bee06942613823dfa3adc6451bf356922ada830e) +++ src/GenPoly/Box.cc (revision bbbc067e84adc59b31d39e97991980bf6379934a) @@ -1823,5 +1823,5 @@ // build initializer list for offset array - std::list< Initializer* > inits; + std::vector< Initializer * > inits; for ( std::list< Declaration* >::const_iterator member = baseMembers.begin(); member != baseMembers.end(); ++member ) { if ( DeclarationWithType *memberDecl = dynamic_cast< DeclarationWithType* >( *member ) ) { Index: src/Parser/InitializerNode.cc =================================================================== --- src/Parser/InitializerNode.cc (revision bee06942613823dfa3adc6451bf356922ada830e) +++ src/Parser/InitializerNode.cc (revision bbbc067e84adc59b31d39e97991980bf6379934a) @@ -96,5 +96,5 @@ designlist.push_back( new Designation( desList ) ); } // for - std::list< Initializer * > initlist; + std::vector< Initializer * > initlist; buildList< Initializer, InitializerNode >( next_init(), initlist ); return new ListInit( initlist, designlist, maybeConstructed ); Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision bee06942613823dfa3adc6451bf356922ada830e) +++ src/ResolvExpr/Resolver.cc (revision bbbc067e84adc59b31d39e97991980bf6379934a) @@ -80,5 +80,5 @@ void previsit( ConstructorInit *ctorInit ); private: - typedef std::list< Initializer * >::iterator InitIterator; + typedef std::vector< Initializer * >::iterator InitIterator; template< typename PtrType > @@ -235,5 +235,5 @@ winner.cost = winner.cvtCost; } - + // produce ambiguous errors, if applicable if ( winners.size() != 1 ) { @@ -255,5 +255,5 @@ // xxx - check for ambiguous expressions - + // output selected choice alt = std::move( choice ); @@ -402,8 +402,8 @@ void Resolver::previsit( ObjectDecl *objectDecl ) { - // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that - // class-variable initContext is changed multiple time because the LHS is analysed twice. - // The second analysis changes initContext because of a function type can contain object - // declarations in the return and parameter types. So each value of initContext is + // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that + // class-variable initContext is changed multiple time because the LHS is analysed twice. + // The second analysis changes initContext because of a function type can contain object + // declarations in the return and parameter types. So each value of initContext is // retained, so the type on the first analysis is preserved and used for selecting the RHS. GuardValue( currentObject ); @@ -442,7 +442,7 @@ void Resolver::postvisit( FunctionDecl *functionDecl ) { - // default value expressions have an environment which shouldn't be there and trips up + // default value expressions have an environment which shouldn't be there and trips up // later passes. - // xxx - it might be necessary to somehow keep the information from this environment, but I + // xxx - it might be necessary to somehow keep the information from this environment, but I // can't currently see how it's useful. for ( Declaration * d : functionDecl->type->parameters ) { @@ -795,11 +795,11 @@ initExpr->expr = nullptr; std::swap( initExpr->env, newExpr->env ); - // InitExpr may have inferParams in the case where the expression specializes a function - // pointer, and newExpr may already have inferParams of its own, so a simple swap is not + // InitExpr may have inferParams in the case where the expression specializes a function + // pointer, and newExpr may already have inferParams of its own, so a simple swap is not // sufficient. newExpr->spliceInferParams( initExpr ); delete initExpr; - // get the actual object's type (may not exactly match what comes back from the resolver + // get the actual object's type (may not exactly match what comes back from the resolver // due to conversions) Type * initContext = currentObject.getCurrentType(); @@ -814,5 +814,5 @@ if ( isCharType( pt->get_base() ) ) { if ( CastExpr *ce = dynamic_cast< CastExpr * >( newExpr ) ) { - // strip cast if we're initializing a char[] with a char *, + // strip cast if we're initializing a char[] with a char *, // e.g. char x[] = "hello"; newExpr = ce->get_arg(); @@ -837,9 +837,9 @@ // move cursor into brace-enclosed initializer-list currentObject.enterListInit(); - // xxx - fix this so that the list isn't copied, iterator should be used to change current + // xxx - fix this so that the list isn't copied, iterator should be used to change current // element std::list newDesignations; for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) { - // iterate designations and initializers in pairs, moving the cursor to the current + // iterate designations and initializers in pairs, moving the cursor to the current // designated object and resolving the initializer against that object. Designation * des = std::get<0>(p); Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision bee06942613823dfa3adc6451bf356922ada830e) +++ src/SymTab/Validate.cc (revision bbbc067e84adc59b31d39e97991980bf6379934a) @@ -1226,5 +1226,5 @@ TupleType * tupleType = strict_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) ); // ensure return value is not destructed by explicitly creating an empty ListInit node wherein maybeConstruct is false. - ObjectDecl * newRet = new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list(), noDesignators, false ) ); + ObjectDecl * newRet = new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::vector< Initializer * >(), noDesignators, false ) ); deleteAll( retVals ); retVals.clear(); Index: src/SynTree/Initializer.cc =================================================================== --- src/SynTree/Initializer.cc (revision bee06942613823dfa3adc6451bf356922ada830e) +++ src/SynTree/Initializer.cc (revision bbbc067e84adc59b31d39e97991980bf6379934a) @@ -70,5 +70,5 @@ -ListInit::ListInit( const std::list &inits, const std::list &des, bool maybeConstructed ) +ListInit::ListInit( const std::vector< Initializer * > &inits, const std::list &des, bool maybeConstructed ) : Initializer( maybeConstructed ), initializers( inits ), designations( des ) { // handle the common case where a ListInit is created without designations by making a list of empty designations with the same length as the initializer Index: src/SynTree/Initializer.h =================================================================== --- src/SynTree/Initializer.h (revision bee06942613823dfa3adc6451bf356922ada830e) +++ src/SynTree/Initializer.h (revision bbbc067e84adc59b31d39e97991980bf6379934a) @@ -18,4 +18,5 @@ #include // for ostream #include // for list, list<>::const_iterator, list<>::it... +#include #include "BaseSyntaxNode.h" // for BaseSyntaxNode @@ -85,8 +86,8 @@ class ListInit : public Initializer { public: - std::list initializers; // order *is* important + std::vector< Initializer * > initializers; // order *is* important std::list designations; // order/length is consistent with initializers - ListInit( const std::list &initializers, + ListInit( const std::vector< Initializer * > &initializers, const std::list &designators = {}, bool maybeConstructed = false ); ListInit( const ListInit & other ); @@ -94,8 +95,8 @@ std::list & get_designations() { return designations; } - std::list & get_initializers() { return initializers; } + std::vector< Initializer * > & get_initializers() { return initializers; } - typedef std::list::iterator iterator; - typedef std::list::const_iterator const_iterator; + typedef std::vector< Initializer * >::iterator iterator; + typedef std::vector< Initializer * >::const_iterator const_iterator; iterator begin() { return initializers.begin(); } iterator end() { return initializers.end(); } Index: src/Tuples/TupleExpansion.cc =================================================================== --- src/Tuples/TupleExpansion.cc (revision bee06942613823dfa3adc6451bf356922ada830e) +++ src/Tuples/TupleExpansion.cc (revision bbbc067e84adc59b31d39e97991980bf6379934a) @@ -271,5 +271,5 @@ // as a distinct part of its initializer - the produced compound literal may be used as part of // another expression - std::list< Initializer * > inits; + std::vector< Initializer * > inits; for ( Expression * expr : exprs ) { inits.push_back( new SingleInit( expr ) );