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; }