Changeset fca78f1

Timestamp:

Sep 23, 2024, 11:14:56 AM (5 months 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

Files:

• AST/Fwd.hpp (modified) (1 diff)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (1 diff)
• AST/Print.cpp (modified) (1 diff)
• AST/Stmt.hpp (modified) (3 diffs)
• AST/Visitor.hpp (modified) (1 diff)
• Common/CodeLocationTools.cpp (modified) (1 diff)
• ControlStruct/TranslateEnumRange.cpp (modified) (2 diffs)
• Parser/StatementNode.cpp (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;

src/Common/CodeLocationTools.cpp ¶

@@ -119 +119 @@
     macro(WhileDoStmt, Stmt) \
     macro(ForStmt, Stmt) \
+    macro(ForeachStmt, Stmt) \
     macro(SwitchStmt, Stmt) \
     macro(CaseClause, CaseClause) \

src/ControlStruct/TranslateEnumRange.cpp ¶

@@ -9 +9 @@
 
 struct TranslateEnumRangeCore {
-        const ast::Stmt * postvisit( const ast::ForStmt * stmt );
+        const ast::Stmt * postvisit( const ast::ForeachStmt * stmt );
 };
 
-const ast::Stmt * TranslateEnumRangeCore::postvisit( const ast::ForStmt * stmt ) {
-        if ( !stmt->range_over ) return stmt;
-        auto mutStmt = ast::mutate( stmt );
-        auto & location = mutStmt->location;
+const ast::Stmt * TranslateEnumRangeCore::postvisit( const ast::ForeachStmt * stmt ) {
+        auto & location = stmt->location;
 
-        if ( auto declStmt = mutStmt->inits.front().as<ast::DeclStmt>() ) {
-                if ( auto objDecl = declStmt->decl.as<ast::ObjectDecl>() ) {
-                        if ( !objDecl->init ) {
-                                ast::SingleInit * newInit = new ast::SingleInit( location,
-                                        ast::UntypedExpr::createCall( location,
-                                                mutStmt->is_inc ? "lowerBound" : "upperBound", {} ),
-                                        ast::ConstructFlag::MaybeConstruct
-                                );
-                                auto objDeclWithInit = ast::mutate_field( objDecl, &ast::ObjectDecl::init, newInit );
-                                auto declWithInit = ast::mutate_field( declStmt, &ast::DeclStmt::decl, objDeclWithInit );
-                                mutStmt->inits[0] = declWithInit;
-                        }
-                }
+        assert( stmt->inits.size() == 1 );
+        ast::DeclStmt const * initialize = stmt->inits.front().strict_as<ast::DeclStmt>();
+
+        auto objDecl = initialize->decl.strict_as<ast::ObjectDecl>();
+        if ( !objDecl->init ) {
+                ast::SingleInit * init = new ast::SingleInit( location,
+                        ast::UntypedExpr::createCall( location,
+                                stmt->isIncreasing ? "lowerBound" : "upperBound", {} ),
+                        ast::ConstructFlag::MaybeConstruct
+                );
+                objDecl = ast::mutate_field( objDecl, &ast::ObjectDecl::init, init );
+                initialize = ast::mutate_field( initialize, &ast::DeclStmt::decl, objDecl );
         }
 
-        auto declStmt = mutStmt->inits.front().strict_as<ast::DeclStmt>();
-        auto initDecl = declStmt->decl.strict_as<ast::ObjectDecl>();
-        auto indexName = initDecl->name;
+        auto indexName = objDecl->name;
 
         // Both inc and dec check if the current posn less than the number of enumerator
@@ -40 +35 @@
         // it wraps around and become unsigned max
         ast::UntypedExpr * condition = ast::UntypedExpr::createCall( location,
-                mutStmt->is_inc ? "?<=?" : "?>=?",
+                stmt->isIncreasing ? "?<=?" : "?>=?",
                 {
                         new ast::NameExpr( location, indexName ),
                         ast::UntypedExpr::createCall( location,
-                                mutStmt->is_inc ? "upperBound" : "lowerBound", {} )
+                                stmt->isIncreasing ? "upperBound" : "lowerBound", {} )
                 } );
-        auto increment = ast::UntypedExpr::createCall( location,
-                mutStmt->is_inc ? "succ_unsafe" : "pred_unsafe",
-                { new ast::NameExpr( location, indexName ) } );
-        auto assig = ast::UntypedExpr::createAssign( location,
-                new ast::NameExpr( location, indexName ), increment );
-        mutStmt->cond = condition;
-        mutStmt->inc = assig;
-        return mutStmt;
+        ast::UntypedExpr * increment = ast::UntypedExpr::createAssign( location,
+                new ast::NameExpr( location, indexName ),
+                ast::UntypedExpr::createCall( location,
+                        stmt->isIncreasing ? "succ_unsafe" : "pred_unsafe",
+                        { new ast::NameExpr( location, indexName ) } ) );
+
+        return new ast::ForStmt(
+                stmt->location,
+                { initialize },
+                condition,
+                increment,
+                stmt->body,
+                stmt->else_,
+                copy( stmt->labels )
+        );
 }
 

src/Parser/StatementNode.cpp ¶

@@ -213 +213 @@
         if ( forctl->range_over ) {
                 ast::Expr * range_over = maybeMoveBuild( forctl->range_over );
-                auto kind = forctl->kind;                                               // save before delete, used in return
+                bool isIncreasing = forctl->kind == OperKinds::LEThan;
+                // Copy all the data needed before the delete.
                 delete forctl;
-                return new ast::ForStmt( location,
+                return new ast::ForeachStmt( location,
                         std::move( astinit ),
-                        range_over, kind == OperKinds::LEThan,
+                        range_over,
+                        isIncreasing ? ast::IncreasingRange : ast::DecreasingRange,
                         buildMoveSingle( stmt ),
                         buildMoveOptional( else_ )