Changeset 3d9d017 for src/AST

Timestamp:

Nov 6, 2023, 2:19:37 PM (14 months ago)

Author:

caparson <caparson@…>

Branches:

master

Children:

ba0e1bc

Parents:

49ae2bc

Message:

added cofor implementation

Location:

src/AST

Files:

• Convert.cpp (modified) (1 diff)
• Fwd.hpp (modified) (1 diff)
• Node.cpp (modified) (1 diff)
• Pass.hpp (modified) (1 diff)
• Pass.impl.hpp (modified) (1 diff)
• Print.cpp (modified) (1 diff)
• Stmt.hpp (modified) (1 diff)
• Visitor.hpp (modified) (1 diff)

src/AST/Convert.cpp

@@ -656 +656 @@
         }
 
+        const ast::Stmt * visit( const ast::CoforStmt * node ) override final {
+                // There is no old-AST CoforStmt, so this should never be called.
+                assert( !node );
+                return nullptr;
+        }
+
         TypeSubstitution * convertTypeSubstitution(const ast::TypeSubstitution * src) {
 

src/AST/Fwd.hpp

@@ -68 +68 @@
 class MutexStmt;
 class CorunStmt;
+class CoforStmt;
 
 class Expr;

src/AST/Node.cpp

@@ -194 +194 @@
 template class ast::ptr_base< ast::CorunStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::CorunStmt, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::CoforStmt, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::CoforStmt, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::Expr, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::Expr, ast::Node::ref_type::strong >;

src/AST/Pass.hpp

@@ -172 +172 @@
         const ast::Stmt *             visit( const ast::MutexStmt            * ) override final;
         const ast::Stmt *             visit( const ast::CorunStmt            * ) override final;
+        const ast::Stmt *             visit( const ast::CoforStmt            * ) override final;
         const ast::Expr *             visit( const ast::ApplicationExpr      * ) override final;
         const ast::Expr *             visit( const ast::UntypedExpr          * ) override final;

src/AST/Pass.impl.hpp

@@ -1134 +1134 @@
 
 //--------------------------------------------------------------------------
+// CoforStmt
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::CoforStmt * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                // for statements introduce a level of scope (for the initialization)
+                guard_symtab guard { *this };
+                maybe_accept( node, &CoforStmt::inits );
+                maybe_accept_top( node, &CoforStmt::cond  );
+                maybe_accept_top( node, &CoforStmt::inc   );
+                maybe_accept_as_compound( node, &CoforStmt::body  );
+        }
+
+        VISIT_END( Stmt, node );
+}
+
+//--------------------------------------------------------------------------
 // ApplicationExpr
 template< typename core_t >

src/AST/Print.cpp

@@ -934 +934 @@
         }
 
+        virtual const ast::Stmt * visit( const ast::CoforStmt * node ) override final {
+                os << "Cofor 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->cond ) {
+                        os << indent << "... condition:" << endl;
+                        ++indent;
+                        os << indent;
+                        node->cond->accept( *this );
+                        --indent;
+                }
+
+                if ( node->inc ) {
+                        os << indent << "... increment:" << endl;
+                        ++indent;
+                        os << indent;
+                        node->inc->accept( *this );
+                        --indent;
+                }
+
+                if ( node->body ) {
+                        os << indent << "... with body:" << endl;
+                        ++indent;
+                        os << indent;
+                        node->body->accept( *this );
+                        --indent;
+                }
+                os << endl;
+                print( node->labels );
+
+                return node;
+        }
+
         virtual const ast::Expr * visit( const ast::ApplicationExpr * node ) override final {
                 ++indent;

src/AST/Stmt.hpp

@@ -546 +546 @@
 };
 
+// Corun Statement
+class CoforStmt final : public Stmt {
+  public:
+        std::vector<ptr<Stmt>> inits;
+        ptr<Expr> cond;
+        ptr<Expr> inc;
+        ptr<Stmt> body;
+
+        CoforStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
+                         const Expr * inc, const Stmt * body, const std::vector<Label> && label = {} )
+                : Stmt(loc, std::move(label)), inits(std::move(inits)), cond(cond), inc(inc), body(body) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+        CoforStmt * clone() const override { return new CoforStmt{ *this }; }
+        MUTATE_FRIEND
+};
+
 } // namespace ast
 

src/AST/Visitor.hpp

@@ -60 +60 @@
     virtual const ast::Stmt *             visit( const ast::MutexStmt            * ) = 0;
     virtual const ast::Stmt *             visit( const ast::CorunStmt            * ) = 0;
+    virtual const ast::Stmt *             visit( const ast::CoforStmt            * ) = 0;
     virtual const ast::Expr *             visit( const ast::ApplicationExpr      * ) = 0;
     virtual const ast::Expr *             visit( const ast::UntypedExpr          * ) = 0;