Changeset bbbc067

Timestamp:

Jan 29, 2019, 4:30:46 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

no_list

Children:

8d25360

Parents:

bee0694

Message:

Changed std::list<Initializer> to vector

Location:

src

Files:

• Concurrency/Keywords.cc (modified) (1 diff)
• Concurrency/Waitfor.cc (modified) (1 diff)
• GenPoly/Box.cc (modified) (1 diff)
• Parser/InitializerNode.cc (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (8 diffs)
• SymTab/Validate.cc (modified) (1 diff)
• SynTree/Initializer.cc (modified) (1 diff)
• SynTree/Initializer.h (modified) (3 diffs)
• Tuples/TupleExpansion.cc (modified) (1 diff)

src/Concurrency/Keywords.cc

@@ -621 +621 @@
                         ),
                         new ListInit(
-                                map_range < std::list<Initializer*> > ( args, [](DeclarationWithType * var ){
+                                map_range < std::vector< Initializer * > > ( args, [](DeclarationWithType * var ){
                                         Type * type = var->get_type()->clone();
                                         type->set_mutex( false );

src/Concurrency/Waitfor.cc

@@ -371 +371 @@
                         ),
                         new ListInit(
-                                map_range < std::list<Initializer*> > ( clause.target.arguments, [this](Expression * expr ){
+                                map_range < std::vector< Initializer * > > ( clause.target.arguments, [this](Expression * expr ){
                                         Expression * init = new CastExpr(
                                                 new UntypedExpr(

src/GenPoly/Box.cc

@@ -1823 +1823 @@
 
                                         // 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 ) ) {

src/Parser/InitializerNode.cc

@@ -96 +96 @@
                         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 );

src/ResolvExpr/Resolver.cc

@@ -80 +80 @@
                 void previsit( ConstructorInit *ctorInit );
           private:
-                typedef std::list< Initializer * >::iterator InitIterator;
+                typedef std::vector< Initializer * >::iterator InitIterator;
 
                 template< typename PtrType >
@@ -235 +235 @@
                                 winner.cost = winner.cvtCost;
                         }
-                        
+
                         // produce ambiguous errors, if applicable
                         if ( winners.size() != 1 ) {
@@ -255 +255 @@
 
                         // xxx - check for ambiguous expressions
-                        
+
                         // output selected choice
                         alt = std::move( choice );
@@ -402 +402 @@
 
         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 +442 @@
 
         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 +795 @@
                 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 +814 @@
                                         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 +837 @@
                 // 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<Designation *> 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);

src/SymTab/Validate.cc

@@ -1226 +1226 @@
                         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<Initializer*>(), noDesignators, false ) );
+                        ObjectDecl * newRet = new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::vector< Initializer * >(), noDesignators, false ) );
                         deleteAll( retVals );
                         retVals.clear();

src/SynTree/Initializer.cc

@@ -70 +70 @@
 
 
-ListInit::ListInit( const std::list<Initializer*> &inits, const std::list<Designation *> &des, bool maybeConstructed )
+ListInit::ListInit( const std::vector< Initializer * > &inits, const std::list<Designation *> &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

src/SynTree/Initializer.h

@@ -18 +18 @@
 #include <iosfwd>            // for ostream
 #include <list>              // for list, list<>::const_iterator, list<>::it...
+#include <vector>
 
 #include "BaseSyntaxNode.h"  // for BaseSyntaxNode
@@ -85 +86 @@
 class ListInit : public Initializer {
   public:
-        std::list<Initializer *> initializers;  // order *is* important
+        std::vector< Initializer * > initializers;  // order *is* important
         std::list<Designation *> designations;  // order/length is consistent with initializers
 
-        ListInit( const std::list<Initializer*> &initializers,
+        ListInit( const std::vector< Initializer * > &initializers,
                           const std::list<Designation *> &designators = {}, bool maybeConstructed = false );
         ListInit( const ListInit & other );
@@ -94 +95 @@
 
         std::list<Designation *> & get_designations() { return designations; }
-        std::list<Initializer *> & get_initializers() { return initializers; }
+        std::vector< Initializer * > & get_initializers() { return initializers; }
 
-        typedef std::list<Initializer*>::iterator iterator;
-        typedef std::list<Initializer*>::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(); }

src/Tuples/TupleExpansion.cc

@@ -271 +271 @@
                         // 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 ) );