Changeset fca78f1 for src/AST

Timestamp:

Sep 23, 2024, 11:14:56 AM (5 weeks ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

738a9b4

Parents:

b723b63

Message:

Added ForeachStmt? (felt better than ForEachStmt?). This new node is a bit optimistic in that currently it is covering a very narrow case, but with improvements to it and RangeExpr?, it could handle many more kind of loops.

Location:

src/AST

Files:

• Fwd.hpp (modified) (1 diff)
• Pass.hpp (modified) (1 diff)
• Pass.impl.hpp (modified) (1 diff)
• Print.cpp (modified) (1 diff)
• Stmt.hpp (modified) (3 diffs)
• Visitor.hpp (modified) (1 diff)

src/AST/Fwd.hpp

@@ -49 +49 @@
 class WhileDoStmt;
 class ForStmt;
+class ForeachStmt;
 class SwitchStmt;
 class CaseClause;

src/AST/Pass.hpp

@@ -138 +138 @@
         const ast::Stmt *             visit( const ast::WhileDoStmt          * ) override final;
         const ast::Stmt *             visit( const ast::ForStmt              * ) override final;
+        const ast::Stmt *             visit( const ast::ForeachStmt          * ) override final;
         const ast::Stmt *             visit( const ast::SwitchStmt           * ) override final;
         const ast::CaseClause *       visit( const ast::CaseClause           * ) override final;

src/AST/Pass.impl.hpp

@@ -803 +803 @@
                 maybe_accept_top( node, &ForStmt::cond  );
                 maybe_accept_top( node, &ForStmt::inc   );
-                maybe_accept_top( node, &ForStmt::range_over );
                 maybe_accept_as_compound( node, &ForStmt::body  );
                 maybe_accept_as_compound( node, &ForStmt::else_ );
+        }
+
+        VISIT_END( Stmt, node );
+}
+
+//--------------------------------------------------------------------------
+// ForeachStmt
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::ForeachStmt * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                // for statements introduce a level of scope (for the initialization)
+                guard_symtab guard { *this };
+                // xxx - old ast does not create WithStmtsToAdd scope for loop inits. should revisit this later.
+                maybe_accept( node, &ForeachStmt::inits );
+                maybe_accept_top( node, &ForeachStmt::range );
+                maybe_accept_as_compound( node, &ForeachStmt::body  );
+                maybe_accept_as_compound( node, &ForeachStmt::else_ );
         }
 

src/AST/Print.cpp

@@ -637 +637 @@
         }
 
+        virtual const ast::Stmt * visit( const ast::ForeachStmt * node ) override final {
+                os << "Range for Statement" << endl;
+
+                if ( ! node->inits.empty() ) {
+                        os << indent << "... initialization:" << endl;
+                        ++indent;
+                        for ( const ast::Stmt * stmt : node->inits ) {
+                                os << indent+1;
+                                safe_print( stmt );
+                        }
+                        --indent;
+                }
+
+                if ( node->isIncreasing ) {
+                        os << indent << "increasing" << endl;
+                } else {
+                        os << indent << "decreasing" << endl;
+                }
+
+                if ( !node->range ) {
+                        os << indent << "... over range:" << endl;
+                        ++indent;
+                        node->range->accept( *this );
+                        --indent;
+                }
+
+                if ( node->body ) {
+                        os << indent << "... with body:" << endl;
+                        ++indent;
+                        os << indent;
+                        node->body->accept( *this );
+                        --indent;
+                }
+
+                if ( node->else_ ) {
+                        os << indent << "... with else:" << endl;
+                        ++indent;
+                        os << indent;
+                        node->else_->accept( *this );
+                        --indent;
+                }
+
+                os << endl;
+                print( node->labels );
+
+                return node;
+        }
+
         virtual const ast::Stmt * visit( const ast::SwitchStmt * node ) override final {
                 os << "Switch on condition: ";

src/AST/Stmt.hpp

@@ -237 +237 @@
         ptr<Expr> cond;
         ptr<Expr> inc;
-        ptr<Expr> range_over;
-        bool is_inc;
         ptr<Stmt> body;
         ptr<Stmt> else_;
@@ -245 +243 @@
                          const Expr * inc, const Stmt * body, const std::vector<Label> && label = {} )
                 : Stmt(loc, std::move(label)), inits(std::move(inits)), cond(cond), inc(inc),
-                        range_over(nullptr), body(body), else_(nullptr) {}
+                body(body), else_(nullptr) {}
 
         ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
                          const Expr * inc, const Stmt * body, const Stmt * else_, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc),
-                        range_over(nullptr), body(body), else_(else_) {}
-
-        ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * range_over, bool is_inc,
-                         const Stmt * body, const Stmt * else_ )
-                : Stmt(loc, std::move(labels)), inits(std::move(inits)), range_over(range_over), is_inc(is_inc), 
                 body(body), else_(else_) {}
 
@@ -260 +253 @@
   private:
         ForStmt * clone() const override { return new ForStmt{ *this }; }
+        MUTATE_FRIEND
+};
+
+enum RangeDirection { DecreasingRange, IncreasingRange };
+
+// For-each loop: for (... : ...) ... else ...
+class ForeachStmt final : public Stmt {
+  public:
+        std::vector<ptr<Stmt>> inits;
+        ptr<Expr> range;
+        ptr<Stmt> body;
+        ptr<Stmt> else_;
+        // This is a property of the range, but there is no place to store it.
+        RangeDirection isIncreasing;
+
+        ForeachStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits,
+                        const Expr * range_over, RangeDirection isInc, const Stmt * body, const Stmt * else_ )
+                : Stmt(loc, std::move(labels)), inits(std::move(inits)), range(range_over),
+                body(body), else_(else_), isIncreasing(isInc) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+        ForeachStmt * clone() const override { return new ForeachStmt{ *this }; }
         MUTATE_FRIEND
 };

src/AST/Visitor.hpp

@@ -41 +41 @@
     virtual const ast::Stmt *             visit( const ast::WhileDoStmt          * ) = 0;
     virtual const ast::Stmt *             visit( const ast::ForStmt              * ) = 0;
+    virtual const ast::Stmt *             visit( const ast::ForeachStmt          * ) = 0;
     virtual const ast::Stmt *             visit( const ast::SwitchStmt           * ) = 0;
     virtual const ast::CaseClause *       visit( const ast::CaseClause           * ) = 0;