Changeset 6a490b2 for src

Timestamp:

May 11, 2020, 1:53:29 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

504a7dc

Parents:

b7d6a36 (diff), a7b486b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into relaxed_ready

Location:

src

Files:

• AST/Convert.cpp (modified) (2 diffs)
• AST/Decl.hpp (modified) (1 diff)
• 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)
• CompilationState.cc (modified) (1 diff)
• CompilationState.h (modified) (1 diff)
• Concurrency/Keywords.cc (modified) (18 diffs)
• Concurrency/Waitfor.cc (modified) (1 diff)
• ControlStruct/ExceptTranslate.cc (modified) (11 diffs)
• Parser/ParseNode.h (modified) (1 diff)
• Parser/StatementNode.cc (modified) (1 diff)
• Parser/TypeData.cc (modified) (1 diff)
• Parser/lex.ll (modified) (2 diffs)
• Parser/parser.yy (modified) (7 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (2 diffs)
• ResolvExpr/Resolver.cc (modified) (3 diffs)
• ResolvExpr/TypeEnvironment.cc (modified) (3 diffs)
• SynTree/Declaration.h (modified) (1 diff)
• SynTree/LinkageSpec.cc (modified) (2 diffs)
• SynTree/LinkageSpec.h (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)
• main.cc (modified) (4 diffs)

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/Decl.hpp

@@ -259 +259 @@
 
         bool is_coroutine() { return kind == Coroutine; }
-        bool is_monitor() { return kind == Monitor; }
-        bool is_thread() { return kind == Thread; }
+        bool is_generator() { return kind == Generator; }
+        bool is_monitor  () { return kind == Monitor  ; }
+        bool is_thread   () { return kind == Thread   ; }
 
         const Decl * accept( Visitor & v ) const override { return v.visit( this ); }

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/CompilationState.cc

@@ -27 +27 @@
         nopreludep = false,
         genproto = false,
+        deterministic_output = false,
         nomainp = false,
         parsep = false,

src/CompilationState.h

@@ -28 +28 @@
         nopreludep,
         genproto,
+        deterministic_output,
         nomainp,
         parsep,

src/Concurrency/Keywords.cc

@@ -16 +16 @@
 #include "Concurrency/Keywords.h"
 
-#include <cassert>                 // for assert
-#include <string>                  // for string, operator==
-
-#include "Common/PassVisitor.h"    // for PassVisitor
-#include "Common/SemanticError.h"  // for SemanticError
-#include "Common/utility.h"        // for deleteAll, map_range
-#include "CodeGen/OperatorTable.h" // for isConstructor
-#include "InitTweak/InitTweak.h"   // for getPointerBase
-#include "SynTree/LinkageSpec.h"   // for Cforall
-#include "SynTree/Constant.h"      // for Constant
-#include "SynTree/Declaration.h"   // for StructDecl, FunctionDecl, ObjectDecl
-#include "SynTree/Expression.h"    // for VariableExpr, ConstantExpr, Untype...
-#include "SynTree/Initializer.h"   // for SingleInit, ListInit, Initializer ...
-#include "SynTree/Label.h"         // for Label
-#include "SynTree/Statement.h"     // for CompoundStmt, DeclStmt, ExprStmt
-#include "SynTree/Type.h"          // for StructInstType, Type, PointerType
-#include "SynTree/Visitor.h"       // for Visitor, acceptAll
+#include <cassert>                        // for assert
+#include <string>                         // for string, operator==
+
+#include "Common/PassVisitor.h"           // for PassVisitor
+#include "Common/SemanticError.h"         // for SemanticError
+#include "Common/utility.h"               // for deleteAll, map_range
+#include "CodeGen/OperatorTable.h"        // for isConstructor
+#include "ControlStruct/LabelGenerator.h" // for LebelGenerator
+#include "InitTweak/InitTweak.h"          // for getPointerBase
+#include "SynTree/LinkageSpec.h"          // for Cforall
+#include "SynTree/Constant.h"             // for Constant
+#include "SynTree/Declaration.h"          // for StructDecl, FunctionDecl, ObjectDecl
+#include "SynTree/Expression.h"           // for VariableExpr, ConstantExpr, Untype...
+#include "SynTree/Initializer.h"          // for SingleInit, ListInit, Initializer ...
+#include "SynTree/Label.h"                // for Label
+#include "SynTree/Statement.h"            // for CompoundStmt, DeclStmt, ExprStmt
+#include "SynTree/Type.h"                 // for StructInstType, Type, PointerType
+#include "SynTree/Visitor.h"              // for Visitor, acceptAll
 
 class Attribute;
@@ -88 +89 @@
         //      int data;                                  int data;
         //      a_struct_t more_data;                      a_struct_t more_data;
-        //                                =>             thread_desc __thrd_d;
+        //                                =>             $thread __thrd_d;
         // };                                        };
-        //                                           static inline thread_desc * get_thread( MyThread * this ) { return &this->__thrd_d; }
+        //                                           static inline $thread * get_thread( MyThread * this ) { return &this->__thrd_d; }
         //
         class ThreadKeyword final : public ConcurrentSueKeyword {
@@ -96 +97 @@
 
                 ThreadKeyword() : ConcurrentSueKeyword(
-                        "thread_desc",
+                        "$thread",
                         "__thrd",
                         "get_thread",
@@ -120 +121 @@
         //      int data;                                  int data;
         //      a_struct_t more_data;                      a_struct_t more_data;
-        //                                =>             coroutine_desc __cor_d;
+        //                                =>             $coroutine __cor_d;
         // };                                        };
-        //                                           static inline coroutine_desc * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; }
+        //                                           static inline $coroutine * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; }
         //
         class CoroutineKeyword final : public ConcurrentSueKeyword {
@@ -128 +129 @@
 
                 CoroutineKeyword() : ConcurrentSueKeyword(
-                        "coroutine_desc",
+                        "$coroutine",
                         "__cor",
                         "get_coroutine",
@@ -147 +148 @@
         };
 
+
+
         //-----------------------------------------------------------------------------
         //Handles monitor type declarations :
@@ -152 +155 @@
         //      int data;                                  int data;
         //      a_struct_t more_data;                      a_struct_t more_data;
-        //                                =>             monitor_desc __mon_d;
+        //                                =>             $monitor __mon_d;
         // };                                        };
-        //                                           static inline monitor_desc * get_coroutine( MyMonitor * this ) { return &this->__cor_d; }
+        //                                           static inline $monitor * get_coroutine( MyMonitor * this ) { return &this->__cor_d; }
         //
         class MonitorKeyword final : public ConcurrentSueKeyword {
@@ -160 +163 @@
 
                 MonitorKeyword() : ConcurrentSueKeyword(
-                        "monitor_desc",
+                        "$monitor",
                         "__mon",
                         "get_monitor",
@@ -180 +183 @@
 
         //-----------------------------------------------------------------------------
+        //Handles generator type declarations :
+        // generator MyGenerator {                   struct MyGenerator {
+        //      int data;                                  int data;
+        //      a_struct_t more_data;                      a_struct_t more_data;
+        //                                =>             int __gen_next;
+        // };                                        };
+        //
+        class GeneratorKeyword final : public ConcurrentSueKeyword {
+          public:
+
+                GeneratorKeyword() : ConcurrentSueKeyword(
+                        "$generator",
+                        "__generator_state",
+                        "get_generator",
+                        "Unable to find builtin type $generator\n",
+                        true,
+                        AggregateDecl::Generator
+                )
+                {}
+
+                virtual ~GeneratorKeyword() {}
+
+                virtual bool is_target( StructDecl * decl ) override final { return decl->is_generator(); }
+
+                static void implement( std::list< Declaration * > & translationUnit ) {
+                        PassVisitor< GeneratorKeyword > impl;
+                        mutateAll( translationUnit, impl );
+                }
+        };
+
+
+        //-----------------------------------------------------------------------------
+        class SuspendKeyword final : public WithStmtsToAdd, public WithGuards {
+        public:
+                SuspendKeyword() = default;
+                virtual ~SuspendKeyword() = default;
+
+                void  premutate( FunctionDecl * );
+                DeclarationWithType * postmutate( FunctionDecl * );
+
+                Statement * postmutate( SuspendStmt * );
+
+                static void implement( std::list< Declaration * > & translationUnit ) {
+                        PassVisitor< SuspendKeyword > impl;
+                        mutateAll( translationUnit, impl );
+                }
+
+        private:
+                DeclarationWithType * is_main( FunctionDecl * );
+                bool is_real_suspend( FunctionDecl * );
+
+                Statement * make_generator_suspend( SuspendStmt * );
+                Statement * make_coroutine_suspend( SuspendStmt * );
+
+                struct LabelPair {
+                        Label obj;
+                        int   idx;
+                };
+
+                LabelPair make_label() {
+                        labels.push_back( gen.newLabel("generator") );
+                        return { labels.back(), int(labels.size()) };
+                }
+
+                DeclarationWithType * in_generator = nullptr;
+                FunctionDecl * decl_suspend = nullptr;
+                std::vector<Label> labels;
+                ControlStruct::LabelGenerator & gen = *ControlStruct::LabelGenerator::getGenerator();
+        };
+
+        //-----------------------------------------------------------------------------
         //Handles mutex routines definitions :
         // void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
-        //                                                                       monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
+        //                                                                       $monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
         //                                                                       monitor_guard_t __guard = { __monitors, 2 };
         //    /*Some code*/                                       =>           /*Some code*/
@@ -221 +295 @@
         //Handles mutex routines definitions :
         // void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
-        //                                                                       monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
+        //                                                                       $monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
         //                                                                       monitor_guard_t __guard = { __monitors, 2 };
         //    /*Some code*/                                       =>           /*Some code*/
@@ -251 +325 @@
                 CoroutineKeyword        ::implement( translationUnit );
                 MonitorKeyword  ::implement( translationUnit );
+                GeneratorKeyword  ::implement( translationUnit );
+                SuspendKeyword    ::implement( translationUnit );
         }
 
@@ -306 +382 @@
         Expression * ConcurrentSueKeyword::postmutate( KeywordCastExpr * cast ) {
                 if ( cast_target == cast->target ) {
-                        // convert (thread &)t to (thread_desc &)*get_thread(t), etc.
+                        // convert (thread &)t to ($thread &)*get_thread(t), etc.
                         if( !type_decl ) SemanticError( cast, context_error );
                         if( !dtor_decl ) SemanticError( cast, context_error );
@@ -377 +453 @@
                         get_type,
                         nullptr,
-                        noAttributes,
+                        { new Attribute("const") },
                         Type::Inline
                 );
@@ -446 +522 @@
 
                 declsToAddAfter.push_back( get_decl );
-
-                // get_decl->fixUniqueId();
-        }
+        }
+
+        //=============================================================================================
+        // Suspend keyword implementation
+        //=============================================================================================
+        DeclarationWithType * SuspendKeyword::is_main( FunctionDecl * func) {
+                if(func->name != "main") return nullptr;
+                if(func->type->parameters.size() != 1) return nullptr;
+
+                auto param = func->type->parameters.front();
+
+                auto type  = dynamic_cast<ReferenceType * >(param->get_type());
+                if(!type) return nullptr;
+
+                auto obj   = dynamic_cast<StructInstType *>(type->base);
+                if(!obj) return nullptr;
+
+                if(!obj->baseStruct->is_generator()) return nullptr;
+
+                return param;
+        }
+
+        bool SuspendKeyword::is_real_suspend( FunctionDecl * func ) {
+                if(isMangled(func->linkage)) return false; // the real suspend isn't mangled
+                if(func->name != "__cfactx_suspend") return false; // the real suspend has a specific name
+                if(func->type->parameters.size() != 0) return false; // Too many parameters
+                if(func->type->returnVals.size() != 0) return false; // Too many return values
+
+                return true;
+        }
+
+        void SuspendKeyword::premutate( FunctionDecl * func ) {
+                GuardValue(in_generator);
+                in_generator = nullptr;
+
+                // Is this the real suspend?
+                if(is_real_suspend(func)) {
+                        decl_suspend = decl_suspend ? decl_suspend : func;
+                        return;
+                }
+
+                // Is this the main of a generator?
+                auto param = is_main( func );
+                if(!param) return;
+
+                if(func->type->returnVals.size() != 0) SemanticError(func->location, "Generator main must return void");
+
+                in_generator = param;
+                GuardValue(labels);
+                labels.clear();
+        }
+
+        DeclarationWithType * SuspendKeyword::postmutate( FunctionDecl * func ) {
+                if( !func->statements ) return func; // Not the actual definition, don't do anything
+                if( !in_generator     ) return func; // Not in a generator, don't do anything
+                if( labels.empty()    ) return func; // Generator has no states, nothing to do, could throw a warning
+
+                // This is a generator main, we need to add the following code to the top
+                // static void * __generator_labels[] = {&&s0, &&s1, ...};
+                // goto * __generator_labels[gen.__generator_state];
+                const auto & loc = func->location;
+
+                const auto first_label = gen.newLabel("generator");
+
+                // for each label add to declaration
+                std::list<Initializer*> inits = { new SingleInit( new LabelAddressExpr( first_label ) ) };
+                for(const auto & label : labels) {
+                        inits.push_back(
+                                new SingleInit(
+                                        new LabelAddressExpr( label )
+                                )
+                        );
+                }
+                auto init = new ListInit(std::move(inits), noDesignators, true);
+                labels.clear();
+
+                // create decl
+                auto decl = new ObjectDecl(
+                        "__generator_labels",
+                        Type::StorageClasses( Type::Static ),
+                        LinkageSpec::AutoGen,
+                        nullptr,
+                        new ArrayType(
+                                Type::Qualifiers(),
+                                new PointerType(
+                                        Type::Qualifiers(),
+                                        new VoidType( Type::Qualifiers() )
+                                ),
+                                nullptr,
+                                false, false
+                        ),
+                        init
+                );
+
+                // create the goto
+                assert(in_generator);
+
+                auto go_decl = new ObjectDecl(
+                        "__generator_label",
+                        noStorageClasses,
+                        LinkageSpec::AutoGen,
+                        nullptr,
+                        new PointerType(
+                                Type::Qualifiers(),
+                                new VoidType( Type::Qualifiers() )
+                        ),
+                        new SingleInit(
+                                new UntypedExpr(
+                                        new NameExpr("?[?]"),
+                                        {
+                                                new NameExpr("__generator_labels"),
+                                                new UntypedMemberExpr(
+                                                        new NameExpr("__generator_state"),
+                                                        new VariableExpr( in_generator )
+                                                )
+                                        }
+                                )
+                        )
+                );
+                go_decl->location = loc;
+
+                auto go = new BranchStmt(
+                        new VariableExpr( go_decl ),
+                        BranchStmt::Goto
+                );
+                go->location = loc;
+                go->computedTarget->location = loc;
+
+                auto noop = new NullStmt({ first_label });
+                noop->location = loc;
+
+                // wrap everything in a nice compound
+                auto body = new CompoundStmt({
+                        new DeclStmt( decl ),
+                        new DeclStmt( go_decl ),
+                        go,
+                        noop,
+                        func->statements
+                });
+                body->location   = loc;
+                func->statements = body;
+
+                return func;
+        }
+
+        Statement * SuspendKeyword::postmutate( SuspendStmt * stmt ) {
+                SuspendStmt::Type type = stmt->type;
+                if(type == SuspendStmt::None) {
+                        // This suspend has a implicit target, find it
+                        type = in_generator ? SuspendStmt::Generator : SuspendStmt::Coroutine;
+                }
+
+                // Check that the target makes sense
+                if(!in_generator && type == SuspendStmt::Generator) SemanticError( stmt->location, "'suspend generator' must be used inside main of generator type.");
+
+                // Act appropriately
+                switch(type) {
+                        case SuspendStmt::Generator: return make_generator_suspend(stmt);
+                        case SuspendStmt::Coroutine: return make_coroutine_suspend(stmt);
+                        default: abort();
+                }
+        }
+
+        Statement * SuspendKeyword::make_generator_suspend( SuspendStmt * stmt ) {
+                assert(in_generator);
+                // Target code is :
+                //   gen.__generator_state = X;
+                //   { THEN }
+                //   return;
+                //   __gen_X:;
+
+                // Save the location and delete the old statement, we only need the location from this point on
+                auto loc = stmt->location;
+
+                // Build the label and get its index
+                auto label = make_label();
+
+                // Create the context saving statement
+                auto save = new ExprStmt( new UntypedExpr(
+                        new NameExpr( "?=?" ),
+                        {
+                                new UntypedMemberExpr(
+                                        new NameExpr("__generator_state"),
+                                        new VariableExpr( in_generator )
+                                ),
+                                new ConstantExpr(
+                                        Constant::from_int( label.idx )
+                                )
+                        }
+                ));
+                assert(save->expr);
+                save->location = loc;
+                stmtsToAddBefore.push_back( save );
+
+                // if we have a then add it here
+                auto then = stmt->then;
+                stmt->then = nullptr;
+                delete stmt;
+                if(then) stmtsToAddBefore.push_back( then );
+
+                // Create the return statement
+                auto ret = new ReturnStmt( nullptr );
+                ret->location = loc;
+                stmtsToAddBefore.push_back( ret );
+
+                // Create the null statement with the created label
+                auto noop = new NullStmt({ label.obj });
+                noop->location = loc;
+
+                // Return the null statement to take the place of the previous statement
+                return noop;
+        }
+
+        Statement * SuspendKeyword::make_coroutine_suspend( SuspendStmt * stmt ) {
+                if(stmt->then) SemanticError( stmt->location, "Compound statement following coroutines is not implemented.");
+
+                // Save the location and delete the old statement, we only need the location from this point on
+                auto loc = stmt->location;
+                delete stmt;
+
+                // Create the call expression
+                if(!decl_suspend) SemanticError( loc, "suspend keyword applied to coroutines requires coroutines to be in scope, add #include <coroutine.hfa>\n");
+                auto expr = new UntypedExpr( VariableExpr::functionPointer( decl_suspend ) );
+                expr->location = loc;
+
+                // Change this statement into a regular expr
+                assert(expr);
+                auto nstmt = new ExprStmt( expr );
+                nstmt->location = loc;
+                return nstmt;
+        }
+
 
         //=============================================================================================
@@ -516 +821 @@
         void MutexKeyword::postvisit(StructDecl* decl) {
 
-                if( decl->name == "monitor_desc" && decl->body ) {
+                if( decl->name == "$monitor" && decl->body ) {
                         assert( !monitor_decl );
                         monitor_decl = decl;
@@ -612 +917 @@
                 );
 
-                //monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
+                //$monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
                 body->push_front( new DeclStmt( monitors) );
         }
@@ -673 +978 @@
                 );
 
-                //monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
+                //$monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
                 body->push_front( new DeclStmt( monitors) );
         }
@@ -681 +986 @@
         //=============================================================================================
         void ThreadStarter::previsit( StructDecl * decl ) {
-                if( decl->name == "thread_desc" && decl->body ) {
+                if( decl->name == "$thread" && decl->body ) {
                         assert( !thread_decl );
                         thread_decl = decl;

src/Concurrency/Waitfor.cc

@@ -244 +244 @@
                         decl_mask = decl;
                 }
-                else if( decl->name == "monitor_desc" ) {
+                else if( decl->name == "$monitor" ) {
                         assert( !decl_monitor );
                         decl_monitor = decl;

src/ControlStruct/ExceptTranslate.cc

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Wed Jun 14 16:49:00 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Dec 13 23:40:15 2019
-// Update Count     : 12
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Mar 27 11:58:00 2020
+// Update Count     : 13
 //
 
@@ -211 +211 @@
                         ThrowStmt *throwStmt ) {
                 // __throw_terminate( `throwStmt->get_name()` ); }
-                return create_given_throw( "__cfaabi_ehm__throw_terminate", throwStmt );
+                return create_given_throw( "__cfaehm_throw_terminate", throwStmt );
         }
 
@@ -232 +232 @@
                         ) ) );
                 result->push_back( new ExprStmt(
-                        new UntypedExpr( new NameExpr( "__cfaabi_ehm__rethrow_terminate" ) )
+                        new UntypedExpr( new NameExpr( "__cfaehm_rethrow_terminate" ) )
                         ) );
                 delete throwStmt;
@@ -241 +241 @@
                         ThrowStmt *throwStmt ) {
                 // __throw_resume( `throwStmt->get_name` );
-                return create_given_throw( "__cfaabi_ehm__throw_resume", throwStmt );
+                return create_given_throw( "__cfaehm_throw_resume", throwStmt );
         }
 
@@ -309 +309 @@
                         local_except->get_attributes().push_back( new Attribute(
                                 "cleanup",
-                                { new NameExpr( "__cfaabi_ehm__cleanup_terminate" ) }
+                                { new NameExpr( "__cfaehm_cleanup_terminate" ) }
                                 ) );
 
@@ -429 +429 @@
                         FunctionDecl * terminate_catch,
                         FunctionDecl * terminate_match ) {
-                // { __cfaabi_ehm__try_terminate(`try`, `catch`, `match`); }
+                // { __cfaehm_try_terminate(`try`, `catch`, `match`); }
 
                 UntypedExpr * caller = new UntypedExpr( new NameExpr(
-                        "__cfaabi_ehm__try_terminate" ) );
+                        "__cfaehm_try_terminate" ) );
                 std::list<Expression *>& args = caller->get_args();
                 args.push_back( nameOf( try_wrapper ) );
@@ -486 +486 @@
 
                 // struct __try_resume_node __resume_node
-                //      __attribute__((cleanup( __cfaabi_ehm__try_resume_cleanup )));
+                //      __attribute__((cleanup( __cfaehm_try_resume_cleanup )));
                 // ** unwinding of the stack here could cause problems **
                 // ** however I don't think that can happen currently **
-                // __cfaabi_ehm__try_resume_setup( &__resume_node, resume_handler );
+                // __cfaehm_try_resume_setup( &__resume_node, resume_handler );
 
                 std::list< Attribute * > attributes;
@@ -495 +495 @@
                         std::list< Expression * > attr_params;
                         attr_params.push_back( new NameExpr(
-                                "__cfaabi_ehm__try_resume_cleanup" ) );
+                                "__cfaehm_try_resume_cleanup" ) );
                         attributes.push_back( new Attribute( "cleanup", attr_params ) );
                 }
@@ -514 +514 @@
 
                 UntypedExpr *setup = new UntypedExpr( new NameExpr(
-                        "__cfaabi_ehm__try_resume_setup" ) );
+                        "__cfaehm_try_resume_setup" ) );
                 setup->get_args().push_back( new AddressExpr( nameOf( obj ) ) );
                 setup->get_args().push_back( nameOf( resume_handler ) );
@@ -539 +539 @@
         ObjectDecl * ExceptionMutatorCore::create_finally_hook(
                         FunctionDecl * finally_wrapper ) {
-                // struct __cfaabi_ehm__cleanup_hook __finally_hook
+                // struct __cfaehm_cleanup_hook __finally_hook
                 //      __attribute__((cleanup( finally_wrapper )));
 
@@ -593 +593 @@
                         // Skip children?
                         return;
-                } else if ( structDecl->get_name() == "__cfaabi_ehm__base_exception_t" ) {
+                } else if ( structDecl->get_name() == "__cfaehm_base_exception_t" ) {
                         assert( nullptr == except_decl );
                         except_decl = structDecl;
                         init_func_types();
-                } else if ( structDecl->get_name() == "__cfaabi_ehm__try_resume_node" ) {
+                } else if ( structDecl->get_name() == "__cfaehm_try_resume_node" ) {
                         assert( nullptr == node_decl );
                         node_decl = structDecl;
-                } else if ( structDecl->get_name() == "__cfaabi_ehm__cleanup_hook" ) {
+                } else if ( structDecl->get_name() == "__cfaehm_cleanup_hook" ) {
                         assert( nullptr == hook_decl );
                         hook_decl = structDecl;

src/Parser/ParseNode.h

@@ -428 +428 @@
 Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
 Statement * build_directive( std::string * directive );
+SuspendStmt * build_suspend( StatementNode *, SuspendStmt::Type = SuspendStmt::None);
 WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when );
 WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when, WaitForStmt * existing );

src/Parser/StatementNode.cc

@@ -249 +249 @@
 } // build_finally
 
+SuspendStmt * build_suspend( StatementNode * then, SuspendStmt::Type type ) {
+        auto node = new SuspendStmt();
+
+        node->type = type;
+
+        std::list< Statement * > stmts;
+        buildMoveList< Statement, StatementNode >( then, stmts );
+        if(!stmts.empty()) {
+                assert( stmts.size() == 1 );
+                node->then = dynamic_cast< CompoundStmt * >( stmts.front() );
+        }
+
+        return node;
+}
+
 WaitForStmt * build_waitfor( ExpressionNode * targetExpr, StatementNode * stmt, ExpressionNode * when ) {
         auto node = new WaitForStmt();

src/Parser/TypeData.cc

@@ -769 +769 @@
           case AggregateDecl::Struct:
           case AggregateDecl::Coroutine:
+          case AggregateDecl::Generator:
           case AggregateDecl::Monitor:
           case AggregateDecl::Thread:

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

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Feb 16 08:22:14 2020
-// Update Count     : 4461
+// Last Modified On : Mon Apr 27 12:25:42 2020
+// Update Count     : 4483
 //
 
@@ -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
@@ -918 +919 @@
         conditional_expression
         | unary_expression assignment_operator assignment_expression
-                { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); }
+                {
+                        if ( $2 == OperKinds::AtAssn ) {
+                                SemanticError( yylloc, "C @= assignment is currently unimplemented." ); $$ = nullptr;
+                        } else {
+                                $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) );
+                        } // if
+                }
         | unary_expression '=' '{' initializer_list_opt comma_opt '}'
                 { SemanticError( yylloc, "Initializer assignment is currently unimplemented." ); $$ = nullptr; }
@@ -959 +966 @@
 
 tuple_expression_list:
-        assignment_expression_opt
-        | tuple_expression_list ',' assignment_expression_opt
+        assignment_expression
+        | '@'                                                                                           // CFA
+                { SemanticError( yylloc, "Eliding tuple element with '@' is currently unimplemented." ); $$ = nullptr; }
+        | tuple_expression_list ',' assignment_expression
                 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+        | tuple_expression_list ',' '@'
+                { SemanticError( yylloc, "Eliding tuple element with '@' is currently unimplemented." ); $$ = nullptr; }
         ;
 
@@ -1259 +1270 @@
         | 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 ';'
+                { $$ = new StatementNode( build_suspend( nullptr ) ); }
+        | SUSPEND compound_statement
+                { $$ = new StatementNode( build_suspend( $2 ) ); }
+        | SUSPEND COROUTINE ';'
+                { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Coroutine ) ); }
+        | SUSPEND COROUTINE compound_statement
+                { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Coroutine ) ); }
+        | SUSPEND GENERATOR ';'
+                { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Generator ) ); }
+        | SUSPEND GENERATOR compound_statement
+                { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Generator ) ); }
         | THROW assignment_expression_opt ';'                           // handles rethrow
                 { $$ = new StatementNode( build_throw( $2 ) ); }
@@ -1589 +1608 @@
                 // type_specifier can resolve to just TYPEDEFname (e.g., typedef int T; int f( T );). Therefore this must be
                 // flattened to allow lookahead to the '(' without having to reduce identifier_or_type_name.
-        cfa_abstract_tuple identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')'
+        cfa_abstract_tuple identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' attribute_list_opt
                 // To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator).
-                { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 ); }
-        | cfa_function_return identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')'
-                { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 ); }
+                { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 )->addQualifiers( $8 ); }
+        | cfa_function_return identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' attribute_list_opt
+                { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 )->addQualifiers( $8 ); }
         ;
 
@@ -2077 +2096 @@
 aggregate_control:                                                                              // CFA
         GENERATOR
-                { yyy = true; $$ = AggregateDecl::Coroutine; }
+                { yyy = true; $$ = AggregateDecl::Generator; }
+        | MONITOR GENERATOR
+                { SemanticError( yylloc, "monitor generator is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         | COROUTINE
                 { yyy = true; $$ = AggregateDecl::Coroutine; }
         | MONITOR
                 { yyy = true; $$ = AggregateDecl::Monitor; }
+        | MONITOR COROUTINE
+                { SemanticError( yylloc, "monitor coroutine is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         | THREAD
                 { yyy = true; $$ = AggregateDecl::Thread; }
+        | MONITOR THREAD
+                { SemanticError( yylloc, "monitor thread is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         ;
 

src/ResolvExpr/AlternativeFinder.cc

@@ -1292 +1292 @@
 
                 try {
-                        // Attempt 1 : turn (thread&)X into (thread_desc&)X.__thrd
+                        // Attempt 1 : turn (thread&)X into ($thread&)X.__thrd
                         // Clone is purely for memory management
                         std::unique_ptr<Expression> tech1 { new UntypedMemberExpr(new NameExpr(castExpr->concrete_target.field), castExpr->arg->clone()) };
@@ -1303 +1303 @@
                 } catch(SemanticErrorException & ) {}
 
-                // Fallback : turn (thread&)X into (thread_desc&)get_thread(X)
+                // Fallback : turn (thread&)X into ($thread&)get_thread(X)
                 std::unique_ptr<Expression> fallback { UntypedExpr::createDeref( new UntypedExpr(new NameExpr(castExpr->concrete_target.getter), { castExpr->arg->clone() })) };
                 // don't prune here, since it's guaranteed all alternatives will have the same type

src/ResolvExpr/Resolver.cc

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Sun May 17 12:17:01 2015
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Wed May 29 11:00:00 2019
-// Update Count     : 241
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Mar 27 11:58:00 2020
+// Update Count     : 242
 //
 
@@ -560 +560 @@
                 // TODO: Replace *exception type with &exception type.
                 if ( throwStmt->get_expr() ) {
-                        const StructDecl * exception_decl = indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" );
+                        const StructDecl * exception_decl = indexer.lookupStruct( "__cfaehm_base_exception_t" );
                         assert( exception_decl );
                         Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, const_cast<StructDecl *>(exception_decl) ) );
@@ -1477 +1477 @@
                 if ( throwStmt->expr ) {
                         const ast::StructDecl * exceptionDecl =
-                                symtab.lookupStruct( "__cfaabi_ehm__base_exception_t" );
+                                symtab.lookupStruct( "__cfaehm_base_exception_t" );
                         assert( exceptionDecl );
                         ast::ptr< ast::Type > exceptType =

src/ResolvExpr/TypeEnvironment.cc

@@ -20 +20 @@
 #include <utility>                     // for pair, move
 
+#include "CompilationState.h"          // for deterministic_output
 #include "Common/utility.h"            // for maybeClone
 #include "SynTree/Type.h"              // for Type, FunctionType, Type::Fora...
@@ -106 +107 @@
 
         void EqvClass::print( std::ostream &os, Indenter indent ) const {
-                os << "( ";
-                std::copy( vars.begin(), vars.end(), std::ostream_iterator< std::string >( os, " " ) );
-                os << ")";
+                if( !deterministic_output ) {
+                        os << "( ";
+                        std::copy( vars.begin(), vars.end(), std::ostream_iterator< std::string >( os, " " ) );
+                        os << ")";
+                }
                 if ( type ) {
                         os << " -> ";
@@ -235 +238 @@
                 // check safely bindable
                 if ( r.type && occursIn( r.type, s.vars.begin(), s.vars.end(), *this ) ) return false;
-                
+
                 // merge classes in
                 r.vars.insert( s.vars.begin(), s.vars.end() );

src/SynTree/Declaration.h

@@ -302 +302 @@
 
         bool is_coroutine() { return kind == Coroutine; }
-        bool is_monitor() { return kind == Monitor; }
-        bool is_thread() { return kind == Thread; }
+        bool is_generator() { return kind == Generator; }
+        bool is_monitor  () { return kind == Monitor  ; }
+        bool is_thread   () { return kind == Thread   ; }
 
         virtual StructDecl * clone() const override { return new StructDecl( *this ); }

src/SynTree/LinkageSpec.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:22:09 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Dec 16 15:02:29 2019
-// Update Count     : 28
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Mar  2 16:13:00 2020
+// Update Count     : 29
 //
 
@@ -20 +20 @@
 
 #include "LinkageSpec.h"
+#include "Common/CodeLocation.h"
 #include "Common/SemanticError.h"
 

src/SynTree/LinkageSpec.h

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:24:28 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Dec 16 15:03:43 2019
-// Update Count     : 20
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Mar  2 16:13:00 2020
+// Update Count     : 21
 //
 
@@ -18 +18 @@
 #include <string>
 
-#include "Common/CodeLocation.h"
+struct CodeLocation;
 
 namespace LinkageSpec {

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 Type { 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;

src/main.cc

@@ -443 +443 @@
 
 
-static const char optstring[] = ":c:ghlLmNnpP:S:twW:D:";
+static const char optstring[] = ":c:ghlLmNnpdP:S:twW:D:";
 
 enum { PreludeDir = 128 };
@@ -456 +456 @@
         { "no-prelude", no_argument, nullptr, 'n' },
         { "prototypes", no_argument, nullptr, 'p' },
+        { "deterministic-out", no_argument, nullptr, 'd' },
         { "print", required_argument, nullptr, 'P' },
         { "prelude-dir", required_argument, nullptr, PreludeDir },
@@ -476 +477 @@
         "do not read prelude",                                // -n
         "generate prototypes for prelude functions",            // -p
+        "don't print output that isn't deterministic",        // -d
         "print",                                              // -P
         "<directory> prelude directory for debug/nodebug",      // no flag
@@ -580 +582 @@
                         genproto = true;
                         break;
+                  case 'd':                                     // don't print non-deterministic output
+                    deterministic_output = true;
+                        break;
                   case 'P':                                                                             // print options
                         for ( int i = 0;; i += 1 ) {