Index: src/BasicTypes-gen.cpp =================================================================== --- src/BasicTypes-gen.cpp (revision 3bd950881e1bba6bb9b6912c86686aaab822bf9a) +++ src/BasicTypes-gen.cpp (revision 3e91c6f91e5a3f8b46dfbdd035a898ca5dfe818f) @@ -53,10 +53,4 @@ Float128xComplex, NUMBER_OF_BASIC_TYPES, - - Float32x4, // ARM, gcc-14 - Float64x2, - Svfloat32, - Svfloat64, - Svbool, }; Index: src/Common/Iterate.hpp =================================================================== --- src/Common/Iterate.hpp (revision 3bd950881e1bba6bb9b6912c86686aaab822bf9a) +++ src/Common/Iterate.hpp (revision 3e91c6f91e5a3f8b46dfbdd035a898ca5dfe818f) @@ -208,42 +208,2 @@ return group_iterate_t( std::forward( args )... ); } - -// ----------------------------------------------------------------------------- -// Helper struct and function to support -// for ( val : lazy_map( container1, f ) ) {} -// syntax to have a for each that iterates a container, -// mapping each element by applying f. - -template< typename T, typename Func > -struct lambda_iterate_t { - const T & ref; - std::function f; - - struct iterator { - typedef decltype(begin(ref)) Iter; - Iter it; - std::function f; - iterator( Iter it, std::function f ) : it(it), f(f) {} - iterator & operator++() { - ++it; return *this; - } - bool operator!=( const iterator &other ) const { return it != other.it; } - auto operator*() const -> decltype(f(*it)) { return f(*it); } - }; - - lambda_iterate_t( const T & ref, std::function f ) : ref(ref), f(f) {} - - auto begin() const -> decltype(iterator(std::begin(ref), f)) { return iterator(std::begin(ref), f); } - auto end() const -> decltype(iterator(std::end(ref), f)) { return iterator(std::end(ref), f); } -}; - -template< typename... Args > -lambda_iterate_t lazy_map( const Args &... args ) { - return lambda_iterate_t( args...); -} - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/GenPoly/InstantiateGeneric.cpp =================================================================== --- src/GenPoly/InstantiateGeneric.cpp (revision 3bd950881e1bba6bb9b6912c86686aaab822bf9a) +++ src/GenPoly/InstantiateGeneric.cpp (revision 3e91c6f91e5a3f8b46dfbdd035a898ca5dfe818f) @@ -10,6 +10,6 @@ // Created On : Tue Aug 16 10:51:00 2022 // Last Modified By : Andrew Beach -// Last Modified On : Mon Oct 31 16:48:00 2022 -// Update Count : 1 +// Last Modified On : Wed Mar 12 15:18:00 2025 +// Update Count : 2 // @@ -159,4 +159,24 @@ } +/// Get the scrubbed type of a declaration (see scrubTypeVars functions). +ast::TypeExpr const * scrubTypeDecl( + CodeLocation const & location, ast::TypeDecl const * typeDecl ) { + switch ( typeDecl->kind ) { + // Erase any incomplete dtype to `void` (`T *` -> `void *`). + case ast::TypeDecl::Dtype: + return new ast::TypeExpr( location, new ast::VoidType() ); + // Erase any ftype to `void (*)(void)`. + case ast::TypeDecl::Ftype: + return new ast::TypeExpr( location, new ast::FunctionType() ); + // Remaining cases are not supported. + case ast::TypeDecl::Ttype: + assertf( false, "Ttype parameters are not currently allowed as parameters to generic types." ); + break; + default: + assertf( false, "Unhandled type parameter kind" ); + break; + } +} + /// Makes substitutions of params into baseParams; returns dtypeStatic if /// there is a concrete instantiation based only on {d,f}type-to-void @@ -190,21 +210,6 @@ gt |= GenericType::concrete; } - } else switch ( (*baseParam)->kind ) { - case ast::TypeDecl::Dtype: - // Here, pretend that any incomplete dtype is `void`. - out.emplace_back( new ast::TypeExpr( paramExpr->location, - new ast::VoidType() ) ); - break; - case ast::TypeDecl::Ftype: - // Here, pretend that any ftype is `void (*)(void)`. - out.emplace_back( new ast::TypeExpr( paramExpr->location, - new ast::FunctionType() ) ); - break; - case ast::TypeDecl::Ttype: - assertf( false, "Ttype parameters are not currently allowed as parameters to generic types." ); - break; - default: - assertf( false, "Unhandled type parameter kind" ); - break; + } else { + out.emplace_back( scrubTypeDecl( paramExpr->location, *baseParam ) ); } } @@ -443,4 +448,7 @@ instantiations(), dtypeStatics(), typeNamer("_conc_") {} + ast::StructDecl const * previsit( ast::StructDecl const * ); + ast::UnionDecl const * previsit( ast::UnionDecl const * ); + ast::Type const * postvisit( ast::StructInstType const * inst ); ast::Type const * postvisit( ast::UnionInstType const * inst ); @@ -481,4 +489,7 @@ template + AggrDecl const * fixAggrDecl( AggrDecl const * decl ); + + template ast::Type const * fixInstType( ast::SueInstType const * inst ); @@ -489,4 +500,33 @@ ast::vector const & typeSubs ); }; + +ast::StructDecl const * GenericInstantiator::previsit( ast::StructDecl const * decl ) { + return fixAggrDecl( decl ); +} + +ast::UnionDecl const * GenericInstantiator::previsit( ast::UnionDecl const * decl ) { + return fixAggrDecl( decl ); +} + +template +AggrDecl const * GenericInstantiator::fixAggrDecl( AggrDecl const * decl ) { + // This function and stripDtypeParams handle declarations before their + // first use (required to be in the previsit for types with a self use). + if ( decl->params.empty() || !isDtypeStatic( decl->params ) ) { + return decl; + } + + ast::vector typeSubs; + for ( auto const & param : decl->params ) { + assert( !param->isComplete() ); + typeSubs.emplace_back( scrubTypeDecl( param->location, param ) ); + } + + assert( decl->unique() ); + auto mutDecl = ast::mutate( decl ); + stripDtypeParams( mutDecl, mutDecl->params, typeSubs ); + + return mutDecl; +} ast::Type const * GenericInstantiator::postvisit( @@ -531,4 +571,6 @@ case GenericType::dtypeStatic: { + // This call to stripDtypeParams is used when a forward declaration + // has allowed an instance to appear before the full declaration. auto mutInst = ast::mutate( inst ); assert( mutInst->base->unique() ); Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision 3bd950881e1bba6bb9b6912c86686aaab822bf9a) +++ src/Parser/lex.ll (revision 3e91c6f91e5a3f8b46dfbdd035a898ca5dfe818f) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Fri Jan 17 14:36:16 2025 - * Update Count : 878 + * Last Modified On : Mon Mar 3 09:21:33 2025 + * Update Count : 880 */ @@ -240,5 +240,5 @@ basetypeof { KEYWORD_RETURN(BASETYPEOF); } // CFA _Bool { KEYWORD_RETURN(BOOL); } // C99 -__SVBool_t { KEYWORD_RETURN(SVBOOL); } // gcc (ARM) +__SVBool_t { KEYWORD_RETURN(BOOL); } // gcc (ARM) break { KEYWORD_RETURN(BREAK); } case { KEYWORD_RETURN(CASE); } @@ -287,8 +287,8 @@ _Float128 { FLOATXX(FLOAT128); } // GCC _Float128x { FLOATXX(FLOAT128X); } // GCC -__Float32x4_t { FLOATXX(FLOAT32X4); } // GCC (ARM) -__Float64x2_t { FLOATXX(FLOAT64X2); } // GCC (ARM) -__SVFloat32_t { FLOATXX(SVFLOAT32); } // GCC (ARM) -__SVFloat64_t { FLOATXX(SVFLOAT64); } // GCC (ARM) +__Float32x4_t { FLOATXX(FLOAT128); } // GCC (ARM) +__Float64x2_t { FLOATXX(FLOAT128); } // GCC (ARM) +__SVFloat32_t { FLOATXX(FLOAT128); } // GCC (ARM) +__SVFloat64_t { FLOATXX(FLOAT128); } // GCC (ARM) for { KEYWORD_RETURN(FOR); } forall { KEYWORD_RETURN(FORALL); } // CFA Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 3bd950881e1bba6bb9b6912c86686aaab822bf9a) +++ src/Parser/parser.yy (revision 3e91c6f91e5a3f8b46dfbdd035a898ca5dfe818f) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Mar 3 20:47:00 2025 -// Update Count : 7254 +// Last Modified On : Thu Mar 13 09:23:21 2025 +// Update Count : 7255 // @@ -2244,5 +2244,5 @@ basic_type_specifier | sue_type_specifier - | type_type_specifier + | type_type_specifier attribute_list_opt ;