Changeset 857b5f9 for src/AST

Timestamp:

Jan 23, 2025, 12:09:40 PM (3 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

9e72bae3

Parents:

829821c

Message:

CountExpr? -> CountofExpr?. Actually the main fix was making countof use the same pattern as sizeof/alignof, using a typeof to combine the two cases and have one field instead of two.

Location:

src/AST

Files:

• Expr.cpp (modified) (1 diff)
• Expr.hpp (modified) (2 diffs)
• Fwd.hpp (modified) (1 diff)
• Pass.hpp (modified) (1 diff)
• Pass.impl.hpp (modified) (2 diffs)
• Print.cpp (modified) (1 diff)
• Visitor.hpp (modified) (1 diff)

src/AST/Expr.cpp ¶

@@ -283 +283 @@
 : Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), type( t ) {}
 
-// --- CountExpr
-
-CountExpr::CountExpr( const CodeLocation & loc, const Expr * e )
-: Expr( loc, new BasicType( BasicKind::LongUnsignedInt) ), expr(e), type( nullptr ) {}
-
-CountExpr::CountExpr( const CodeLocation & loc, const Type * t )
-: Expr( loc, new BasicType( BasicKind::LongUnsignedInt) ), expr(nullptr), type( t ) {}
-
 // --- AlignofExpr
 
 AlignofExpr::AlignofExpr( const CodeLocation & loc, const Type * t )
 : Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), type( t ) {}
+
+// --- CountofExpr
+
+CountofExpr::CountofExpr( const CodeLocation & loc, const Type * t )
+: Expr( loc, new BasicType( BasicKind::LongUnsignedInt) ), type( t ) {}
 
 // --- OffsetofExpr

src/AST/Expr.hpp ¶

@@ -490 +490 @@
 };
 
-class CountExpr final : public Expr {
-public:
-        ptr<Expr> expr;
-        ptr<Type> type;
-
-        CountExpr( const CodeLocation & loc, const Expr * t );
-        CountExpr( const CodeLocation & loc, const Type * t );
-
-        const Expr * accept( Visitor & v )const override { return v.visit( this ); }
-private:
-        CountExpr * clone() const override { return new CountExpr( *this ); }
-        MUTATE_FRIEND
-};
-
 /// alignof expression, e.g. `alignof(int)`, `alignof 3+4`
 class AlignofExpr final : public Expr {
@@ -514 +500 @@
 private:
         AlignofExpr * clone() const override { return new AlignofExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// countof expression, e.g. `countof(AnEnum)`, `countof pred(Head)`
+class CountofExpr final : public Expr {
+public:
+        ptr<Type> type;
+
+        CountofExpr( const CodeLocation & loc, const Type * t );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        CountofExpr * clone() const override { return new CountofExpr( *this ); }
         MUTATE_FRIEND
 };

src/AST/Fwd.hpp ¶

@@ -86 +86 @@
 class ConstantExpr;
 class SizeofExpr;
-class CountExpr;
 class AlignofExpr;
+class CountofExpr;
 class UntypedOffsetofExpr;
 class OffsetofExpr;

src/AST/Pass.hpp ¶

@@ -173 +173 @@
         const ast::Expr *             visit( const ast::ConstantExpr         * ) override final;
         const ast::Expr *             visit( const ast::SizeofExpr           * ) override final;
-        const ast::Expr *             visit( const ast::CountExpr            * ) override final;
         const ast::Expr *             visit( const ast::AlignofExpr          * ) override final;
+        const ast::Expr *             visit( const ast::CountofExpr          * ) override final;
         const ast::Expr *             visit( const ast::UntypedOffsetofExpr  * ) override final;
         const ast::Expr *             visit( const ast::OffsetofExpr         * ) override final;

src/AST/Pass.impl.hpp ¶

@@ -1350 +1350 @@
 
 //--------------------------------------------------------------------------
-// CountExpr
-template< typename core_t >
-const ast::Expr * ast::Pass< core_t >::visit( const ast::CountExpr * node ) {
-        VISIT_START( node );
-        if ( __visit_children() ) {
-                {
-                        guard_symtab guard { *this };
-                        maybe_accept( node, &CountExpr::result );
-                }
-                if ( node->type ) {
-                        maybe_accept( node, &CountExpr::type );
-                } else {
-                        maybe_accept( node, &CountExpr::expr );
-                }
-        }
-        VISIT_END( Expr, node );
-}
-
-//--------------------------------------------------------------------------
 // AlignofExpr
 template< typename core_t >
@@ -1380 +1361 @@
                 }
                 maybe_accept( node, &AlignofExpr::type );
+        }
+
+        VISIT_END( Expr, node );
+}
+
+//--------------------------------------------------------------------------
+// CountofExpr
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::CountofExpr * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                {
+                        guard_symtab guard { *this };
+                        maybe_accept( node, &CountofExpr::result );
+                }
+                maybe_accept( node, &CountofExpr::type );
         }
 

src/AST/Print.cpp ¶

@@ -1207 +1207 @@
         }
 
-        virtual const ast::Expr * visit( const ast::CountExpr * node ) override final {
+        virtual const ast::Expr * visit( const ast::CountofExpr * node ) override final {
                 os << "Count Expression on: ";
                 ++indent;
-                if ( node->type ) node->type->accept( *this );
-                else safe_print( node->expr );
+                safe_print( node->type );
                 --indent;
                 postprint( node );

src/AST/Visitor.hpp ¶

@@ -76 +76 @@
     virtual const ast::Expr *             visit( const ast::ConstantExpr         * ) = 0;
     virtual const ast::Expr *             visit( const ast::SizeofExpr           * ) = 0;
-    virtual const ast::Expr *             visit( const ast::CountExpr            * ) = 0;
     virtual const ast::Expr *             visit( const ast::AlignofExpr          * ) = 0;
+    virtual const ast::Expr *             visit( const ast::CountofExpr          * ) = 0;
     virtual const ast::Expr *             visit( const ast::UntypedOffsetofExpr  * ) = 0;
     virtual const ast::Expr *             visit( const ast::OffsetofExpr         * ) = 0;