Changeset 37cdd97

Timestamp:

Feb 27, 2020, 5:24:09 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

427854b

Parents:

5452673

Message:

Added a ast node for suspend statements

Location:

src

Files:

• AST/Convert.cpp (modified) (2 diffs)
• 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) (1 diff)
• AST/Visitor.hpp (modified) (1 diff)
• Common/PassVisitor.h (modified) (2 diffs)
• Common/PassVisitor.impl.h (modified) (1 diff)
• Parser/lex.ll (modified) (2 diffs)
• Parser/parser.yy (modified) (2 diffs)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/Statement.cc (modified) (1 diff)
• SynTree/Statement.h (modified) (1 diff)
• SynTree/SynTree.h (modified) (1 diff)
• SynTree/Visitor.h (modified) (1 diff)

src/AST/Convert.cpp

@@ -493 +493 @@
         }
 
+        const ast::Stmt * visit(const ast::SuspendStmt * node ) override final {
+                if ( inCache( node ) ) return nullptr;
+                auto stmt = new SuspendStmt();
+                stmt->then   = get<CompoundStmt>().accept1( node->then   );
+                switch(node->type) {
+                        case ast::SuspendStmt::None     : stmt->type = SuspendStmt::None     ; break;
+                        case ast::SuspendStmt::Coroutine: stmt->type = SuspendStmt::Coroutine; break;
+                        case ast::SuspendStmt::Generator: stmt->type = SuspendStmt::Generator; break;
+                }
+                return stmtPostamble( stmt, node );
+        }
+
         const ast::Stmt * visit( const ast::WaitForStmt * node ) override final {
                 if ( inCache( node ) ) return nullptr;
@@ -1859 +1871 @@
         }
 
+        virtual void visit( const SuspendStmt * old ) override final {
+                if ( inCache( old ) ) return;
+                ast::SuspendStmt::Type type;
+                switch (old->type) {
+                        case SuspendStmt::Coroutine: type = ast::SuspendStmt::Coroutine; break;
+                        case SuspendStmt::Generator: type = ast::SuspendStmt::Generator; break;
+                        case SuspendStmt::None     : type = ast::SuspendStmt::None     ; break;
+                        default: abort();
+                }
+                this->node = new ast::SuspendStmt(
+                        old->location,
+                        GET_ACCEPT_1(then  , CompoundStmt),
+                        type,
+                        GET_LABELS_V(old->labels)
+                );
+                cache.emplace( old, this->node );
+        }
+
         virtual void visit( const WaitForStmt * old ) override final {
                 if ( inCache( old ) ) return;

src/AST/Fwd.hpp

@@ -53 +53 @@
 class CatchStmt;
 class FinallyStmt;
+class SuspendStmt;
 class WaitForStmt;
 class WithStmt;

src/AST/Pass.hpp

@@ -111 +111 @@
         const ast::Stmt *             visit( const ast::CatchStmt            * ) override final;
         const ast::Stmt *             visit( const ast::FinallyStmt          * ) override final;
+        const ast::Stmt *             visit( const ast::SuspendStmt          * ) override final;
         const ast::Stmt *             visit( const ast::WaitForStmt          * ) override final;
         const ast::Decl *             visit( const ast::WithStmt             * ) override final;

src/AST/Pass.impl.hpp

@@ -823 +823 @@
 
 //--------------------------------------------------------------------------
+// FinallyStmt
+template< typename pass_t >
+const ast::Stmt * ast::Pass< pass_t >::visit( const ast::SuspendStmt * node ) {
+        VISIT_START( node );
+
+        VISIT(
+                maybe_accept( node, &SuspendStmt::then   );
+        )
+
+        VISIT_END( Stmt, node );
+}
+
+//--------------------------------------------------------------------------
 // WaitForStmt
 template< typename pass_t >

src/AST/Print.cpp

@@ -674 +674 @@
                 safe_print( node->body );
                 --indent;
+
+                return node;
+        }
+
+        virtual const ast::Stmt * visit( const ast::SuspendStmt * node ) override final {
+                os << "Suspend Statement";
+                switch (node->type) {
+                        case ast::SuspendStmt::None     : os << " with implicit target"; break;
+                        case ast::SuspendStmt::Generator: os << " for generator"; break;
+                        case ast::SuspendStmt::Coroutine: os << " for coroutine"; break;
+                }
+                os << endl;
+
+                ++indent;
+                if(node->then) {
+                        os << indent << " with post statement :" << endl;
+                        safe_print( node->then );
+                }
+                ++indent;
 
                 return node;

src/AST/Stmt.hpp

@@ -342 +342 @@
 };
 
+/// Suspend statement
+class SuspendStmt final : public Stmt {
+public:
+        ptr<CompoundStmt> then;
+        enum Type { None, Coroutine, Generator } type = None;
+
+        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, std::vector<Label> && labels = {} )
+        : Stmt(loc, std::move(labels)), then(then), type(type) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        SuspendStmt * clone() const override { return new SuspendStmt{ *this }; }
+        MUTATE_FRIEND
+};
+
 /// Wait for concurrency statement `when (...) waitfor (... , ...) ... timeout(...) ... else ...`
 class WaitForStmt final : public Stmt {

src/AST/Visitor.hpp

@@ -47 +47 @@
     virtual const ast::Stmt *             visit( const ast::CatchStmt            * ) = 0;
     virtual const ast::Stmt *             visit( const ast::FinallyStmt          * ) = 0;
+    virtual const ast::Stmt *             visit( const ast::SuspendStmt          * ) = 0;
     virtual const ast::Stmt *             visit( const ast::WaitForStmt          * ) = 0;
     virtual const ast::Decl *             visit( const ast::WithStmt             * ) = 0;

src/Common/PassVisitor.h

@@ -110 +110 @@
         virtual void visit( FinallyStmt * finallyStmt ) override final;
         virtual void visit( const FinallyStmt * finallyStmt ) override final;
+        virtual void visit( SuspendStmt * suspendStmt ) override final;
+        virtual void visit( const SuspendStmt * suspendStmt ) override final;
         virtual void visit( WaitForStmt * waitforStmt ) override final;
         virtual void visit( const WaitForStmt * waitforStmt ) override final;
@@ -276 +278 @@
         virtual Statement * mutate( CatchStmt * catchStmt ) override final;
         virtual Statement * mutate( FinallyStmt * finallyStmt ) override final;
+        virtual Statement * mutate( SuspendStmt * suspendStmt ) override final;
         virtual Statement * mutate( WaitForStmt * waitforStmt ) override final;
         virtual Declaration * mutate( WithStmt * withStmt ) override final;

src/Common/PassVisitor.impl.h

@@ -1522 +1522 @@
 
 //--------------------------------------------------------------------------
+// SuspendStmt
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( SuspendStmt * node ) {
+        VISIT_START( node );
+
+        maybeAccept_impl( node->then  , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( const SuspendStmt * node ) {
+        VISIT_START( node );
+
+        maybeAccept_impl( node->then  , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( SuspendStmt * node ) {
+        MUTATE_START( node );
+
+        maybeMutate_impl( node->then  , *this );
+
+        MUTATE_END( Statement, node );
+}
+
+//--------------------------------------------------------------------------
 // WaitForStmt
 template< typename pass_type >

src/Parser/lex.ll

@@ -65 +65 @@
 #define FLOATXX(v) KEYWORD_RETURN(v);
 #else
-#define FLOATXX(v) IDENTIFIER_RETURN(); 
+#define FLOATXX(v) IDENTIFIER_RETURN();
 #endif // HAVE_KEYWORDS_FLOATXX
 
@@ -301 +301 @@
 _Static_assert  { KEYWORD_RETURN(STATICASSERT); }               // C11
 struct                  { KEYWORD_RETURN(STRUCT); }
-        /* suspend                      { KEYWORD_RETURN(SUSPEND); }                    // CFA */
+suspend                 { KEYWORD_RETURN(SUSPEND); }                    // CFA
 switch                  { KEYWORD_RETURN(SWITCH); }
 thread                  { KEYWORD_RETURN(THREAD); }                             // C11

src/Parser/parser.yy

@@ -278 +278 @@
 %token OTYPE FTYPE DTYPE TTYPE TRAIT                                    // CFA
 %token SIZEOF OFFSETOF
-// %token SUSPEND RESUME                                                                        // CFA
+// %token RESUME                                                                        // CFA
+%token SUSPEND                                                                  // CFA
 %token ATTRIBUTE EXTENSION                                                              // GCC
 %token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
@@ -1259 +1260 @@
         | RETURN '{' initializer_list_opt comma_opt '}' ';'
                 { SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; }
-        // | SUSPEND ';'
-        //      { SemanticError( yylloc, "Suspend expression is currently unimplemented." ); $$ = nullptr; }
-        // | SUSPEND compound_statement ';'
-        //      { SemanticError( yylloc, "Suspend expression is currently unimplemented." ); $$ = nullptr; }
+        | SUSPEND ';'
+                { SemanticError( yylloc, "Suspend expression is currently unimplemented." ); $$ = nullptr; }
+        | SUSPEND compound_statement ';'
+                { SemanticError( yylloc, "Suspend expression is currently unimplemented." ); $$ = nullptr; }
+        | SUSPEND COROUTINE ';'
+                { SemanticError( yylloc, "Suspend expression is currently unimplemented." ); $$ = nullptr; }
+        | SUSPEND COROUTINE compound_statement
+                { SemanticError( yylloc, "Suspend expression is currently unimplemented." ); $$ = nullptr; }
+        | SUSPEND GENERATOR ';'
+                { SemanticError( yylloc, "Suspend expression is currently unimplemented." ); $$ = nullptr; }
+        | SUSPEND GENERATOR compound_statement
+                { SemanticError( yylloc, "Suspend expression is currently unimplemented." ); $$ = nullptr; }
         | THROW assignment_expression_opt ';'                           // handles rethrow
                 { $$ = new StatementNode( build_throw( $2 ) ); }

src/SynTree/Mutator.h

@@ -51 +51 @@
         virtual Statement * mutate( CatchStmt * catchStmt ) = 0;
         virtual Statement * mutate( FinallyStmt * catchStmt ) = 0;
+        virtual Statement * mutate( SuspendStmt * suspendStmt ) = 0;
         virtual Statement * mutate( WaitForStmt * waitforStmt ) = 0;
         virtual Declaration * mutate( WithStmt * withStmt ) = 0;

src/SynTree/Statement.cc

@@ -420 +420 @@
 }
 
+SuspendStmt::SuspendStmt( const SuspendStmt & other )
+        : Statement( other )
+        , then( maybeClone(other.then) )
+{}
+
+SuspendStmt::~SuspendStmt() {
+        delete then;
+}
+
+void SuspendStmt::print( std::ostream & os, Indenter indent ) const {
+        os << "Suspend Statement";
+        switch (type) {
+                case None     : os << " with implicit target"; break;
+                case Generator: os << " for generator"       ; break;
+                case Coroutine: os << " for coroutine"       ; break;
+        }
+        os << endl;
+        indent += 1;
+
+        if(then) {
+                os << indent << " with post statement :" << endl;
+                then->print( os, indent + 1);
+        }
+}
+
 WaitForStmt::WaitForStmt() : Statement() {
         timeout.time      = nullptr;

src/SynTree/Statement.h

@@ -422 +422 @@
 };
 
+class SuspendStmt : public Statement {
+  public:
+        CompoundStmt * then = nullptr;
+        enum { None, Coroutine, Generator } type = None;
+
+        SuspendStmt() = default;
+        SuspendStmt( const SuspendStmt & );
+        virtual ~SuspendStmt();
+
+        virtual SuspendStmt * clone() const override { return new SuspendStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+
 class WaitForStmt : public Statement {
   public:

src/SynTree/SynTree.h

@@ -54 +54 @@
 class CatchStmt;
 class FinallyStmt;
+class SuspendStmt;
 class WaitForStmt;
 class WithStmt;

src/SynTree/Visitor.h

@@ -78 +78 @@
         virtual void visit( FinallyStmt * node ) { visit( const_cast<const FinallyStmt *>(node) ); }
         virtual void visit( const FinallyStmt * finallyStmt ) = 0;
+        virtual void visit( SuspendStmt * node ) { visit( const_cast<const SuspendStmt *>(node) ); }
+        virtual void visit( const SuspendStmt * suspendStmt ) = 0;
         virtual void visit( WaitForStmt * node ) { visit( const_cast<const WaitForStmt *>(node) ); }
         virtual void visit( const WaitForStmt * waitforStmt ) = 0;