Changeset 3e91c6f9 for src

Timestamp:

Mar 13, 2025, 9:26:17 AM (2 weeks ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

8b639f9

Parents:

3bd9508 (diff), 594671a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

fix pull conflicit

Location:

src

Files:

• BasicTypes-gen.cpp (modified) (1 diff)
• Common/Iterate.hpp (modified) (1 diff)
• GenPoly/InstantiateGeneric.cpp (modified) (7 diffs)
• Parser/lex.ll (modified) (3 diffs)
• Parser/parser.yy (modified) (2 diffs)

src/BasicTypes-gen.cpp ¶

@@ -53 +53 @@
         Float128xComplex,
         NUMBER_OF_BASIC_TYPES,
-
-        Float32x4,                                                                                      // ARM, gcc-14
-        Float64x2,
-        Svfloat32,
-        Svfloat64,
-        Svbool,
 };
 

src/Common/Iterate.hpp ¶

@@ -208 +208 @@
         return group_iterate_t<Args...>( std::forward<Args>( 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<Func> f;
-
-        struct iterator {
-                typedef decltype(begin(ref)) Iter;
-                Iter it;
-                std::function<Func> f;
-                iterator( Iter it, std::function<Func> 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<Func> 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<Args...> lazy_map( const Args &... args ) {
-        return lambda_iterate_t<Args...>( args...);
-}
-
-// Local Variables: //
-// tab-width: 4 //
-// mode: c++ //
-// compile-command: "make install" //
-// End: //

src/GenPoly/InstantiateGeneric.cpp ¶

@@ -10 +10 @@
 // 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 +159 @@
 }
 
+/// 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 +210 @@
                                 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 +448 @@
                 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 +489 @@
 
         template<typename AggrDecl>
+        AggrDecl const * fixAggrDecl( AggrDecl const * decl );
+
+        template<typename AggrDecl>
         ast::Type const * fixInstType( ast::SueInstType<AggrDecl> const * inst );
 
@@ -489 +500 @@
                 ast::vector<ast::TypeExpr> 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<typename AggrDecl>
+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<ast::TypeExpr> 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 +571 @@
         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() );

src/Parser/lex.ll ¶

@@ -10 +10 @@
  * 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 +240 @@
 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 +287 @@
 _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

src/Parser/parser.yy ¶

@@ -10 +10 @@
 // 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 +2244 @@
         basic_type_specifier
         | sue_type_specifier
-        | type_type_specifier
+        | type_type_specifier attribute_list_opt
         ;