Changeset 70a1c3ae

Timestamp:

Jan 29, 2019, 4:09:59 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

no_list

Children:

bee0694

Parents:

ede87c6

Message:

Starting to remove std::list to see if it affects performance, started with List of attributes

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (1 diff)
• CodeGen/CodeGenerator.h (modified) (1 diff)
• ControlStruct/ExceptTranslate.cc (modified) (4 diffs)
• GenPoly/Box.cc (modified) (3 diffs)
• InitTweak/FixInit.cc (modified) (1 diff)
• InitTweak/InitTweak.cc (modified) (1 diff)
• Parser/DeclarationNode.cc (modified) (2 diffs)
• Parser/ParseNode.h (modified) (2 diffs)
• Parser/TypeData.cc (modified) (7 diffs)
• Parser/TypeData.h (modified) (2 diffs)
• SymTab/Autogen.cc (modified) (2 diffs)
• SymTab/Validate.cc (modified) (1 diff)
• SynTree/AggregateDecl.cc (modified) (1 diff)
• SynTree/ArrayType.cc (modified) (1 diff)
• SynTree/AttrType.cc (modified) (1 diff)
• SynTree/Attribute.h (modified) (2 diffs)
• SynTree/BasicType.cc (modified) (1 diff)
• SynTree/Declaration.h (modified) (11 diffs)
• SynTree/DeclarationWithType.cc (modified) (1 diff)
• SynTree/FunctionDecl.cc (modified) (1 diff)
• SynTree/FunctionType.cc (modified) (1 diff)
• SynTree/Label.h (modified) (3 diffs)
• SynTree/ObjectDecl.cc (modified) (1 diff)
• SynTree/PointerType.cc (modified) (1 diff)
• SynTree/ReferenceToType.cc (modified) (6 diffs)
• SynTree/ReferenceType.cc (modified) (1 diff)
• SynTree/TupleType.cc (modified) (1 diff)
• SynTree/Type.cc (modified) (1 diff)
• SynTree/Type.h (modified) (21 diffs)
• SynTree/TypeofType.cc (modified) (1 diff)
• SynTree/VarArgsType.cc (modified) (1 diff)
• SynTree/VoidType.cc (modified) (1 diff)
• SynTree/ZeroOneType.cc (modified) (2 diffs)

src/CodeGen/CodeGenerator.cc ¶

@@ -129 +129 @@
         }
 
-        void CodeGenerator::genAttributes( list< Attribute * > & attributes ) {
+        void CodeGenerator::genAttributes( vector< Attribute * > & attributes ) {
           if ( attributes.empty() ) return;
                 output << "__attribute__ ((";
-                for ( list< Attribute * >::iterator attr( attributes.begin() );; ) {
+                for ( vector< Attribute * >::iterator attr( attributes.begin() );; ) {
                         output << (*attr)->name;
                         if ( ! (*attr)->parameters.empty() ) {

src/CodeGen/CodeGenerator.h ¶

@@ -118 +118 @@
                 void postvisit( ImplicitCtorDtorStmt * );
 
-                void genAttributes( std::list< Attribute * > & attributes );
+                void genAttributes( std::vector< Attribute * > & attributes );
 
                 template< class Iterator > void genCommaList( Iterator begin, Iterator end );

src/ControlStruct/ExceptTranslate.cc ¶

@@ -167 +167 @@
                         new BasicType( noQualifiers, BasicType::Bool ),
                         /*init*/ NULL,
-                        std::list<Attribute *>{ new Attribute( "unused" ) }
+                        std::vector< Attribute * >{ new Attribute( "unused" ) }
                         );
                 ObjectDecl voidptr_obj(
@@ -179 +179 @@
                                         noQualifiers
                                         ),
-                                std::list<Attribute *>{ new Attribute( "unused" ) }
+                                std::vector< Attribute * >{ new Attribute( "unused" ) }
                                 ),
                         NULL
@@ -491 +491 @@
                 // __cfaabi_ehm__try_resume_setup( &__resume_node, resume_handler );
 
-                std::list< Attribute * > attributes;
+                std::vector< Attribute * > attributes;
                 {
                         std::list< Expression * > attr_params;
@@ -543 +543 @@
 
                 // Make Cleanup Attribute.
-                std::list< Attribute * > attributes;
+                std::vector< Attribute * > attributes;
                 {
                         std::list< Expression * > attr_params;

src/GenPoly/Box.cc ¶

@@ -298 +298 @@
                                                                                                          functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static ),
                                                                                                          LinkageSpec::AutoGen, layoutFnType, new CompoundStmt(),
-                                                                                                         std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
+                                                                                                         std::vector< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
                 layoutDecl->fixUniqueId();
                 return layoutDecl;
@@ -1485 +1485 @@
                         Attribute * aligned = new Attribute( "aligned", std::list<Expression*>{ new ConstantExpr( Constant::from_int(8) ) } );
                         return new ArrayType( Type::Qualifiers(), charType, size,
-                                true, false, std::list<Attribute *>{ aligned } );
+                                true, false, std::vector< Attribute * >{ aligned } );
                 }
 
@@ -1764 +1764 @@
 
                 Expression *PolyGenericCalculator::postmutate( SizeofExpr *sizeofExpr ) {
-                        Type *ty = sizeofExpr->get_isType() ? 
+                        Type *ty = sizeofExpr->get_isType() ?
                                 sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
-                        
+
                         Expression * gen = genSizeof( ty );
                         if ( gen ) {

src/InitTweak/FixInit.cc ¶

@@ -824 +824 @@
                                                         // create a new object which is never used
                                                         static UniqueName dummyNamer( "_dummy" );
-                                                        ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
+                                                        ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::vector< Attribute * >{ new Attribute("unused") } );
                                                         delete ctorInit;
                                                         return dummy;

src/InitTweak/InitTweak.cc ¶

@@ -229 +229 @@
 
                                 static UniqueName targetLabel( "L__autogen__" );
-                                Label switchLabel( targetLabel.newName(), 0, std::list< Attribute * >{ new Attribute("unused") } );
+                                Label switchLabel( targetLabel.newName(), 0, std::vector< Attribute * >{ new Attribute("unused") } );
                                 for ( Initializer * init : *listInit ) {
                                         Expression * condition;

src/Parser/DeclarationNode.cc ¶

@@ -509 +509 @@
 
         for ( Attribute *attr: reverseIterate( q->attributes ) ) {
-                attributes.push_front( attr->clone() );
+                attributes.insert(attributes.begin(), attr->clone() );
         } // for
         return this;
@@ -770 +770 @@
         if ( a ) {
                 for ( Attribute *attr: reverseIterate( a->attributes ) ) {
-                        attributes.push_front( attr );
+                        attributes.insert( attributes.begin(), attr );
                 } // for
                 a->attributes.clear();

src/Parser/ParseNode.h ¶

@@ -344 +344 @@
         LinkageSpec::Spec linkage;
         Expression * asmName = nullptr;
-        std::list< Attribute * > attributes;
+        std::vector< Attribute * > attributes;
         InitializerNode * initializer = nullptr;
         bool extension = false;
@@ -374 +374 @@
 
         virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
-                stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::list< Attribute * > {} );
+                stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::vector< Attribute * > {} );
                 delete attr;
                 delete name;

src/Parser/TypeData.cc ¶

@@ -760 +760 @@
 
 
-AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
+AggregateDecl * buildAggregate( const TypeData * td, std::vector< Attribute * > attributes, LinkageSpec::Spec linkage ) {
         assert( td->kind == TypeData::Aggregate );
         AggregateDecl * at;
@@ -790 +790 @@
 
 
-ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
+ReferenceToType * buildComAggInst( const TypeData * type, std::vector< Attribute * > attributes, LinkageSpec::Spec linkage ) {
         switch ( type->kind ) {
           case TypeData::Enum: {
@@ -850 +850 @@
         assert( td->kind == TypeData::AggregateInst );
 
-        // ReferenceToType * ret = buildComAggInst( td->aggInst.aggregate, std::list< Attribute * >() );
+        // ReferenceToType * ret = buildComAggInst( td->aggInst.aggregate, std::vector< Attribute * >() );
         ReferenceToType * ret = nullptr;
         TypeData * type = td->aggInst.aggregate;
@@ -887 +887 @@
 
 
-NamedTypeDecl * buildSymbolic( const TypeData * td, std::list< Attribute * > attributes, const string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ) {
+NamedTypeDecl * buildSymbolic( const TypeData * td, std::vector< Attribute * > attributes, const string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ) {
         assert( td->kind == TypeData::Symbolic );
         NamedTypeDecl * ret;
@@ -898 +898 @@
         buildList( td->symbolic.params, ret->get_parameters() );
         buildList( td->symbolic.assertions, ret->get_assertions() );
-        ret->base->attributes.splice( ret->base->attributes.end(), attributes );
+        ret->base->attributes.insert( ret->base->attributes.end(), attributes.begin(), attributes.end() );
         return ret;
 } // buildSymbolic
 
 
-EnumDecl * buildEnum( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
+EnumDecl * buildEnum( const TypeData * td, std::vector< Attribute * > attributes, LinkageSpec::Spec linkage ) {
         assert( td->kind == TypeData::Enum );
         EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, linkage );
@@ -947 +947 @@
 
 
-Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, Expression *asmName, Initializer * init, std::list< Attribute * > attributes ) {
+Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, Expression *asmName, Initializer * init, std::vector< Attribute * > attributes ) {
         if ( td->kind == TypeData::Function ) {
                 if ( td->function.idList ) {                                    // KR function ?
@@ -1020 +1020 @@
                                 param->type = decl->type;                               // set copy declaration type to parameter type
                                 decl->type = nullptr;                                   // reset declaration type
-                                param->attributes.splice( param->attributes.end(), decl->attributes ); // copy and reset attributes from declaration to parameter
+                                param->attributes.insert( param->attributes.end(), decl->attributes.begin(), decl->attributes.end() ); // copy and reset attributes from declaration to parameter
                         } // if
                 } // for

src/Parser/TypeData.h ¶

@@ -19 +19 @@
 #include <list>                  // for list
 #include <string>                // for string
+#include <vector>
 
 #include "ParseNode.h"           // for DeclarationNode, DeclarationNode::Ag...
@@ -120 +121 @@
 ArrayType * buildArray( const TypeData * );
 ReferenceType * buildReference( const TypeData * );
-AggregateDecl * buildAggregate( const TypeData *, std::list< Attribute * > );
-ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes, LinkageSpec::Spec linkage );
+AggregateDecl * buildAggregate( const TypeData *, std::vector< Attribute * > );
+ReferenceToType * buildComAggInst( const TypeData *, std::vector< Attribute * > attributes, LinkageSpec::Spec linkage );
 ReferenceToType * buildAggInst( const TypeData * );
 TypeDecl * buildVariable( const TypeData * );
-EnumDecl * buildEnum( const TypeData *, std::list< Attribute * >, LinkageSpec::Spec );
+EnumDecl * buildEnum( const TypeData *, std::vector< Attribute * >, LinkageSpec::Spec );
 TypeInstType * buildSymbolicInst( const TypeData * );
 TupleType * buildTuple( const TypeData * );
 TypeofType * buildTypeof( const TypeData * );
 Declaration * buildDecl( const TypeData *, const std::string &, Type::StorageClasses, Expression *, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec, Expression * asmName,
-                                                 Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
+                                                 Initializer * init = nullptr, std::vector< Attribute * > attributes = std::vector< Attribute * >() );
 FunctionType * buildFunction( const TypeData * );
 void buildKRFunction( const TypeData::Function_t & function );

src/SymTab/Autogen.cc ¶

@@ -264 +264 @@
                 LinkageSpec::Spec spec = isIntrinsic ? LinkageSpec::Intrinsic : LinkageSpec::AutoGen;
                 FunctionDecl * decl = new FunctionDecl( fname, scs, spec, ftype, new CompoundStmt(),
-                                                                                                std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
+                                                                                                std::vector< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
                 decl->fixUniqueId();
                 return decl;
@@ -692 +692 @@
                                         TypeInstType * inst = new TypeInstType( Type::Qualifiers(), newDecl->get_name(), newDecl );
                                         newDecl->get_assertions().push_back( new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Cforall, genAssignType( inst ), nullptr,
-                                                                                                                                                   std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
+                                                                                                                                                   std::vector< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
                                         newDecl->get_assertions().push_back( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr,
-                                                                                                                                                   std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
+                                                                                                                                                   std::vector< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
                                         newDecl->get_assertions().push_back( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, genCopyType( inst ), nullptr,
-                                                                                                                                                   std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
+                                                                                                                                                   std::vector< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
                                         newDecl->get_assertions().push_back( new FunctionDecl( "^?{}", Type::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr,
-                                                                                                                                                   std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
+                                                                                                                                                   std::vector< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
                                         typeParams.push_back( newDecl );
                                         done.insert( ty->get_baseType() );

src/SymTab/Validate.cc ¶

@@ -912 +912 @@
                         // attributes are not carried over from typedef to function parameters/return values
                         if ( ! inFunctionType ) {
-                                ret->attributes.splice( ret->attributes.end(), typeInst->attributes );
+                                ret->attributes.insert( ret->attributes.end(), typeInst->attributes.begin(), typeInst->attributes.end() );
                         } else {
                                 deleteAll( ret->attributes );

src/SynTree/AggregateDecl.cc ¶

@@ -25 +25 @@
 
 
-AggregateDecl::AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, Type::StorageClasses(), linkage ), body( false ), attributes( attributes ) {
+AggregateDecl::AggregateDecl( const std::string &name, const std::vector< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, Type::StorageClasses(), linkage ), body( false ), attributes( attributes ) {
 }
 

src/SynTree/ArrayType.cc ¶

@@ -24 +24 @@
 
 
-ArrayType::ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes )
+ArrayType::ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::vector< Attribute * > & attributes )
         : Type( tq, attributes ), base( base ), dimension( dimension ), isVarLen( isVarLen ), isStatic( isStatic ) {
         base->set_lvalue( false );

src/SynTree/AttrType.cc ¶

@@ -25 +25 @@
 
 
-AttrType::AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr, const std::list< Attribute * > & attributes )
+AttrType::AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr, const std::vector< Attribute * > & attributes )
         : Type( tq, attributes ), name( name ), expr( expr ), type( 0 ), isType( false ) {
 }
 
-AttrType::AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type, const std::list< Attribute * > & attributes )
+AttrType::AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type, const std::vector< Attribute * > & attributes )
         : Type( tq, attributes ), name( name ), expr( 0 ), type( type ), isType( true ) {
 }

src/SynTree/Attribute.h ¶

@@ -19 +19 @@
 #include <list>    // for list
 #include <string>  // for string, operator==
+#include <vector>
 
 #include "BaseSyntaxNode.h"
@@ -54 +55 @@
 };
 
-const std::list< Attribute * > noAttributes;
+const std::vector< Attribute * > noAttributes;
 
 // Local Variables: //

src/SynTree/BasicType.cc ¶

@@ -22 +22 @@
 class Attribute;
 
-BasicType::BasicType( const Type::Qualifiers &tq, Kind bt, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), kind( bt ) {}
+BasicType::BasicType( const Type::Qualifiers &tq, Kind bt, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ), kind( bt ) {}
 
 void BasicType::print( std::ostream &os, Indenter indent ) const {

src/SynTree/Declaration.h ¶

@@ -20 +20 @@
 #include <list>                  // for list
 #include <string>                // for string, operator+, allocator, to_string
+#include <vector>
 
 #include "BaseSyntaxNode.h"      // for BaseSyntaxNode
@@ -83 +84 @@
 
         Expression *asmName;
-        std::list< Attribute * > attributes;
+        std::vector< Attribute * > attributes;
         bool isDeleted = false;
 
-        DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
+        DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::vector< Attribute * > & attributes, Type::FuncSpecifiers fs );
         DeclarationWithType( const DeclarationWithType &other );
         virtual ~DeclarationWithType();
@@ -101 +102 @@
         DeclarationWithType * set_asmName( Expression *newValue ) { asmName = newValue; return this; }
 
-        std::list< Attribute * >& get_attributes() { return attributes; }
-        const std::list< Attribute * >& get_attributes() const { return attributes; }
+        std::vector< Attribute * >& get_attributes() { return attributes; }
+        const std::vector< Attribute * >& get_attributes() const { return attributes; }
 
         Type::FuncSpecifiers get_funcSpec() const { return fs; }
@@ -125 +126 @@
 
         ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init,
-                                const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
+                                const std::vector< Attribute * > attributes = std::vector< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
         ObjectDecl( const ObjectDecl &other );
         virtual ~ObjectDecl();
@@ -155 +156 @@
 
         FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements,
-                                  const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
+                                  const std::vector< Attribute * > attributes = std::vector< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
         FunctionDecl( const FunctionDecl &other );
         virtual ~FunctionDecl();
@@ -265 +266 @@
         std::list<TypeDecl*> parameters;
         bool body;
-        std::list< Attribute * > attributes;
+        std::vector< Attribute * > attributes;
         AggregateDecl * parent = nullptr;
 
-        AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
+        AggregateDecl( const std::string &name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
         AggregateDecl( const AggregateDecl &other );
         virtual ~AggregateDecl();
@@ -275 +276 @@
         std::list<TypeDecl*>& get_parameters() { return parameters; }
 
-        std::list< Attribute * >& get_attributes() { return attributes; }
-        const std::list< Attribute * >& get_attributes() const { return attributes; }
+        std::vector< Attribute * >& get_attributes() { return attributes; }
+        const std::vector< Attribute * >& get_attributes() const { return attributes; }
 
         bool has_body() const { return body; }
@@ -290 +291 @@
         typedef AggregateDecl Parent;
   public:
-        StructDecl( const std::string &name, DeclarationNode::Aggregate kind = DeclarationNode::Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ) {}
+        StructDecl( const std::string &name, DeclarationNode::Aggregate kind = DeclarationNode::Struct, const std::vector< Attribute * > & attributes = std::vector< Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ) {}
         StructDecl( const StructDecl &other ) : Parent( other ), kind( other.kind ) {}
 
@@ -308 +309 @@
         typedef AggregateDecl Parent;
   public:
-        UnionDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
+        UnionDecl( const std::string &name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
         UnionDecl( const UnionDecl &other ) : Parent( other ) {}
 
@@ -321 +322 @@
         typedef AggregateDecl Parent;
   public:
-        EnumDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
+        EnumDecl( const std::string &name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
         EnumDecl( const EnumDecl &other ) : Parent( other ) {}
 
@@ -337 +338 @@
         typedef AggregateDecl Parent;
   public:
-        TraitDecl( const std::string &name, const std::list< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, attributes, linkage ) {
+        TraitDecl( const std::string &name, const std::vector< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, attributes, linkage ) {
                 assertf( attributes.empty(), "attribute unsupported for traits" );
         }

src/SynTree/DeclarationWithType.cc ¶

@@ -24 +24 @@
 #include "Type.h"                // for Type, Type::FuncSpecifiers, Type::St...
 
-DeclarationWithType::DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs )
+DeclarationWithType::DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::vector< Attribute * > & attributes, Type::FuncSpecifiers fs )
         : Declaration( name, scs, linkage ), asmName( nullptr ), attributes( attributes ), fs( fs ) {
 }

src/SynTree/FunctionDecl.cc ¶

@@ -30 +30 @@
 extern bool translation_unit_nomain;
 
-FunctionDecl::FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, std::list< Attribute * > attributes, Type::FuncSpecifiers fs )
+FunctionDecl::FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, std::vector< Attribute * > attributes, Type::FuncSpecifiers fs )
         : Parent( name, scs, linkage, attributes, fs ), type( type ), statements( statements ) {
         // hack forcing the function "main" to have Cforall linkage to replace main even if it is inside an extern

src/SynTree/FunctionType.cc ¶

@@ -25 +25 @@
 class Attribute;
 
-FunctionType::FunctionType( const Type::Qualifiers &tq, bool isVarArgs, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), isVarArgs( isVarArgs ) {
+FunctionType::FunctionType( const Type::Qualifiers &tq, bool isVarArgs, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ), isVarArgs( isVarArgs ) {
 }
 

src/SynTree/Label.h ¶

@@ -19 +19 @@
 #include <list>
 #include <iostream>
+#include <vector>
 #include "SynTree.h"
 
 class Label {
   public:
-        Label( const std::string & name = "", Statement * labelled = 0, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : name( name ), labelled( labelled ), attributes( attributes ) {}
+        Label( const std::string & name = "", Statement * labelled = 0, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() ) : name( name ), labelled( labelled ), attributes( attributes ) {}
         Label( const char * name, Statement * labelled = 0 ) : name( name ), labelled( labelled ) {}
 
@@ -31 +32 @@
         Statement * get_statement() const { return labelled; }
         void set_statement( Statement * newValue ) { labelled = newValue; }
-        std::list< Attribute * >& get_attributes() { return attributes; }
+        std::vector< Attribute * >& get_attributes() { return attributes; }
 
         operator std::string() const { return name; }
@@ -38 +39 @@
         std::string name;
         Statement * labelled;
-        std::list< Attribute * > attributes;
+        std::vector< Attribute * > attributes;
 };
 

src/SynTree/ObjectDecl.cc ¶

@@ -26 +26 @@
 #include "Type.h"                // for Type, Type::StorageClasses, Type::Fu...
 
-ObjectDecl::ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes, Type::FuncSpecifiers fs )
+ObjectDecl::ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::vector< Attribute * > attributes, Type::FuncSpecifiers fs )
         : Parent( name, scs, linkage, attributes, fs ), type( type ), init( init ), bitfieldWidth( bitfieldWidth ) {
 }

src/SynTree/PointerType.cc ¶

@@ -23 +23 @@
 class Attribute;
 
-PointerType::PointerType( const Type::Qualifiers &tq, Type *base, const std::list< Attribute * > & attributes )
+PointerType::PointerType( const Type::Qualifiers &tq, Type *base, const std::vector< Attribute * > & attributes )
         : Type( tq, attributes ), base( base ), dimension( 0 ), isVarLen( false ), isStatic( false ) {
 }
 
-PointerType::PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes )
+PointerType::PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::vector< Attribute * > & attributes )
         : Type( tq, attributes ), base( base ), dimension( dimension ), isVarLen( isVarLen ), isStatic( isStatic ) {
 }

src/SynTree/ReferenceToType.cc ¶

@@ -27 +27 @@
 class Attribute;
 
-ReferenceToType::ReferenceToType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), name( name ), hoistType( false ) {
+ReferenceToType::ReferenceToType( const Type::Qualifiers &tq, const std::string &name, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ), name( name ), hoistType( false ) {
 }
 
@@ -59 +59 @@
 } // namespace
 
-StructInstType::StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes ) :
+StructInstType::StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::vector< Attribute * > & attributes ) :
                 Parent( tq, baseStruct->name, attributes ), baseStruct( baseStruct ) {}
 
@@ -102 +102 @@
 
 
-UnionInstType::UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes ) :
+UnionInstType::UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::vector< Attribute * > & attributes ) :
                 Parent( tq, baseUnion->name, attributes ), baseUnion( baseUnion ) {}
 
@@ -145 +145 @@
 
 
-EnumInstType::EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes ) :
+EnumInstType::EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::vector< Attribute * > & attributes ) :
                 Parent( tq, baseEnum->get_name(), attributes ), baseEnum( baseEnum ) {}
 
@@ -167 +167 @@
 std::string TraitInstType::typeString() const { return "trait"; }
 
-TraitInstType::TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes ) : Parent( tq, baseTrait->name, attributes ), baseTrait( baseTrait ) {}
+TraitInstType::TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::vector< Attribute * > & attributes ) : Parent( tq, baseTrait->name, attributes ), baseTrait( baseTrait ) {}
 
 TraitInstType::TraitInstType( const TraitInstType &other ) : Parent( other ), baseTrait( other.baseTrait ) {
@@ -177 +177 @@
 bool TraitInstType::isComplete() const { assert( false ); }
 
-TypeInstType::TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType, const std::list< Attribute * > & attributes ) : Parent( tq, name, attributes ) {
+TypeInstType::TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType, const std::vector< Attribute * > & attributes ) : Parent( tq, name, attributes ) {
         set_baseType( baseType );
 }
 
-TypeInstType::TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype, const std::list< Attribute * > & attributes ) : Parent( tq, name, attributes ), baseType( 0 ), isFtype( isFtype ) {
+TypeInstType::TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype, const std::vector< Attribute * > & attributes ) : Parent( tq, name, attributes ), baseType( 0 ), isFtype( isFtype ) {
 }
 

src/SynTree/ReferenceType.cc ¶

@@ -19 +19 @@
 #include "Common/utility.h"
 
-ReferenceType::ReferenceType( const Type::Qualifiers &tq, Type *base, const std::list< Attribute * > & attributes )
+ReferenceType::ReferenceType( const Type::Qualifiers &tq, Type *base, const std::vector< Attribute * > & attributes )
         : Type( tq, attributes ), base( base ) {
         assertf( base, "Reference Type with a null base created." );

src/SynTree/TupleType.cc ¶

@@ -25 +25 @@
 class Attribute;
 
-TupleType::TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), types( types ) {
+TupleType::TupleType( const Type::Qualifiers &tq, const std::list< 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

src/SynTree/Type.cc ¶

@@ -56 +56 @@
 );
 
-Type::Type( const Qualifiers &tq, const std::list< Attribute * > & attributes ) : tq( tq ), attributes( attributes ) {}
+Type::Type( const Qualifiers &tq, const std::vector< Attribute * > & attributes ) : tq( tq ), attributes( attributes ) {}
 
 Type::Type( const Type &other ) : BaseSyntaxNode( other ), tq( other.tq ) {

src/SynTree/Type.h ¶

@@ -21 +21 @@
 #include <ostream>           // for ostream, operator<<, basic_ostream
 #include <string>            // for string
+#include <vector>
 
 #include "BaseSyntaxNode.h"  // for BaseSyntaxNode
@@ -137 +138 @@
         Qualifiers tq;
         ForallList forall;
-        std::list< Attribute * > attributes;
-
-        Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
+        std::vector< Attribute * > attributes;
+
+        Type( const Qualifiers & tq, const std::vector< Attribute * > & attributes );
         Type( const Type & other );
         virtual ~Type();
@@ -159 +160 @@
         ForallList& get_forall() { return forall; }
 
-        std::list< Attribute * >& get_attributes() { return attributes; }
-        const std::list< Attribute * >& get_attributes() const { return attributes; }
+        std::vector< Attribute * >& get_attributes() { return attributes; }
+        const std::vector< Attribute * >& get_attributes() const { return attributes; }
 
         /// How many elemental types are represented by this type
@@ -194 +195 @@
 class VoidType : public Type {
   public:
-        VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        VoidType( const Type::Qualifiers & tq, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
 
         virtual unsigned size() const override { return 0; };
@@ -238 +239 @@
         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
 
-        BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        BasicType( const Type::Qualifiers & tq, Kind bt, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
 
         Kind get_kind() { return kind; }
@@ -260 +261 @@
         bool isStatic;
 
-        PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
-        PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        PointerType( const Type::Qualifiers & tq, Type *base, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
+        PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
         PointerType( const PointerType& );
         virtual ~PointerType();
@@ -291 +292 @@
         bool isStatic;
 
-        ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
         ArrayType( const ArrayType& );
         virtual ~ArrayType();
@@ -334 +335 @@
         Type *base;
 
-        ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        ReferenceType( const Type::Qualifiers & tq, Type *base, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
         ReferenceType( const ReferenceType & );
         virtual ~ReferenceType();
@@ -367 +368 @@
         bool isVarArgs;
 
-        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
         FunctionType( const FunctionType& );
         virtual ~FunctionType();
@@ -391 +392 @@
         bool hoistType;
 
-        ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
+        ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::vector< Attribute * > & attributes );
         ReferenceToType( const ReferenceToType & other );
         virtual ~ReferenceToType();
@@ -418 +419 @@
         StructDecl *baseStruct;
 
-        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
-        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
+        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
         StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
 
@@ -455 +456 @@
         UnionDecl *baseUnion;
 
-        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
-        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
+        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
         UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
 
@@ -492 +493 @@
         EnumDecl *baseEnum = nullptr;
 
-        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
-        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  ) : Parent( tq, name, attributes ) {}
+        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
         EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
 
@@ -519 +520 @@
         TraitDecl * baseTrait = nullptr;
 
-        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
-        TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() ) : Parent( tq, name, attributes ) {}
+        TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
         TraitInstType( const TraitInstType & other );
         ~TraitInstType();
@@ -541 +542 @@
         bool isFtype;
 
-        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
-        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
+        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
         TypeInstType( const TypeInstType & other );
         ~TypeInstType();
@@ -566 +567 @@
         std::list<Declaration *> members;
 
-        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
         TupleType( const TupleType& );
         virtual ~TupleType();
@@ -601 +602 @@
         bool is_basetypeof;  ///< true iff is basetypeof type
 
-        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
-        TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof, 
-                const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
+        TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof,
+                const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
         TypeofType( const TypeofType& );
         virtual ~TypeofType();
@@ -625 +626 @@
         bool isType;
 
-        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
-        AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
+        AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
         AttrType( const AttrType& );
         virtual ~AttrType();
@@ -651 +652 @@
   public:
         VarArgsType();
-        VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        VarArgsType( Type::Qualifiers tq, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
 
         virtual bool isComplete() const override{ return true; } // xxx - is this right?
@@ -665 +666 @@
   public:
         ZeroType();
-        ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        ZeroType( Type::Qualifiers tq, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
 
         virtual ZeroType *clone() const override { return new ZeroType( *this ); }
@@ -677 +678 @@
   public:
         OneType();
-        OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        OneType( Type::Qualifiers tq, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
 
         virtual OneType *clone() const override { return new OneType( *this ); }

src/SynTree/TypeofType.cc ¶

@@ -23 +23 @@
 class Attribute;
 
-TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, 
-        const std::list< Attribute * > & attributes ) 
+TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr,
+        const std::vector< Attribute * > & attributes )
 : Type( tq, attributes ), expr( expr ), is_basetypeof(false) {}
 
-TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, bool is_basetypeof, 
-        const std::list< Attribute * > & attributes ) 
+TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, bool is_basetypeof,
+        const std::vector< Attribute * > & attributes )
 : Type( tq, attributes ), expr( expr ), is_basetypeof( is_basetypeof ) {}
 

src/SynTree/VarArgsType.cc ¶

@@ -21 +21 @@
 class Attribute;
 
-VarArgsType::VarArgsType() : Type( Type::Qualifiers(), std::list< Attribute * >() ) {}
+VarArgsType::VarArgsType() : Type( Type::Qualifiers(), std::vector< Attribute * >() ) {}
 
-VarArgsType::VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
+VarArgsType::VarArgsType( Type::Qualifiers tq, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ) {}
 
 void VarArgsType::print( std::ostream &os, Indenter indent ) const {

src/SynTree/VoidType.cc ¶

@@ -21 +21 @@
 class Attribute;
 
-VoidType::VoidType( const Type::Qualifiers &tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {
+VoidType::VoidType( const Type::Qualifiers &tq, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ) {
 }
 

src/SynTree/ZeroOneType.cc ¶

@@ -21 +21 @@
 class Attribute;
 
-ZeroType::ZeroType() : Type( Type::Qualifiers(), std::list< Attribute * >() ) {}
+ZeroType::ZeroType() : Type( Type::Qualifiers(), std::vector< Attribute * >() ) {}
 
-ZeroType::ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
+ZeroType::ZeroType( Type::Qualifiers tq, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ) {}
 
 void ZeroType::print( std::ostream &os, Indenter ) const {
@@ -29 +29 @@
 }
 
-OneType::OneType() : Type( Type::Qualifiers(), std::list< Attribute * >() ) {}
+OneType::OneType() : Type( Type::Qualifiers(), std::vector< Attribute * >() ) {}
 
-OneType::OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
+OneType::OneType( Type::Qualifiers tq, const std::vector< Attribute * > & attributes ) : Type( tq, attributes ) {}
 
 void OneType::print( std::ostream &os, Indenter ) const {