Changeset f265042

Timestamp:

Sep 25, 2017, 12:07:43 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

3aeaecd

Parents:

1755226 (diff), 596bc0a (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' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (2 diffs)
• Concurrency/Keywords.cc (modified) (1 diff)
• Concurrency/Waitfor.cc (modified) (20 diffs)
• Parser/StatementNode.cc (modified) (4 diffs)
• Parser/parserutility.cc (modified) (1 diff)
• ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• ResolvExpr/AlternativeFinder.h (modified) (3 diffs)
• ResolvExpr/Resolver.cc (modified) (4 diffs)
• ResolvExpr/Resolver.h (modified) (1 diff)
• SymTab/Mangler.cc (modified) (1 diff)
• SynTree/BaseSyntaxNode.h (modified) (1 diff)
• SynTree/CompoundStmt.cc (modified) (1 diff)
• SynTree/Constant.cc (modified) (1 diff)
• SynTree/Constant.h (modified) (1 diff)
• SynTree/Declaration.cc (modified) (1 diff)
• SynTree/Declaration.h (modified) (15 diffs)
• SynTree/Expression.cc (modified) (1 diff)
• SynTree/Expression.h (modified) (1 diff)
• SynTree/Initializer.cc (modified) (1 diff)
• SynTree/Initializer.h (modified) (6 diffs)
• SynTree/Statement.cc (modified) (3 diffs)
• SynTree/Statement.h (modified) (21 diffs)
• SynTree/Type.cc (modified) (1 diff)
• SynTree/Type.h (modified) (19 diffs)
• benchmark/bench.h (modified) (1 diff)
• libcfa/Makefile.am (modified) (1 diff)
• libcfa/Makefile.in (modified) (1 diff)
• libcfa/concurrency/coroutine.c (modified) (1 diff)
• libcfa/concurrency/invoke.h (modified) (2 diffs)
• libcfa/concurrency/kernel.c (modified) (5 diffs)
• libcfa/concurrency/monitor (modified) (3 diffs)
• libcfa/concurrency/monitor.c (modified) (24 diffs)
• libcfa/concurrency/preemption.c (modified) (1 diff)
• libcfa/concurrency/thread (modified) (1 diff)
• libcfa/concurrency/thread.c (modified) (1 diff)
• prelude/prelude.cf (modified) (2 diffs)
• tests/.expect/sched-ext-else.txt (added)
• tests/.expect/sched-ext-parse.txt (added)
• tests/Makefile.am (modified) (1 diff)
• tests/Makefile.in (modified) (1 diff)
• tests/sched-ext-else.c (added)
• tests/sched-ext-parse.c (modified) (1 diff)
• tests/sched-ext.c (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -879 +879 @@
 
         void CodeGenerator::postvisit( CaseStmt * caseStmt ) {
+                updateLocation( caseStmt );
+                output << indent;
                 if ( caseStmt->isDefault()) {
                         output << "default";
@@ -1020 +1022 @@
 } // namespace CodeGen
 
+std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node ) {
+        if ( node ) {
+                node->print( out );
+        } else {
+                out << "nullptr";
+        }
+        return out;
+}
+
 // Local Variables: //
 // tab-width: 4 //

src/Concurrency/Keywords.cc

@@ -528 +528 @@
                 DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
                 auto type  = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) );
-                // if( type ) std::cerr << "FRED2" << std::endl;
                 if( type && type->get_baseStruct()->is_thread() ) {
                         addStartStatement( decl, param );

src/Concurrency/Waitfor.cc

@@ -27 +27 @@
 #include "InitTweak/InitTweak.h"   // for getPointerBase
 #include "Parser/LinkageSpec.h"    // for Cforall
-#include "SymTab/AddVisit.h"       // for acceptAndAdd
+#include "ResolvExpr/Resolver.h"   // for findVoidExpression
 #include "SynTree/Constant.h"      // for Constant
 #include "SynTree/Declaration.h"   // for StructDecl, FunctionDecl, ObjectDecl
@@ -112 +112 @@
         //=============================================================================================
 
-        class GenerateWaitForPass final : public WithStmtsToAdd {
+        class GenerateWaitForPass final : public WithIndexer {
           public:
 
@@ -126 +126 @@
 
                 ObjectDecl * declare( unsigned long count, CompoundStmt * stmt );
+                ObjectDecl * declareFlag( CompoundStmt * stmt );
+                Statement  * makeSetter( ObjectDecl * flag );
                 ObjectDecl * declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt );
-                void         init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, CompoundStmt * stmt );
-                Expression * init_timeout( Expression *& time, Expression *& time_cond, bool has_else, Expression *& else_cond, CompoundStmt * stmt );
-                Expression * call();
-                void choose();
+                void         init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * settter, CompoundStmt * stmt );
+                Expression * init_timeout( Expression *& time, Expression *& time_cond, bool has_else, Expression *& else_cond, Statement * settter, CompoundStmt * stmt );
+                Expression * call(size_t count, ObjectDecl * acceptables, Expression * timeout, CompoundStmt * stmt);
+                void         choose( WaitForStmt * waitfor, Expression  * result, CompoundStmt * stmt );
 
                 static void implement( std::list< Declaration * > & translationUnit ) {
@@ -140 +142 @@
           private:
                 FunctionDecl        * decl_waitfor    = nullptr;
+                StructDecl          * decl_mask       = nullptr;
                 StructDecl          * decl_acceptable = nullptr;
                 StructDecl          * decl_monitor    = nullptr;
-                DeclarationWithType * decl_m_func     = nullptr;
-                DeclarationWithType * decl_m_count    = nullptr;
-                DeclarationWithType * decl_m_monitors = nullptr;
-                DeclarationWithType * decl_m_isdtor   = nullptr;
 
                 static std::unique_ptr< Type > generic_func;
 
+                UniqueName namer_acc = "__acceptables_"s;
+                UniqueName namer_idx = "__index_"s;
+                UniqueName namer_flg = "__do_run_"s;
+                UniqueName namer_msk = "__mask_"s;
                 UniqueName namer_mon = "__monitors_"s;
-                UniqueName namer_acc = "__acceptables_"s;
                 UniqueName namer_tim = "__timeout_"s;
         };
@@ -167 +169 @@
         namespace {
                 Expression * makeOpIndex( DeclarationWithType * array, unsigned long index ) {
-                        return new ApplicationExpr(
+                        return new UntypedExpr(
                                 new NameExpr( "?[?]" ),
                                 {
@@ -177 +179 @@
 
                 Expression * makeOpAssign( Expression * lhs, Expression * rhs ) {
-                        return new ApplicationExpr(
+                        return new UntypedExpr(
                                         new NameExpr( "?=?" ),
                                         { lhs, rhs }
@@ -183 +185 @@
                 }
 
-                Expression * makeOpMember( Expression * sue, DeclarationWithType * mem ) {
-                        return new MemberExpr( mem, sue );
-                }
-
-                Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, DeclarationWithType * member, Expression * value ) {
-                        return new ExprStmt(
-                                noLabels,
-                                makeOpAssign(
-                                        makeOpMember(
-                                                makeOpIndex(
-                                                        object,
-                                                        index
-                                                ),
-                                                member
+                Expression * makeOpMember( Expression * sue, const std::string & mem ) {
+                        return new UntypedMemberExpr( new NameExpr( mem ), sue );
+                }
+
+                Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, const std::string & member, Expression * value, const SymTab::Indexer & indexer ) {
+                        std::unique_ptr< Expression > expr( makeOpAssign(
+                                makeOpMember(
+                                        makeOpIndex(
+                                                object,
+                                                index
                                         ),
-                                        value
-                                )
-                        );
+                                        member
+                                ),
+                                value
+                        ) );
+
+                        return new ExprStmt( noLabels, ResolvExpr::findVoidExpression( expr.get(), indexer ) );
                 }
 
@@ -208 +209 @@
                         return new ConstantExpr( Constant::from_bool( ifnull ) );
                 }
+
+                VariableExpr * extractVariable( Expression * func ) {
+                        if( VariableExpr * var = dynamic_cast< VariableExpr * >( func ) ) {
+                                return var;
+                        }
+
+                        CastExpr * cast = strict_dynamic_cast< CastExpr * >( func );
+                        return strict_dynamic_cast< VariableExpr * >( cast->arg );
+                }
+
+                Expression * detectIsDtor( Expression * func ) {
+                        VariableExpr * typed_func = extractVariable( func );
+                        bool is_dtor = InitTweak::isDestructor( typed_func->var );
+                        return new ConstantExpr( Constant::from_bool( is_dtor ) );
+                }
         };
 
@@ -216 +232 @@
 
         void GenerateWaitForPass::premutate( FunctionDecl * decl) {
-                if( decl->name != "__accept_internal" ) return;
+                if( decl->name != "__waitfor_internal" ) return;
 
                 decl_waitfor = decl;
@@ -227 +243 @@
                         assert( !decl_acceptable );
                         decl_acceptable = decl;
-                        for( Declaration * field : decl_acceptable->members ) {
-                                     if( field->name == "func"    ) decl_m_func     = strict_dynamic_cast< DeclarationWithType * >( field );
-                                else if( field->name == "count"   ) decl_m_count    = strict_dynamic_cast< DeclarationWithType * >( field );
-                                else if( field->name == "monitor" ) decl_m_monitors = strict_dynamic_cast< DeclarationWithType * >( field );
-                                else if( field->name == "is_dtor" ) decl_m_isdtor   = strict_dynamic_cast< DeclarationWithType * >( field );
-                        }
-
+                }
+                else if( decl->name == "__waitfor_mask_t" ) {
+                        assert( !decl_mask );
+                        decl_mask = decl;
                 }
                 else if( decl->name == "monitor_desc" ) {
@@ -242 +255 @@
 
         Statement * GenerateWaitForPass::postmutate( WaitForStmt * waitfor ) {
-                return waitfor;
-
-                if( !decl_monitor || !decl_acceptable ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include <monitor>", waitfor );
+                if( !decl_monitor || !decl_acceptable || !decl_mask ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include <monitor>", waitfor );
 
                 CompoundStmt * stmt = new CompoundStmt( noLabels );
 
                 ObjectDecl * acceptables = declare( waitfor->clauses.size(), stmt );
+                ObjectDecl * flag        = declareFlag( stmt );
+                Statement  * setter      = makeSetter( flag );
 
                 int index = 0;
                 for( auto & clause : waitfor->clauses ) {
-                        init( acceptables, index, clause, stmt );
+                        init( acceptables, index, clause, setter, stmt );
 
                         index++;
@@ -262 +275 @@
                         waitfor->orelse .statement,
                         waitfor->orelse .condition,
+                        setter,
                         stmt
                 );
 
-                // Expression * result  = call( acceptables, timeout, orelse, stmt );
-
-                // choose( waitfor, result );
+                CompoundStmt * compound = new CompoundStmt( noLabels );
+                stmt->push_back( new IfStmt(
+                        noLabels,
+                        safeCond( new VariableExpr( flag ) ),
+                        compound,
+                        nullptr
+                ));
+
+                Expression * result = call( waitfor->clauses.size(), acceptables, timeout, compound );
+
+                choose( waitfor, result, compound );
 
                 return stmt;
@@ -274 +296 @@
         ObjectDecl * GenerateWaitForPass::declare( unsigned long count, CompoundStmt * stmt )
         {
-                ObjectDecl * acceptables = new ObjectDecl(
+                ObjectDecl * acceptables = ObjectDecl::newObject(
                         namer_acc.newName(),
-                        noStorage,
-                        LinkageSpec::Cforall,
-                        nullptr,
                         new ArrayType(
                                 noQualifiers,
@@ -294 +313 @@
                 stmt->push_back( new DeclStmt( noLabels, acceptables) );
 
+                UntypedExpr * set = new UntypedExpr(
+                        new NameExpr( "__builtin_memset" ),
+                        {
+                                new VariableExpr( acceptables ),
+                                new ConstantExpr( Constant::from_int( 0 ) ),
+                                new SizeofExpr( new VariableExpr( acceptables ) )
+                        }
+                );
+
+                Expression * resolved_set = ResolvExpr::findVoidExpression( set, indexer );
+                delete set;
+
+                stmt->push_back( new ExprStmt( noLabels, resolved_set ) );
+
                 return acceptables;
         }
 
+        ObjectDecl * GenerateWaitForPass::declareFlag( CompoundStmt * stmt ) {
+                ObjectDecl * flag = ObjectDecl::newObject(
+                        namer_flg.newName(),
+                        new BasicType(
+                                noQualifiers,
+                                BasicType::Bool
+                        ),
+                        new SingleInit( new ConstantExpr( Constant::from_ulong( 0 ) ) )
+                );
+
+                stmt->push_back( new DeclStmt( noLabels, flag) );
+
+                return flag;
+        }
+
+        Statement * GenerateWaitForPass::makeSetter( ObjectDecl * flag ) {
+                Expression * untyped = new UntypedExpr(
+                        new NameExpr( "?=?" ),
+                        {
+                                new VariableExpr( flag ),
+                                new ConstantExpr( Constant::from_ulong( 1 ) )
+                        }
+                );
+
+                Expression * expr = ResolvExpr::findVoidExpression( untyped, indexer );
+                delete untyped;
+
+                return new ExprStmt( noLabels, expr );
+        }
+
         ObjectDecl * GenerateWaitForPass::declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt ) {
 
-                ObjectDecl * mon = new ObjectDecl(
+                ObjectDecl * mon = ObjectDecl::newObject(
                         namer_mon.newName(),
-                        noStorage,
-                        LinkageSpec::Cforall,
-                        nullptr,
                         new ArrayType(
                                 noQualifiers,
-                                new StructInstType(
+                                new PointerType(
                                         noQualifiers,
-                                        decl_monitor
+                                        new StructInstType(
+                                                noQualifiers,
+                                                decl_monitor
+                                        )
                                 ),
                                 new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ),
@@ -316 +379 @@
                         new ListInit(
                                 map_range < std::list<Initializer*> > ( clause.target.arguments, [this](Expression * expr ){
-                                        return new SingleInit( expr );
+                                        Expression * untyped = new CastExpr(
+                                                new UntypedExpr(
+                                                        new NameExpr( "get_monitor" ),
+                                                        { expr }
+                                                ),
+                                                new PointerType(
+                                                        noQualifiers,
+                                                        new StructInstType(
+                                                                noQualifiers,
+                                                                decl_monitor
+                                                        )
+                                                )
+                                        );
+
+                                        Expression * init = ResolvExpr::findSingleExpression( untyped, indexer );
+                                        delete untyped;
+                                        return new SingleInit( init );
                                 })
                         )
@@ -326 +405 @@
         }
 
-        void GenerateWaitForPass::init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, CompoundStmt * stmt ) {
+        void GenerateWaitForPass::init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * setter, CompoundStmt * stmt ) {
 
                 ObjectDecl * monitors = declMon( clause, stmt );
 
-                CompoundStmt * compound = new CompoundStmt( noLabels );
-                compound->push_back( makeAccStatement( acceptables, index, decl_m_func    , clause.target.function ) );
-                compound->push_back( makeAccStatement( acceptables, index, decl_m_count   , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ) ) );
-                compound->push_back( makeAccStatement( acceptables, index, decl_m_monitors, new VariableExpr( monitors ) ) );
-                compound->push_back( makeAccStatement( acceptables, index, decl_m_isdtor  , new ConstantExpr( Constant::from_bool( true ) ) ) );
+                Type * fptr_t = new PointerType( noQualifiers, new FunctionType( noQualifiers, true ) );
 
                 stmt->push_back( new IfStmt(
                         noLabels,
                         safeCond( clause.condition ),
-                        compound,
+                        new CompoundStmt({
+                                makeAccStatement( acceptables, index, "is_dtor", detectIsDtor( clause.target.function )                                    , indexer ),
+                                makeAccStatement( acceptables, index, "func"   , new CastExpr( clause.target.function, fptr_t )                            , indexer ),
+                                makeAccStatement( acceptables, index, "list"   , new VariableExpr( monitors )                                              , indexer ),
+                                makeAccStatement( acceptables, index, "size"   , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ), indexer ),
+                                setter->clone()
+                        }),
                         nullptr
                 ));
@@ -353 +434 @@
                 bool has_else,
                 Expression *& else_cond,
+                Statement * setter,
                 CompoundStmt * stmt
         ) {
-                ObjectDecl * timeout = new ObjectDecl(
+                ObjectDecl * timeout = ObjectDecl::newObject(
                         namer_tim.newName(),
-                        noStorage,
-                        LinkageSpec::Cforall,
-                        nullptr,
                         new BasicType(
                                 noQualifiers,
@@ -374 +453 @@
                         stmt->push_back( new IfStmt(
                                 noLabels,
-                                safeCond( else_cond ),
-                                new ExprStmt(
-                                        noLabels,
-                                        makeOpAssign(
-                                                new VariableExpr( timeout ),
-                                                time
-                                        )
-                                ),
+                                safeCond( time_cond ),
+                                new CompoundStmt({
+                                        new ExprStmt(
+                                                noLabels,
+                                                makeOpAssign(
+                                                        new VariableExpr( timeout ),
+                                                        time
+                                                )
+                                        ),
+                                        setter->clone()
+                                }),
                                 nullptr
                         ));
@@ -392 +474 @@
                                 noLabels,
                                 safeCond( else_cond ),
-                                new ExprStmt(
-                                        noLabels,
-                                        makeOpAssign(
-                                                new VariableExpr( timeout ),
-                                                new ConstantExpr( Constant::from_ulong( 0 ) )
-                                        )
-                                ),
+                                new CompoundStmt({
+                                        new ExprStmt(
+                                                noLabels,
+                                                makeOpAssign(
+                                                        new VariableExpr( timeout ),
+                                                        new ConstantExpr( Constant::from_ulong( 0 ) )
+                                                )
+                                        ),
+                                        setter->clone()
+                                }),
                                 nullptr
                         ));
@@ -405 +490 @@
                 }
 
+                delete setter;
+
                 return new VariableExpr( timeout );
+        }
+
+        Expression * GenerateWaitForPass::call(
+                size_t count,
+                ObjectDecl * acceptables,
+                Expression * timeout,
+                CompoundStmt * stmt
+        ) {
+                ObjectDecl * index = ObjectDecl::newObject(
+                        namer_idx.newName(),
+                        new BasicType(
+                                noQualifiers,
+                                BasicType::ShortSignedInt
+                        ),
+                        new SingleInit(
+                                new ConstantExpr( Constant::from_int( -1 ) )
+                        )
+                );
+
+                stmt->push_back( new DeclStmt( noLabels, index ) );
+
+                ObjectDecl * mask = ObjectDecl::newObject(
+                        namer_msk.newName(),
+                        new StructInstType(
+                                noQualifiers,
+                                decl_mask
+                        ),
+                        new ListInit({
+                                new SingleInit( new AddressExpr( new VariableExpr( index ) ) ),
+                                new SingleInit( new VariableExpr( acceptables ) ),
+                                new SingleInit( new ConstantExpr( Constant::from_ulong( count ) ) )
+                        })
+                );
+
+                stmt->push_back( new DeclStmt( noLabels, mask ) );
+
+                stmt->push_back( new ExprStmt(
+                        noLabels,
+                        new ApplicationExpr(
+                                VariableExpr::functionPointer( decl_waitfor ),
+                                {
+                                        new CastExpr(
+                                                new VariableExpr( mask ),
+                                                new ReferenceType(
+                                                        noQualifiers,
+                                                        new StructInstType(
+                                                                noQualifiers,
+                                                                decl_mask
+                                                        )
+                                                )
+                                        ),
+                                        timeout
+                                }
+                        )
+                ));
+
+                return new VariableExpr( index );
+        }
+
+        void GenerateWaitForPass::choose(
+                WaitForStmt * waitfor,
+                Expression  * result,
+                CompoundStmt * stmt
+        ) {
+                SwitchStmt * swtch = new SwitchStmt(
+                        noLabels,
+                        result,
+                        std::list<Statement *>()
+                );
+
+                unsigned long i = 0;
+                for( auto & clause : waitfor->clauses ) {
+                        swtch->statements.push_back(
+                                new CaseStmt(
+                                        noLabels,
+                                        new ConstantExpr( Constant::from_ulong( i++ ) ),
+                                        {
+                                                clause.statement,
+                                                new BranchStmt(
+                                                        noLabels,
+                                                        "",
+                                                        BranchStmt::Break
+                                                )
+                                        }
+                                )
+                        );
+                }
+
+                if(waitfor->timeout.statement) {
+                        swtch->statements.push_back(
+                                new CaseStmt(
+                                        noLabels,
+                                        new ConstantExpr( Constant::from_int( -2 ) ),
+                                        {
+                                                waitfor->timeout.statement,
+                                                new BranchStmt(
+                                                        noLabels,
+                                                        "",
+                                                        BranchStmt::Break
+                                                )
+                                        }
+                                )
+                        );
+                }
+
+                if(waitfor->orelse.statement) {
+                        swtch->statements.push_back(
+                                new CaseStmt(
+                                        noLabels,
+                                        new ConstantExpr( Constant::from_int( -1 ) ),
+                                        {
+                                                waitfor->orelse.statement,
+                                                new BranchStmt(
+                                                        noLabels,
+                                                        "",
+                                                        BranchStmt::Break
+                                                )
+                                        }
+                                )
+                        );
+                }
+
+                stmt->push_back( swtch );
         }
 };

src/Parser/StatementNode.cc

@@ -234 +234 @@
                 target,
                 maybeMoveBuild<Statement >( stmt ),
-                maybeMoveBuild<Expression>( when )
+                notZeroExpr( maybeMoveBuild<Expression>( when ) )
         });
 
@@ -250 +250 @@
         delete targetExpr;
 
-        node->clauses.push_back( WaitForStmt::Clause{
+        node->clauses.insert( node->clauses.begin(), WaitForStmt::Clause{
                 std::move( target ),
                 maybeMoveBuild<Statement >( stmt ),
-                maybeMoveBuild<Expression>( when )
+                notZeroExpr( maybeMoveBuild<Expression>( when ) )
         });
 
@@ -265 +265 @@
                 node->timeout.time      = maybeMoveBuild<Expression>( timeout );
                 node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
-                node->timeout.condition = maybeMoveBuild<Expression>( when    );
+                node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
         }
         else {
-                node->orelse.statement  = maybeMoveBuild<Statement >( stmt    );
-                node->orelse.condition  = maybeMoveBuild<Expression>( when    );
+                node->orelse.statement  = maybeMoveBuild<Statement >( stmt );
+                node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( when ) );
         }
 
@@ -280 +280 @@
         node->timeout.time      = maybeMoveBuild<Expression>( timeout );
         node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
-        node->timeout.condition = maybeMoveBuild<Expression>( when    );
+        node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
 
         node->orelse.statement = maybeMoveBuild<Statement >( else_stmt );
-        node->orelse.condition = maybeMoveBuild<Expression>( else_when );
+        node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( else_when ) );
 
         return node;
 }
-
-// WaitForStmt::Target build_waitfor( const std::string * name, ExpressionNode * arguments ) {
-//       return WaitForStmt::Clause{
-
-//       };
-// }
 
 Statement *build_compound( StatementNode *first ) {

src/Parser/parserutility.cc

@@ -29 +29 @@
 
 Expression *notZeroExpr( Expression *orig ) {
+        if( !orig ) return nullptr;
         UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) );
         comparison->get_args().push_back( orig );

src/ResolvExpr/AlternativeFinder.cc

@@ -144 +144 @@
                         expr->get_result()->accept( global_renamer );
                 }
-
-                void referenceToRvalueConversion( Expression *& expr ) {
-                        if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
-                                // cast away reference from expr
-                                expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() );
-                        }
-                }
         } // namespace
+
+        void referenceToRvalueConversion( Expression *& expr ) {
+                if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
+                        // cast away reference from expr
+                        expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() );
+                }
+        }
 
         template< typename InputIterator, typename OutputIterator >

src/ResolvExpr/AlternativeFinder.h

@@ -50 +50 @@
                 const SymTab::Indexer &get_indexer() const { return indexer; }
                 const TypeEnvironment &get_environ() const { return env; }
+
+                /// Runs a new alternative finder on each element in [begin, end)
+                /// and writes each alternative finder to out.
+                template< typename InputIterator, typename OutputIterator >
+                void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
           private:
                 virtual void visit( ApplicationExpr *applicationExpr );
@@ -81 +86 @@
                 virtual void visit( StmtExpr *stmtExpr );
                 virtual void visit( UntypedInitExpr *initExpr );
-                /// Runs a new alternative finder on each element in [begin, end)
-                /// and writes each alternative finder to out.
-                template< typename InputIterator, typename OutputIterator >
-                void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
 
                 /// Adds alternatives for anonymous members
@@ -108 +109 @@
 
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env );
+        void referenceToRvalueConversion( Expression *& expr );
 
         template< typename InputIterator, typename OutputIterator >

src/ResolvExpr/Resolver.cc

@@ -40 +40 @@
 #include "SynTree/Visitor.h"             // for acceptAll, maybeAccept
 #include "typeops.h"                     // for extractResultType
+#include "Unify.h"                       // for unify
 
 using namespace std;
@@ -71 +72 @@
                 void previsit( ThrowStmt *throwStmt );
                 void previsit( CatchStmt *catchStmt );
+                void previsit( WaitForStmt * stmt );
 
                 void previsit( SingleInit *singleInit );
@@ -121 +123 @@
         }
 
+        Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
+                TypeEnvironment env;
+                AlternativeFinder finder( indexer, env );
+                finder.find( untyped );
+                #if 0
+                if ( finder.get_alternatives().size() != 1 ) {
+                        std::cout << "untyped expr is ";
+                        untyped->print( std::cout );
+                        std::cout << std::endl << "alternatives are:";
+                        for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
+                                i->print( std::cout );
+                        } // for
+                } // if
+                #endif
+                assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
+                Alternative &choice = finder.get_alternatives().front();
+                Expression *newExpr = choice.expr->clone();
+                finishExpr( newExpr, choice.env );
+                return newExpr;
+        }
+
         namespace {
-                Expression *findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
-                        TypeEnvironment env;
-                        AlternativeFinder finder( indexer, env );
-                        finder.find( untyped );
-#if 0
-                        if ( finder.get_alternatives().size() != 1 ) {
-                                std::cout << "untyped expr is ";
-                                untyped->print( std::cout );
-                                std::cout << std::endl << "alternatives are:";
-                                for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
-                                        i->print( std::cout );
-                                } // for
-                        } // if
-#endif
-                        assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
-                        Alternative &choice = finder.get_alternatives().front();
-                        Expression *newExpr = choice.expr->clone();
-                        finishExpr( newExpr, choice.env );
-                        return newExpr;
-                }
-
                 bool isIntegralType( Type *type ) {
                         if ( dynamic_cast< EnumInstType * >( type ) ) {
@@ -396 +398 @@
         }
 
+        inline void resolveAsIf( Expression *& expr, SymTab::Indexer & indexer ) {
+                if( !expr ) return;
+                Expression * newExpr = findSingleExpression( expr, indexer );
+                delete expr;
+                expr = newExpr;
+        }
+
+        inline void resolveAsType( Expression *& expr, Type * type, SymTab::Indexer & indexer ) {
+                if( !expr ) return;
+                Expression * newExpr = findSingleExpression( new CastExpr( expr, type ), indexer );
+                delete expr;
+                expr = newExpr;
+        }
+
+        template< typename iterator_t >
+        inline bool advance_to_mutex( iterator_t & it, const iterator_t & end ) {
+                while( it != end && !(*it)->get_type()->get_mutex() ) {
+                        it++;
+                }
+
+                return it != end;
+        }
+
+        void Resolver::previsit( WaitForStmt * stmt ) {
+                visit_children = false;
+
+                // Resolve all clauses first
+                for( auto& clause : stmt->clauses ) {
+
+                        TypeEnvironment env;
+                        AlternativeFinder funcFinder( indexer, env );
+
+                        // Find all alternatives for a function in canonical form
+                        funcFinder.findWithAdjustment( clause.target.function );
+
+                        if ( funcFinder.get_alternatives().empty() ) {
+                                stringstream ss;
+                                ss << "Use of undeclared indentifier '";
+                                ss << strict_dynamic_cast<NameExpr*>( clause.target.function )->name;
+                                ss << "' in call to waitfor";
+                                throw SemanticError( ss.str() );
+                        }
+
+                        // Find all alternatives for all arguments in canonical form
+                        std::list< AlternativeFinder > argAlternatives;
+                        funcFinder.findSubExprs( clause.target.arguments.begin(), clause.target.arguments.end(), back_inserter( argAlternatives ) );
+
+                        // List all combinations of arguments
+                        std::list< AltList > possibilities;
+                        combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
+
+                        AltList                func_candidates;
+                        std::vector< AltList > args_candidates;
+
+                        // For every possible function :
+                        //      try matching the arguments to the parameters
+                        //      not the other way around because we have more arguments than parameters
+                        SemanticError errors;
+                        for ( Alternative & func : funcFinder.get_alternatives() ) {
+                                try {
+                                        PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() );
+                                        if( !pointer ) {
+                                                throw SemanticError( "candidate not viable: not a pointer type\n", func.expr->get_result() );
+                                        }
+
+                                        FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() );
+                                        if( !function ) {
+                                                throw SemanticError( "candidate not viable: not a function type\n", pointer->get_base() );
+                                        }
+
+
+                                        {
+                                                auto param     = function->parameters.begin();
+                                                auto param_end = function->parameters.end();
+
+                                                if( !advance_to_mutex( param, param_end ) ) {
+                                                        throw SemanticError("candidate function not viable: no mutex parameters\n", function);
+                                                }
+                                        }
+
+                                        Alternative newFunc( func );
+                                        // Strip reference from function
+                                        referenceToRvalueConversion( newFunc.expr );
+
+                                        // For all the set of arguments we have try to match it with the parameter of the current function alternative
+                                        for ( auto & argsList : possibilities ) {
+
+                                                try {
+                                                        // Declare data structures need for resolution
+                                                        OpenVarSet openVars;
+                                                        AssertionSet resultNeed, resultHave;
+                                                        TypeEnvironment resultEnv;
+
+                                                        // Load type variables from arguemnts into one shared space
+                                                        simpleCombineEnvironments( argsList.begin(), argsList.end(), resultEnv );
+
+                                                        // Make sure we don't widen any existing bindings
+                                                        for ( auto & i : resultEnv ) {
+                                                                i.allowWidening = false;
+                                                        }
+
+                                                        // Find any unbound type variables
+                                                        resultEnv.extractOpenVars( openVars );
+
+                                                        auto param     = function->parameters.begin();
+                                                        auto param_end = function->parameters.end();
+
+                                                        // For every arguments of its set, check if it matches one of the parameter
+                                                        // The order is important
+                                                        for( auto & arg : argsList ) {
+
+                                                                // Ignore non-mutex arguments
+                                                                if( !advance_to_mutex( param, param_end ) ) {
+                                                                        // We ran out of parameters but still have arguments
+                                                                        // this function doesn't match
+                                                                        throw SemanticError("candidate function not viable: too many mutex arguments\n", function);
+                                                                }
+
+                                                                // Check if the argument matches the parameter type in the current scope
+                                                                if( ! unify( (*param)->get_type(), arg.expr->get_result(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) {
+                                                                        // Type doesn't match
+                                                                        stringstream ss;
+                                                                        ss << "candidate function not viable: no known convertion from '";
+                                                                        arg.expr->get_result()->print( ss );
+                                                                        ss << "' to '";
+                                                                        (*param)->get_type()->print( ss );
+                                                                        ss << "'\n";
+                                                                        throw SemanticError(ss.str(), function);
+                                                                }
+
+                                                                param++;
+                                                        }
+
+                                                        // All arguments match !
+
+                                                        // Check if parameters are missing
+                                                        if( advance_to_mutex( param, param_end ) ) {
+                                                                // We ran out of arguments but still have parameters left
+                                                                // this function doesn't match
+                                                                throw SemanticError("candidate function not viable: too few mutex arguments\n", function);
+                                                        }
+
+                                                        // All parameters match !
+
+                                                        // Finish the expressions to tie in the proper environments
+                                                        finishExpr( newFunc.expr, resultEnv );
+                                                        for( Alternative & alt : argsList ) {
+                                                                finishExpr( alt.expr, resultEnv );
+                                                        }
+
+                                                        // This is a match store it and save it for later
+                                                        func_candidates.push_back( newFunc );
+                                                        args_candidates.push_back( argsList );
+
+                                                }
+                                                catch( SemanticError &e ) {
+                                                        errors.append( e );
+                                                }
+                                        }
+                                }
+                                catch( SemanticError &e ) {
+                                        errors.append( e );
+                                }
+                        }
+
+                        // Make sure we got the right number of arguments
+                        if( func_candidates.empty() )    { SemanticError top( "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
+                        if( args_candidates.empty() )    { SemanticError top( "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
+                        if( func_candidates.size() > 1 ) { SemanticError top( "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
+                        if( args_candidates.size() > 1 ) { SemanticError top( "Ambiguous arguments in call to waitfor"           ); top.append( errors ); throw top; }
+
+
+                        // Swap the results from the alternative with the unresolved values.
+                        // Alternatives will handle deletion on destruction
+                        std::swap( clause.target.function, func_candidates.front().expr );
+                        for( auto arg_pair : group_iterate( clause.target.arguments, args_candidates.front() ) ) {
+                                std::swap ( std::get<0>( arg_pair), std::get<1>( arg_pair).expr );
+                        }
+
+                        // Resolve the conditions as if it were an IfStmt
+                        // Resolve the statments normally
+                        resolveAsIf( clause.condition, this->indexer );
+                        clause.statement->accept( *visitor );
+                }
+
+
+                if( stmt->timeout.statement ) {
+                        // Resolve the timeout as an size_t for now
+                        // Resolve the conditions as if it were an IfStmt
+                        // Resolve the statments normally
+                        resolveAsType( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), this->indexer );
+                        resolveAsIf  ( stmt->timeout.condition, this->indexer );
+                        stmt->timeout.statement->accept( *visitor );
+                }
+
+                if( stmt->orelse.statement ) {
+                        // Resolve the conditions as if it were an IfStmt
+                        // Resolve the statments normally
+                        resolveAsIf( stmt->orelse.condition, this->indexer );
+                        stmt->orelse.statement->accept( *visitor );
+                }
+        }
+
         template< typename T >
         bool isCharType( T t ) {

src/ResolvExpr/Resolver.h

@@ -32 +32 @@
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer );
         Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer );
+        Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer );
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );

src/SymTab/Mangler.cc

@@ -307 +307 @@
                         mangleName << "V";
                 } // if
+                if ( type->get_mutex() ) {
+                        mangleName << "M";
+                } // if
                 // Removed due to restrict not affecting function compatibility in GCC
 //              if ( type->get_isRestrict() ) {

src/SynTree/BaseSyntaxNode.h

@@ -26 +26 @@
 
         virtual void accept( Visitor & v ) = 0;
-  virtual void print( std::ostream & os, int indent = 0 ) const = 0;
+        virtual void print( std::ostream & os, int indent = 0 ) const = 0;
 };
+
+std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node );
 
 // Local Variables: //

src/SynTree/CompoundStmt.cc

@@ -29 +29 @@
 
 CompoundStmt::CompoundStmt( std::list<Label> labels ) : Statement( labels ) {
+}
+
+CompoundStmt::CompoundStmt( std::list<Statement *> stmts ) : Statement( noLabels ), kids( stmts ) {
 }
 

src/SynTree/Constant.cc

@@ -32 +32 @@
 Constant Constant::from_bool( bool b ) {
         return Constant( new BasicType( Type::Qualifiers(), BasicType::Bool ), b ? "1" : "0" , (unsigned long long int)b );
+}
+
+Constant Constant::from_char( char c ) {
+        return Constant( new BasicType( Type::Qualifiers(), BasicType::Char ), std::to_string( c ), (unsigned long long int)c );
 }
 

src/SynTree/Constant.h

@@ -40 +40 @@
         /// generates a boolean constant of the given bool
         static Constant from_bool( bool b );
+        /// generates a char constant of the given char
+        static Constant from_char( char c );
         /// generates an integer constant of the given int
         static Constant from_int( int i );

src/SynTree/Declaration.cc

@@ -59 +59 @@
 }
 
-std::ostream & operator<<( std::ostream & out, const Declaration * decl ) {
-        if ( decl ){
-                decl->print( out );
-        } else {
-                out << "nullptr";
-        }
-        return out;
-}
-
 
 AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), stmt( stmt ) {

src/SynTree/Declaration.h

@@ -62 +62 @@
         void fixUniqueId( void );
         virtual Declaration *clone() const = 0;
-        virtual void accept( Visitor &v ) = 0;
+        virtual void accept( Visitor &v ) override = 0;
         virtual Declaration *acceptMutator( Mutator &m ) = 0;
-        virtual void print( std::ostream &os, int indent = 0 ) const = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
         virtual void printShort( std::ostream &os, int indent = 0 ) const = 0;
 
@@ -106 +106 @@
         //void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
 
-        virtual DeclarationWithType *clone() const = 0;
-        virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
+        virtual DeclarationWithType *clone() const override = 0;
+        virtual DeclarationWithType *acceptMutator( Mutator &m )  override = 0;
 
         virtual Type * get_type() const = 0;
@@ -128 +128 @@
         virtual ~ObjectDecl();
 
-        virtual Type * get_type() const { return type; }
-        virtual void set_type(Type *newType) { type = newType; }
+        virtual Type * get_type() const override { return type; }
+        virtual void set_type(Type *newType) override { type = newType; }
 
         Initializer *get_init() const { return init; }
@@ -139 +139 @@
         static ObjectDecl * newObject( const std::string & name, Type * type, Initializer * init );
 
-        virtual ObjectDecl *clone() const { return new ObjectDecl( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual DeclarationWithType *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-        virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        virtual ObjectDecl *clone() const override { return new ObjectDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -157 +157 @@
         virtual ~FunctionDecl();
 
-        Type * get_type() const { return type; }
-        virtual void set_type(Type * t) { type = strict_dynamic_cast< FunctionType* >( t ); }
+        virtual Type * get_type() const override { return type; }
+        virtual void set_type(Type * t) override { type = strict_dynamic_cast< FunctionType* >( t ); }
 
         FunctionType * get_functionType() const { return type; }
@@ -165 +165 @@
         void set_statements( CompoundStmt *newValue ) { statements = newValue; }
 
-        virtual FunctionDecl *clone() const { return new FunctionDecl( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual DeclarationWithType *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-        virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        virtual FunctionDecl *clone() const override { return new FunctionDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -190 +190 @@
         virtual std::string typeString() const = 0;
 
-        virtual NamedTypeDecl *clone() const = 0;
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-        virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        virtual NamedTypeDecl *clone() const override = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -227 +227 @@
         TypeDecl * set_sized( bool newValue ) { sized = newValue; return this; }
 
-        virtual std::string typeString() const;
+        virtual std::string typeString() const override;
         virtual std::string genTypeString() const;
 
-        virtual TypeDecl *clone() const { return new TypeDecl( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual TypeDecl *clone() const override { return new TypeDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 
   private:
@@ -245 +245 @@
         TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
 
-        virtual std::string typeString() const;
-
-        virtual TypedefDecl *clone() const { return new TypedefDecl( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual std::string typeString() const override;
+
+        virtual TypedefDecl *clone() const override { return new TypedefDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
 };
@@ -274 +274 @@
         AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
 
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-        virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
   protected:
         virtual std::string typeString() const = 0;
@@ -290 +290 @@
         bool is_thread() { return kind == DeclarationNode::Thread; }
 
-        virtual StructDecl *clone() const { return new StructDecl( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual StructDecl *clone() const override { return new StructDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
         DeclarationNode::Aggregate kind;
-        virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 
@@ -304 +304 @@
         UnionDecl( const UnionDecl &other ) : Parent( other ) {}
 
-        virtual UnionDecl *clone() const { return new UnionDecl( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-  private:
-        virtual std::string typeString() const;
+        virtual UnionDecl *clone() const override { return new UnionDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const override;
 };
 
@@ -317 +317 @@
         EnumDecl( const EnumDecl &other ) : Parent( other ) {}
 
-        virtual EnumDecl *clone() const { return new EnumDecl( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-  private:
-        virtual std::string typeString() const;
+        virtual EnumDecl *clone() const override { return new EnumDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const override;
 };
 
@@ -332 +332 @@
         TraitDecl( const TraitDecl &other ) : Parent( other ) {}
 
-        virtual TraitDecl *clone() const { return new TraitDecl( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-  private:
-        virtual std::string typeString() const;
+        virtual TraitDecl *clone() const override { return new TraitDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const override;
 };
 
@@ -350 +350 @@
         void set_stmt( AsmStmt *newValue ) { stmt = newValue; }
 
-        virtual AsmDecl *clone() const { return new AsmDecl( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual AsmDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-        virtual void printShort( std::ostream &os, int indent = 0 ) const;
-};
-
-std::ostream & operator<<( std::ostream & out, const Declaration * decl );
+        virtual AsmDecl *clone() const override { return new AsmDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual AsmDecl *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
+};
+
 std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );
 

src/SynTree/Expression.cc

@@ -741 +741 @@
 }
 
-
-std::ostream & operator<<( std::ostream & out, const Expression * expr ) {
-        if ( expr ) {
-                expr->print( out );
-        } else {
-                out << "nullptr";
-        }
-        return out;
-}
-
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Expression.h

@@ -821 +821 @@
 };
 
-
-std::ostream & operator<<( std::ostream & out, const Expression * expr );
-
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Initializer.cc

@@ -137 +137 @@
 }
 
-std::ostream & operator<<( std::ostream & out, const Initializer * init ) {
-        if ( init ) {
-                init->print( out );
-        } else {
-                out << "nullptr";
-        }
-        return out;
-}
-
-std::ostream & operator<<( std::ostream & out, const Designation * des ) {
-        if ( des ) {
-                des->print( out );
-        } else {
-                out << "nullptr";
-        }
-        return out;
-}
-
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Initializer.h

@@ -38 +38 @@
 
         virtual Designation * clone() const { return new Designation( *this ); };
-        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
         virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -55 +55 @@
 
         virtual Initializer *clone() const = 0;
-        virtual void accept( Visitor &v ) = 0;
+        virtual void accept( Visitor &v ) override = 0;
         virtual Initializer *acceptMutator( Mutator &m ) = 0;
-        virtual void print( std::ostream &os, int indent = 0 ) const = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
   private:
         bool maybeConstructed;
@@ -75 +75 @@
         void set_value( Expression *newValue ) { value = newValue; }
 
-        virtual SingleInit *clone() const { return new SingleInit( *this); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual SingleInit *clone() const override { return new SingleInit( *this); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -103 +103 @@
         const_iterator end() const { return initializers.end(); }
 
-        virtual ListInit *clone() const { return new ListInit( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual ListInit *clone() const override { return new ListInit( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -129 +129 @@
         Initializer * get_init() const { return init; }
 
-        ConstructorInit *clone() const { return new ConstructorInit( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        ConstructorInit *clone() const override { return new ConstructorInit( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 
   private:
@@ -140 +140 @@
 };
 
-std::ostream & operator<<( std::ostream & out, const Initializer * init );
-std::ostream & operator<<( std::ostream & out, const Designation * des );
-
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Statement.cc

@@ -168 +168 @@
 }
 
-SwitchStmt::SwitchStmt( std::list<Label> labels, Expression * condition, std::list<Statement *> &statements ):
+SwitchStmt::SwitchStmt( std::list<Label> labels, Expression * condition, const std::list<Statement *> &statements ):
         Statement( labels ), condition( condition ), statements( statements ) {
 }
@@ -196 +196 @@
 }
 
-CaseStmt::CaseStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
+CaseStmt::CaseStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
         Statement( labels ), condition( condition ), stmts( statements ), _isDefault( deflt ) {
         if ( isDefault() && condition != 0 )
@@ -497 +497 @@
 }
 
-std::ostream & operator<<( std::ostream & out, const Statement * statement ) {
-        if ( statement ) {
-                statement->print( out );
-        } else {
-                out << "nullptr";
-        }
-        return out;
-}
-
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Statement.h

@@ -44 +44 @@
 
         virtual Statement *clone() const = 0;
-        virtual void accept( Visitor &v ) = 0;
+        virtual void accept( Visitor &v ) override = 0;
         virtual Statement *acceptMutator( Mutator &m ) = 0;
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -54 +54 @@
 
         CompoundStmt( std::list<Label> labels );
+        CompoundStmt( std::list<Statement *> stmts );
         CompoundStmt( const CompoundStmt &other );
         virtual ~CompoundStmt();
@@ -61 +62 @@
         void push_front( Statement * stmt ) { kids.push_front( stmt ); }
 
-        virtual CompoundStmt *clone() const { return new CompoundStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual CompoundStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual CompoundStmt *clone() const override { return new CompoundStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual CompoundStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -72 +73 @@
         NullStmt( std::list<Label> labels );
 
-        virtual NullStmt *clone() const { return new NullStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual NullStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual NullStmt *clone() const override { return new NullStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual NullStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -89 +90 @@
         void set_expr( Expression *newValue ) { expr = newValue; }
 
-        virtual ExprStmt *clone() const { return new ExprStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual ExprStmt *clone() const override { return new ExprStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -146 +147 @@
         void set_elsePart( Statement *newValue ) { elsePart = newValue; }
 
-        virtual IfStmt *clone() const { return new IfStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual IfStmt *clone() const override { return new IfStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -157 +158 @@
         std::list<Statement *> statements;
 
-        SwitchStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &statements );
+        SwitchStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements );
         SwitchStmt( const SwitchStmt &other );
         virtual ~SwitchStmt();
@@ -166 +167 @@
         std::list<Statement *> & get_statements() { return statements; }
 
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-
-        virtual SwitchStmt *clone() const { return new SwitchStmt( *this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+
+        virtual SwitchStmt *clone() const override { return new SwitchStmt( *this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 
 };
@@ -179 +180 @@
         std::list<Statement *> stmts;
 
-        CaseStmt( std::list<Label> labels, Expression *conditions, std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
+        CaseStmt( std::list<Label> labels, Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
         CaseStmt( const CaseStmt &other );
         virtual ~CaseStmt();
@@ -194 +195 @@
         void set_statements( std::list<Statement *> &newValue ) { stmts = newValue; }
 
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-
-        virtual CaseStmt *clone() const { return new CaseStmt( *this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+
+        virtual CaseStmt *clone() const override { return new CaseStmt( *this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
   private:
         bool _isDefault;
@@ -221 +222 @@
         void set_isDoWhile( bool newValue ) { isDoWhile = newValue; }
 
-        virtual WhileStmt *clone() const { return new WhileStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual WhileStmt *clone() const override { return new WhileStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -247 +248 @@
         void set_body( Statement *newValue ) { body = newValue; }
 
-        virtual ForStmt *clone() const { return new ForStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual ForStmt *clone() const override { return new ForStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -276 +277 @@
         const char *get_typename() { return brType[ type ]; }
 
-        virtual BranchStmt *clone() const { return new BranchStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual BranchStmt *clone() const override { return new BranchStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
   private:
         static const char *brType[];
@@ -295 +296 @@
         void set_expr( Expression *newValue ) { expr = newValue; }
 
-        virtual ReturnStmt *clone() const { return new ReturnStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual ReturnStmt *clone() const override { return new ReturnStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -319 +320 @@
         void set_target( Expression * newTarget ) { target = newTarget; }
 
-        virtual ThrowStmt *clone() const { return new ThrowStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual ThrowStmt *clone() const override { return new ThrowStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -342 +343 @@
         void set_finally( FinallyStmt *newValue ) { finallyBlock = newValue; }
 
-        virtual TryStmt *clone() const { return new TryStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual TryStmt *clone() const override { return new TryStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -370 +371 @@
         void set_body( Statement *newValue ) { body = newValue; }
 
-        virtual CatchStmt *clone() const { return new CatchStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual CatchStmt *clone() const override { return new CatchStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -387 +388 @@
         void set_block( CompoundStmt *newValue ) { block = newValue; }
 
-        virtual FinallyStmt *clone() const { return new FinallyStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual FinallyStmt *clone() const override { return new FinallyStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -424 +425 @@
         } orelse;
 
-        virtual WaitForStmt *clone() const { return new WaitForStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual WaitForStmt *clone() const override { return new WaitForStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 
 };
@@ -444 +445 @@
         void set_decl( Declaration *newValue ) { decl = newValue; }
 
-        virtual DeclStmt *clone() const { return new DeclStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual DeclStmt *clone() const override { return new DeclStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -466 +467 @@
         void set_callStmt( Statement * newValue ) { callStmt = newValue; }
 
-        virtual ImplicitCtorDtorStmt *clone() const { return new ImplicitCtorDtorStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-};
-
-
-std::ostream & operator<<( std::ostream & out, const Statement * statement );
+        virtual ImplicitCtorDtorStmt *clone() const override { return new ImplicitCtorDtorStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+};
 
 // Local Variables: //

src/SynTree/Type.cc

@@ -99 +99 @@
 const Type::Qualifiers noQualifiers;
 
-std::ostream & operator<<( std::ostream & out, const Type * type ) {
-        if ( type ) {
-                type->print( out );
-        } else {
-                out << "nullptr";
-        } // if
-        return out;
-}
-
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Type.h

@@ -192 +192 @@
         VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 
-        virtual unsigned size() const { return 0; };
-        virtual bool isComplete() const { return false; }
-
-        virtual VoidType *clone() const { return new VoidType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual unsigned size() const override { return 0; };
+        virtual bool isComplete() const override { return false; }
+
+        virtual VoidType *clone() const override { return new VoidType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -235 +235 @@
         void set_kind( Kind newValue ) { kind = newValue; }
 
-        virtual BasicType *clone() const { return new BasicType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual BasicType *clone() const override { return new BasicType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 
         bool isInteger() const;
@@ -268 +268 @@
         bool is_array() const { return isStatic || isVarLen || dimension; }
 
-        virtual bool isComplete() const { return ! isVarLen; }
-
-        virtual PointerType *clone() const { return new PointerType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override { return ! isVarLen; }
+
+        virtual PointerType *clone() const override { return new PointerType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -296 +296 @@
         void set_isStatic( bool newValue ) { isStatic = newValue; }
 
-        virtual bool isComplete() const { return ! isVarLen; }
-
-        virtual ArrayType *clone() const { return new ArrayType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override { return ! isVarLen; }
+
+        virtual ArrayType *clone() const override { return new ArrayType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -315 +315 @@
         void set_base( Type *newValue ) { base = newValue; }
 
-        virtual int referenceDepth() const;
+        virtual int referenceDepth() const override;
 
         // Since reference types act like value types, their size is the size of the base.
         // This makes it simple to cast the empty tuple to a reference type, since casts that increase
         // the number of values are disallowed.
-        virtual unsigned size() const { return base->size(); }
-
-        virtual ReferenceType *clone() const { return new ReferenceType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual unsigned size() const override { return base->size(); }
+
+        virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -349 +349 @@
         bool isTtype() const;
 
-        virtual FunctionType *clone() const { return new FunctionType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual FunctionType *clone() const override { return new FunctionType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -371 +371 @@
         void set_hoistType( bool newValue ) { hoistType = newValue; }
 
-        virtual ReferenceToType *clone() const = 0;
-        virtual void accept( Visitor & v ) = 0;
-        virtual Type *acceptMutator( Mutator & m ) = 0;
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual ReferenceToType *clone() const override = 0;
+        virtual void accept( Visitor & v ) override = 0;
+        virtual Type *acceptMutator( Mutator & m ) override = 0;
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 
         virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
@@ -398 +398 @@
         std::list<TypeDecl*> * get_baseParameters();
 
-        virtual bool isComplete() const;
+        virtual bool isComplete() const override;
 
         /// Looks up the members of this struct named "name" and places them into "foundDecls".
         /// Clones declarations into "foundDecls", caller responsible for freeing
-        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
-
-        virtual StructInstType *clone() const { return new StructInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
+
+        virtual StructInstType *clone() const override { return new StructInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
   private:
-        virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 
@@ -430 +430 @@
         std::list< TypeDecl * > * get_baseParameters();
 
-        virtual bool isComplete() const;
+        virtual bool isComplete() const override;
 
         /// looks up the members of this union named "name" and places them into "foundDecls"
         /// Clones declarations into "foundDecls", caller responsible for freeing
-        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
-
-        virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
+
+        virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
   private:
-        virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 
@@ -459 +459 @@
         void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
 
-        virtual bool isComplete() const;
-
-        virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual bool isComplete() const override;
+
+        virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
   private:
-        virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 
@@ -480 +480 @@
         ~TraitInstType();
 
-        virtual bool isComplete() const;
-
-        virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual bool isComplete() const override;
+
+        virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
   private:
-        virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 
@@ -507 +507 @@
         void set_isFtype( bool newValue ) { isFtype = newValue; }
 
-        virtual bool isComplete() const;
-
-        virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override;
+
+        virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
   private:
-        virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 
@@ -530 +530 @@
 
         std::list<Type *> & get_types() { return types; }
-        virtual unsigned size() const { return types.size(); };
+        virtual unsigned size() const override { return types.size(); };
 
         // For now, this is entirely synthetic -- tuple types always have unnamed members.
@@ -539 +539 @@
         iterator end() { return types.end(); }
 
-        virtual Type * getComponent( unsigned i ) {
+        virtual Type * getComponent( unsigned i ) override {
                 assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
                 return *(begin()+i);
         }
 
-        // virtual bool isComplete() const { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
-
-        virtual TupleType *clone() const { return new TupleType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
+
+        virtual TupleType *clone() const override { return new TupleType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -563 +563 @@
         void set_expr( Expression *newValue ) { expr = newValue; }
 
-        virtual bool isComplete() const { assert( false ); return false; }
-
-        virtual TypeofType *clone() const { return new TypeofType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override { assert( false ); return false; }
+
+        virtual TypeofType *clone() const override { return new TypeofType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -592 +592 @@
         void set_isType( bool newValue ) { isType = newValue; }
 
-        virtual bool isComplete() const { assert( false ); } // xxx - not sure what to do here
-
-        virtual AttrType *clone() const { return new AttrType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
+
+        virtual AttrType *clone() const override { return new AttrType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -606 +606 @@
         VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
 
-        virtual bool isComplete() const{ return true; } // xxx - is this right?
-
-        virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override{ return true; } // xxx - is this right?
+
+        virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -620 +620 @@
         ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
 
-        virtual ZeroType *clone() const { return new ZeroType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual ZeroType *clone() const override { return new ZeroType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -632 +632 @@
         OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
 
-        virtual OneType *clone() const { return new OneType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
-};
-
-std::ostream & operator<<( std::ostream & out, const Type * type );
+        virtual OneType *clone() const override { return new OneType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
+};
 
 // Local Variables: //

src/benchmark/bench.h

@@ -1 +1 @@
 #pragma once
 
+#ifdef __CFORALL__
 extern "C" {
+#endif
         #include <unistd.h>                                     // sysconf
         #include <sys/times.h>                                  // times
         #include <time.h>
+#ifdef __CFORALL__
 }
+#endif
 
-inline unsigned long long int Time() {
-    timespec ts;
+
+static inline unsigned long long int Time() {
+    struct timespec ts;
     clock_gettime(
 #if defined( __linux__ )

src/libcfa/Makefile.am

@@ -36 +36 @@
          ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -O0 -c -o $@ $<
 
-EXTRA_FLAGS = -g -Wall -Werror -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
+EXTRA_FLAGS = -g -Wall -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
 
 AM_CCASFLAGS = @CFA_FLAGS@

src/libcfa/Makefile.in

@@ -416 +416 @@
 ARFLAGS = cr
 lib_LIBRARIES = $(am__append_1) $(am__append_2)
-EXTRA_FLAGS = -g -Wall -Werror -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
+EXTRA_FLAGS = -g -Wall -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
 AM_CCASFLAGS = @CFA_FLAGS@
 headers = fstream iostream iterator limits rational stdlib \

src/libcfa/concurrency/coroutine.c

@@ -123 +123 @@
         if(pageSize == 0ul) pageSize = sysconf( _SC_PAGESIZE );
 
-        LIB_DEBUG_PRINT_SAFE("FRED");
-
         size_t cxtSize = libCeiling( sizeof(machine_context_t), 8 ); // minimum alignment
 

src/libcfa/concurrency/invoke.h

@@ -84 +84 @@
       };
 
+      struct __waitfor_mask_t {
+            short * accepted;                         // the index of the accepted function, -1 if none
+            struct __acceptable_t * clauses;          // list of acceptable functions, null if any
+            short size;                               // number of acceptable functions
+      };
+
       struct monitor_desc {
             struct spinlock lock;                     // spinlock to protect internal data
@@ -90 +96 @@
             struct __condition_stack_t signal_stack;  // stack of conditions to run next once we exit the monitor
             unsigned int recursion;                   // monitor routines can be called recursively, we need to keep track of that
+            struct __waitfor_mask_t mask;               // mask used to know if some thread is waiting for something while holding the monitor
+      };
 
-            struct __acceptable_t * acceptables;      // list of acceptable functions, null if any
-            unsigned short acceptable_count;          // number of acceptable functions
-            short accepted_index;                     // the index of the accepted function, -1 if none
-       };
+      struct __monitor_group_t {
+            struct monitor_desc ** list;              // currently held monitors
+            short                  size;              // number of currently held monitors
+            fptr_t                 func;              // last function that acquired monitors
+      };
 
       struct thread_desc {
             // Core threading fields
-            struct coroutine_desc cor;                // coroutine body used to store context
-            struct monitor_desc mon;                  // monitor body used for mutual exclusion
+            struct coroutine_desc  self_cor;          // coroutine body used to store context
+            struct monitor_desc    self_mon;          // monitor body used for mutual exclusion
+            struct monitor_desc *  self_mon_p;        // pointer to monitor with sufficient lifetime for current monitors
+            struct __monitor_group_t monitors;          // monitors currently held by this thread
 
             // Link lists fields
             struct thread_desc * next;                // instrusive link field for threads
 
-            // Current status related to monitors
-            struct monitor_desc ** current_monitors;  // currently held monitors
-            unsigned short current_monitor_count;     // number of currently held monitors
-            fptr_t current_monitor_func;              // last function that acquired monitors
+
      };
+
+     #ifdef __CFORALL__
+     extern "Cforall" {
+            static inline monitor_desc * ?[?]( const __monitor_group_t & this, ptrdiff_t index ) {
+                  return this.list[index];
+            }
+
+            static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) {
+                  if( (lhs.list != 0) != (rhs.list != 0) ) return false;
+                  if( lhs.size != rhs.size ) return false;
+                  if( lhs.func != rhs.func ) return false;
+
+                  // Check that all the monitors match
+                  for( int i = 0; i < lhs.size; i++ ) {
+                        // If not a match, check next function
+                        if( lhs[i] != rhs[i] ) return false;
+                  }
+
+                  return true;
+            }
+      }
+      #endif
 
 #endif //_INVOKE_H_

src/libcfa/concurrency/kernel.c

@@ -106 +106 @@
 
 void ?{}( thread_desc & this, current_stack_info_t * info) {
-        (this.cor){ info };
+        (this.self_cor){ info };
 }
 
@@ -328 +328 @@
         // if( !thrd ) return;
         verify( thrd );
-        verify( thrd->cor.state != Halted );
+        verify( thrd->self_cor.state != Halted );
 
         verify( disable_preempt_count > 0 );
@@ -373 +373 @@
         assert(thrd);
         disable_interrupts();
-        assert( thrd->cor.state != Halted );
+        assert( thrd->self_cor.state != Halted );
         this_processor->finish.action_code = Schedule;
         this_processor->finish.thrd = thrd;
@@ -466 +466 @@
         this_processor = mainProcessor;
         this_thread = mainThread;
-        this_coroutine = &mainThread->cor;
+        this_coroutine = &mainThread->self_cor;
 
         // Enable preemption
@@ -547 +547 @@
         thread_desc * thrd = kernel_data;
 
-        int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->cor.name, thrd );
+        int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd );
         __lib_debug_write( STDERR_FILENO, abort_text, len );
 

src/libcfa/concurrency/monitor

@@ -22 +22 @@
 #include "stdlib"
 
+trait is_monitor(dtype T) {
+        monitor_desc * get_monitor( T & );
+        void ^?{}( T & mutex );
+};
+
 static inline void ?{}(monitor_desc & this) {
         (this.lock){};
@@ -28 +33 @@
         (this.signal_stack){};
         this.recursion = 0;
-        this.acceptables = NULL;
-        this.acceptable_count = 0;
-        this.accepted_index = -1;
+        this.mask.accepted = NULL;
+        this.mask.clauses  = NULL;
+        this.mask.size     = 0;
 }
 
@@ -100 +105 @@
 
 struct __acceptable_t {
-        fptr_t func;
-        unsigned short count;
-        monitor_desc ** monitors;
+        __monitor_group_t;
         bool is_dtor;
 };
 
-int __accept_internal( unsigned short count, __acceptable_t * acceptables );
+void __waitfor_internal( const __waitfor_mask_t & mask, int duration );
 
 // Local Variables: //

src/libcfa/concurrency/monitor.c

@@ -24 +24 @@
 // Forward declarations
 static inline void set_owner( monitor_desc * this, thread_desc * owner );
+static inline void set_owner( monitor_desc ** storage, short count, thread_desc * owner );
+static inline void set_mask ( monitor_desc ** storage, short count, const __waitfor_mask_t & mask );
+
 static inline thread_desc * next_thread( monitor_desc * this );
-static inline int is_accepted( thread_desc * owner, monitor_desc * this, monitor_desc ** group, int group_cnt, void (*func)() );
+static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & monitors );
 
 static inline void lock_all( spinlock ** locks, unsigned short count );
@@ -32 +35 @@
 static inline void unlock_all( monitor_desc ** locks, unsigned short count );
 
-static inline void save_recursion   ( monitor_desc ** ctx, unsigned int * /*out*/ recursions, unsigned short count );
-static inline void restore_recursion( monitor_desc ** ctx, unsigned int * /*in */ recursions, unsigned short count );
+static inline void save   ( monitor_desc ** ctx, short count, spinlock ** locks, unsigned int * /*out*/ recursions, __waitfor_mask_t * /*out*/ masks );
+static inline void restore( monitor_desc ** ctx, short count, spinlock ** locks, unsigned int * /*in */ recursions, __waitfor_mask_t * /*in */ masks );
 
 static inline void init     ( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria );
 static inline void init_push( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria );
 
-static inline thread_desc * check_condition( __condition_criterion_t * );
-static inline void brand_condition( condition * );
-static inline unsigned short insert_unique( thread_desc ** thrds, unsigned short end, thread_desc * val );
-
-static inline thread_desc * search_entry_queue( __acceptable_t * acceptables, int acc_count, monitor_desc ** monitors, int count );
+static inline thread_desc *        check_condition   ( __condition_criterion_t * );
+static inline void                 brand_condition   ( condition * );
+static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc ** monitors, int count );
+
+forall(dtype T | sized( T ))
+static inline short insert_unique( T ** array, short & size, T * val );
+static inline short count_max    ( const __waitfor_mask_t & mask );
+static inline short aggregate    ( monitor_desc ** storage, const __waitfor_mask_t & mask );
 
 //-----------------------------------------------------------------------------
 // Useful defines
-#define wait_ctx(thrd, user_info)                               /* Create the necessary information to use the signaller stack       */ \
-        __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                   */ \
-        __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up          */ \
-        init( count, monitors, &waiter, criteria );               /* Link everything together                                          */ \
-
-#define wait_ctx_primed(thrd, user_info)                        /* Create the necessary information to use the signaller stack       */ \
-        __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                   */ \
-        __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up          */ \
-        init_push( count, monitors, &waiter, criteria );          /* Link everything together and push it to the AS-Stack              */ \
-
-#define monitor_ctx( mons, cnt )              /* Define that create the necessary struct for internal/external scheduling operations */ \
-        monitor_desc ** monitors = mons;        /* Save the targeted monitors                                                          */ \
-        unsigned short count = cnt;             /* Save the count to a local variable                                                  */ \
-        unsigned int recursions[ count ];       /* Save the current recursion levels to restore them later                             */ \
-        spinlock *   locks     [ count ];       /* We need to pass-in an array of locks to BlockInternal                               */ \
+#define wait_ctx(thrd, user_info)                               /* Create the necessary information to use the signaller stack                         */ \
+        __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                                     */ \
+        __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up                            */ \
+        init( count, monitors, &waiter, criteria );               /* Link everything together                                                            */ \
+
+#define wait_ctx_primed(thrd, user_info)                        /* Create the necessary information to use the signaller stack                         */ \
+        __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                                     */ \
+        __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up                            */ \
+        init_push( count, monitors, &waiter, criteria );          /* Link everything together and push it to the AS-Stack                                */ \
+
+#define monitor_ctx( mons, cnt )                                /* Define that create the necessary struct for internal/external scheduling operations */ \
+        monitor_desc ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
+        unsigned short count = cnt;                               /* Save the count to a local variable                                                  */ \
+        unsigned int recursions[ count ];                         /* Save the current recursion levels to restore them later                             */ \
+        __waitfor_mask_t masks[ count ];                          /* Save the current waitfor masks to restore them later                                */ \
+        spinlock *   locks     [ count ];                         /* We need to pass-in an array of locks to BlockInternal                               */ \
+
+#define monitor_save    save   ( monitors, count, locks, recursions, masks )
+#define monitor_restore restore( monitors, count, locks, recursions, masks )
+
+#define blockAndWake( thrd, cnt )                               /* Create the necessary information to use the signaller stack                         */ \
+        monitor_save;                                             /* Save monitor states                                                                 */ \
+        BlockInternal( locks, count, thrd, cnt );                 /* Everything is ready to go to sleep                                                  */ \
+        monitor_restore;                                          /* We are back, restore the owners and recursions                                      */ \
+
 
 //-----------------------------------------------------------------------------
@@ -68 +84 @@
 extern "C" {
         // Enter single monitor
-        static void __enter_monitor_desc( monitor_desc * this, monitor_desc ** group, int group_cnt, void (*func)() ) {
+        static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
                 // Lock the monitor spinlock, lock_yield to reduce contention
                 lock_yield( &this->lock DEBUG_CTX2 );
@@ -75 +91 @@
                 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
 
-                this->accepted_index = -1;
                 if( !this->owner ) {
                         // No one has the monitor, just take it
@@ -89 +104 @@
                         LIB_DEBUG_PRINT_SAFE("Kernel :  mon already owned \n");
                 }
-                else if( (this->accepted_index = is_accepted( thrd, this, group, group_cnt, func)) >= 0 ) {
+                else if( is_accepted( this, group) ) {
                         // Some one was waiting for us, enter
                         set_owner( this, thrd );
@@ -120 +135 @@
                 lock_yield( &this->lock DEBUG_CTX2 );
 
-                verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i)", this_thread, this->owner, this->recursion );
+                LIB_DEBUG_PRINT_SAFE("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
+
+                verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", this_thread, this->owner, this->recursion, this );
 
                 // Leaving a recursion level, decrement the counter
@@ -146 +163 @@
         // Should never return
         void __leave_thread_monitor( thread_desc * thrd ) {
-                monitor_desc * this = &thrd->mon;
+                monitor_desc * this = &thrd->self_mon;
 
                 // Lock the monitor now
@@ -153 +170 @@
                 disable_interrupts();
 
-                thrd->cor.state = Halted;
-
-                verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i)", thrd, this->owner, this->recursion );
+                thrd->self_cor.state = Halted;
+
+                verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
 
                 // Leaving a recursion level, decrement the counter
@@ -178 +195 @@
 // Enter multiple monitor
 // relies on the monitor array being sorted
-static inline void enter(monitor_desc ** monitors, int count, void (*func)() ) {
-        for(int i = 0; i < count; i++) {
-                __enter_monitor_desc( monitors[i], monitors, count, func );
+static inline void enter( __monitor_group_t monitors ) {
+        for(int i = 0; i < monitors.size; i++) {
+                __enter_monitor_desc( monitors.list[i], monitors );
         }
 }
@@ -203 +220 @@
 
         // Save previous thread context
-        this.prev_mntrs = this_thread->current_monitors;
-        this.prev_count = this_thread->current_monitor_count;
-        this.prev_func  = this_thread->current_monitor_func;
+        this.prev_mntrs = this_thread->monitors.list;
+        this.prev_count = this_thread->monitors.size;
+        this.prev_func  = this_thread->monitors.func;
 
         // Update thread context (needed for conditions)
-        this_thread->current_monitors      = m;
-        this_thread->current_monitor_count = count;
-        this_thread->current_monitor_func  = func;
+        this_thread->monitors.list = m;
+        this_thread->monitors.size = count;
+        this_thread->monitors.func = func;
+
+        LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);
 
         // Enter the monitors in order
-        enter( this.m, this.count, func );
+        __monitor_group_t group = {this.m, this.count, func};
+        enter( group );
+
+        LIB_DEBUG_PRINT_SAFE("MGUARD : entered\n");
 }
 
@@ -219 +241 @@
 // Dtor for monitor guard
 void ^?{}( monitor_guard_t & this ) {
+        LIB_DEBUG_PRINT_SAFE("MGUARD : leaving %d\n", this.count);
+
         // Leave the monitors in order
         leave( this.m, this.count );
 
+        LIB_DEBUG_PRINT_SAFE("MGUARD : left\n");
+
         // Restore thread context
-        this_thread->current_monitors      = this.prev_mntrs;
-        this_thread->current_monitor_count = this.prev_count;
-        this_thread->current_monitor_func  = this.prev_func;
+        this_thread->monitors.list = this.prev_mntrs;
+        this_thread->monitors.size = this.prev_count;
+        this_thread->monitors.func = this.prev_func;
 }
 
@@ -271 +297 @@
         append( &this->blocked, &waiter );
 
-        // Lock all monitors (aggregates the lock them as well)
+        // Lock all monitors (aggregates the locks as well)
         lock_all( monitors, locks, count );
 
-        // DON'T unlock, ask the kernel to do it
-
-        // Save monitor state
-        save_recursion( monitors, recursions, count );
-
         // Find the next thread(s) to run
-        unsigned short thread_count = 0;
+        short thread_count = 0;
         thread_desc * threads[ count ];
         for(int i = 0; i < count; i++) {
@@ -286 +307 @@
         }
 
+        // Save monitor states
+        monitor_save;
+
         // Remove any duplicate threads
         for( int i = 0; i < count; i++) {
                 thread_desc * new_owner = next_thread( monitors[i] );
-                thread_count = insert_unique( threads, thread_count, new_owner );
+                insert_unique( threads, thread_count, new_owner );
         }
 
@@ -295 +319 @@
         BlockInternal( locks, count, threads, thread_count );
 
-
-        // WE WOKE UP
-
-
         // We are back, restore the owners and recursions
-        lock_all( locks, count );
-        restore_recursion( monitors, recursions, count );
-        unlock_all( locks, count );
+        monitor_restore;
 }
 
@@ -315 +333 @@
         LIB_DEBUG_DO(
                 thread_desc * this_thrd = this_thread;
-                if ( this->monitor_count != this_thrd->current_monitor_count ) {
-                        abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", this, this->monitor_count, this_thrd->current_monitor_count );
+                if ( this->monitor_count != this_thrd->monitors.size ) {
+                        abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", this, this->monitor_count, this_thrd->monitors.size );
                 }
 
                 for(int i = 0; i < this->monitor_count; i++) {
-                        if ( this->monitors[i] != this_thrd->current_monitors[i] ) {
-                                abortf( "Signal on condition %p made with different monitor, expected %p got %i", this, this->monitors[i], this_thrd->current_monitors[i] );
+                        if ( this->monitors[i] != this_thrd->monitors.list[i] ) {
+                                abortf( "Signal on condition %p made with different monitor, expected %p got %i", this, this->monitors[i], this_thrd->monitors.list[i] );
                         }
                 }
@@ -364 +382 @@
 
         //save contexts
-        save_recursion( monitors, recursions, count );
+        monitor_save;
 
         //Find the thread to run
         thread_desc * signallee = pop_head( &this->blocked )->waiting_thread;
-        for(int i = 0; i < count; i++) {
-                set_owner( monitors[i], signallee );
-        }
+        set_owner( monitors, count, signallee );
 
         //Everything is ready to go to sleep
@@ -379 +395 @@
 
 
-        //We are back, restore the owners and recursions
-        lock_all( locks, count );
-        restore_recursion( monitors, recursions, count );
-        unlock_all( locks, count );
+        //We are back, restore the masks and recursions
+        monitor_restore;
 
         return true;
@@ -397 +411 @@
 
 //-----------------------------------------------------------------------------
-// Internal scheduling
-int __accept_internal( unsigned short acc_count, __acceptable_t * acceptables ) {
-        thread_desc * thrd = this_thread;
+// External scheduling
+// cases to handle :
+//      - target already there :
+//              block and wake
+//      - dtor already there
+//              put thread on signaller stack
+//      - non-blocking
+//              return else
+//      - timeout
+//              return timeout
+//      - block
+//              setup mask
+//              block
+void __waitfor_internal( const __waitfor_mask_t & mask, int duration ) {
+        // This statment doesn't have a contiguous list of monitors...
+        // Create one!
+        short max = count_max( mask );
+        monitor_desc * mon_storage[max];
+        short actual_count = aggregate( mon_storage, mask );
+
+        if(actual_count == 0) return;
 
         // Create storage for monitor context
-        monitor_ctx( acceptables->monitors, acceptables->count );
-
-        // Lock all monitors (aggregates the lock them as well)
+        monitor_ctx( mon_storage, actual_count );
+
+        // Lock all monitors (aggregates the locks as well)
         lock_all( monitors, locks, count );
 
-        // Create the node specific to this wait operation
-        wait_ctx_primed( thrd, 0 );
-
-        // Check if the entry queue
-        thread_desc * next = search_entry_queue( acceptables, acc_count, monitors, count );
-
-        LIB_DEBUG_PRINT_SAFE("Owner(s) :");
-        for(int i = 0; i < count; i++) {
-                LIB_DEBUG_PRINT_SAFE(" %p", monitors[i]->owner );
-        }
-        LIB_DEBUG_PRINT_SAFE("\n");
-
-        LIB_DEBUG_PRINT_SAFE("Passing mon to %p\n", next);
-
-        if( !next ) {
-                // Update acceptables on the current monitors
-                for(int i = 0; i < count; i++) {
-                        monitors[i]->acceptables = acceptables;
-                        monitors[i]->acceptable_count = acc_count;
-                }
-        }
-        else {
-                for(int i = 0; i < count; i++) {
-                        set_owner( monitors[i], next );
-                }
-        }
-
-
-        save_recursion( monitors, recursions, count );
-
-
-        // Everything is ready to go to sleep
-        BlockInternal( locks, count, &next, next ? 1 : 0 );
-
-
+        {
+                // Check if the entry queue
+                thread_desc * next; int index;
+                [next, index] = search_entry_queue( mask, monitors, count );
+
+                if( next ) {
+                        if( mask.clauses[index].is_dtor ) {
+                                #warning case not implemented
+                        }
+                        else {
+                                blockAndWake( &next, 1 );
+                        }
+
+                        return index;
+                }
+        }
+
+
+        if( duration == 0 ) {
+                unlock_all( locks, count );
+                return;
+        }
+
+
+        verifyf( duration < 0, "Timeout on waitfor statments not supported yet.");
+
+
+        monitor_save;
+        set_mask( monitors, count, mask );
+
+        BlockInternal( locks, count );       // Everything is ready to go to sleep
         //WE WOKE UP
-
-
-        //We are back, restore the owners and recursions
-        lock_all( locks, count );
-        restore_recursion( monitors, recursions, count );
-        int acc_idx = monitors[0]->accepted_index;
-        unlock_all( locks, count );
-
-        return acc_idx;
+        monitor_restore;                     //We are back, restore the masks and recursions
 }
 
@@ -458 +478 @@
 
 static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
+        LIB_DEBUG_PRINT_SAFE("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
+
         //Pass the monitor appropriately
         this->owner = owner;
@@ -463 +485 @@
         //We are passing the monitor to someone else, which means recursion level is not 0
         this->recursion = owner ? 1 : 0;
+}
+
+static inline void set_owner( monitor_desc ** monitors, short count, thread_desc * owner ) {
+        for( int i = 0; i < count; i++ ) {
+                set_owner( monitors[i], owner );
+        }
+}
+
+static inline void set_mask( monitor_desc ** storage, short count, const __waitfor_mask_t & mask ) {
+        for(int i = 0; i < count; i++) {
+                storage[i]->mask = mask;
+        }
 }
 
@@ -485 +519 @@
 }
 
-static inline int is_accepted( thread_desc * owner, monitor_desc * this, monitor_desc ** group, int group_cnt, void (*func)() ) {
-        __acceptable_t* accs = this->acceptables; // Optim
-        int acc_cnt = this->acceptable_count;
+static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & group ) {
+        __acceptable_t * it = this->mask.clauses; // Optim
+        int count = this->mask.size;
 
         // Check if there are any acceptable functions
-        if( !accs ) return -1;
+        if( !it ) return false;
 
         // If this isn't the first monitor to test this, there is no reason to repeat the test.
-        if( this != group[0] ) return group[0]->accepted_index;
+        if( this != group[0] ) return group[0]->mask.accepted >= 0;
 
         // For all acceptable functions check if this is the current function.
-        OUT_LOOP:
-        for( int i = 0; i < acc_cnt; i++ ) {
-                __acceptable_t * acc = &accs[i];
-
-                // if function matches, check the monitors
-                if( acc->func == func ) {
-
-                        // If the group count is different then it can't be a match
-                        if( acc->count != group_cnt ) return -1;
-
-                        // Check that all the monitors match
-                        for( int j = 0; j < group_cnt; j++ ) {
-                                // If not a match, check next function
-                                if( acc->monitors[j] != group[j] ) continue OUT_LOOP;
-                        }
-
-                        // It's a complete match, accept the call
-                        return i;
+        for( short i = 0; i < count; i++, it++ ) {
+                if( *it == group ) {
+                        *this->mask.accepted = i;
+                        return true;
                 }
         }
 
         // No function matched
-        return -1;
+        return false;
 }
 
@@ -564 +584 @@
 }
 
-
-static inline void save_recursion   ( monitor_desc ** ctx, unsigned int * /*out*/ recursions, unsigned short count ) {
+static inline void save   ( monitor_desc ** ctx, short count, __attribute((unused)) spinlock ** locks, unsigned int * /*out*/ recursions, __waitfor_mask_t * /*out*/ masks ) {
         for( int i = 0; i < count; i++ ) {
                 recursions[i] = ctx[i]->recursion;
-        }
-}
-
-static inline void restore_recursion( monitor_desc ** ctx, unsigned int * /*in */ recursions, unsigned short count ) {
+                masks[i]      = ctx[i]->mask;
+        }
+}
+
+static inline void restore( monitor_desc ** ctx, short count, spinlock ** locks, unsigned int * /*out*/ recursions, __waitfor_mask_t * /*out*/ masks ) {
+        lock_all( locks, count );
         for( int i = 0; i < count; i++ ) {
                 ctx[i]->recursion = recursions[i];
-        }
+                ctx[i]->mask      = masks[i];
+        }
+        unlock_all( locks, count );
 }
 
@@ -607 +630 @@
         if( !this->monitors ) {
                 // LIB_DEBUG_PRINT_SAFE("Branding\n");
-                assertf( thrd->current_monitors != NULL, "No current monitor to brand condition %p", thrd->current_monitors );
-                this->monitor_count = thrd->current_monitor_count;
+                assertf( thrd->monitors.list != NULL, "No current monitor to brand condition %p", thrd->monitors.list );
+                this->monitor_count = thrd->monitors.size;
 
                 this->monitors = malloc( this->monitor_count * sizeof( *this->monitors ) );
                 for( int i = 0; i < this->monitor_count; i++ ) {
-                        this->monitors[i] = thrd->current_monitors[i];
-                }
-        }
-}
-
-static inline unsigned short insert_unique( thread_desc ** thrds, unsigned short end, thread_desc * val ) {
-        if( !val ) return end;
-
-        for(int i = 0; i <= end; i++) {
-                if( thrds[i] == val ) return end;
-        }
-
-        thrds[end] = val;
-        return end + 1;
-}
-
-
-static inline bool match( __acceptable_t * acc, thread_desc * thrd ) {
-        verify( thrd );
-        verify( acc );
-        if( acc->func != thrd->current_monitor_func ) return false;
-
-        return true;
-}
-
-static inline thread_desc * search_entry_queue( __acceptable_t * acceptables, int acc_count, monitor_desc ** monitors, int count ) {
+                        this->monitors[i] = thrd->monitors.list[i];
+                }
+        }
+}
+
+static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor_desc ** monitors, int count ) {
 
         __thread_queue_t * entry_queue = &monitors[0]->entry_queue;
@@ -644 +647 @@
         for(    thread_desc ** thrd_it = &entry_queue->head;
                 *thrd_it;
-                thrd_it = &(*thrd_it)->next)
-        {
+                thrd_it = &(*thrd_it)->next
+        ) {
                 // For each acceptable check if it matches
-                __acceptable_t * acc_end = acceptables + acc_count;
-                for( __acceptable_t * acc_it = acceptables; acc_it != acc_end; acc_it++ ) {
+                int i = 0;
+                __acceptable_t * end = mask.clauses + mask.size;
+                for( __acceptable_t * it = mask.clauses; it != end; it++, i++ ) {
                         // Check if we have a match
-                        if( match( acc_it, *thrd_it ) ) {
+                        if( *it == (*thrd_it)->monitors ) {
 
                                 // If we have a match return it
                                 // after removeing it from the entry queue
-                                return remove( entry_queue, thrd_it );
+                                return [remove( entry_queue, thrd_it ), i];
                         }
                 }
         }
 
-        return NULL;
-}
+        return [0, -1];
+}
+
+forall(dtype T | sized( T ))
+static inline short insert_unique( T ** array, short & size, T * val ) {
+        if( !val ) return size;
+
+        for(int i = 0; i <= size; i++) {
+                if( array[i] == val ) return size;
+        }
+
+        array[size] = val;
+        size = size + 1;
+        return size;
+}
+
+static inline short count_max( const __waitfor_mask_t & mask ) {
+        short max = 0;
+        for( int i = 0; i < mask.size; i++ ) {
+                max += mask.clauses[i].size;
+        }
+        return max;
+}
+
+static inline short aggregate( monitor_desc ** storage, const __waitfor_mask_t & mask ) {
+        short size = 0;
+        for( int i = 0; i < mask.size; i++ ) {
+                for( int j = 0; j < mask.clauses[i].size; j++) {
+                        insert_unique( storage, size, mask.clauses[i].list[j] );
+                }
+        }
+        qsort( storage, size );
+        return size;
+}
+
 void ?{}( __condition_blocked_queue_t & this ) {
         this.head = NULL;

src/libcfa/concurrency/preemption.c

@@ -328 +328 @@
                 siginfo_t info;
                 int sig = sigwaitinfo( &mask, &info );
+
+                if( sig < 0 ) {
+                        //Error!
+                        int err = errno;
+                        switch( err ) {
+                                case EAGAIN :
+                                case EINTR :
+                                        continue;
+                        case EINVAL :
+                                        abortf("Timeout was invalid.");
+                                default:
+                                        abortf("Unhandled error %d", err);
+                        }
+                }
 
                 // If another signal arrived something went wrong

src/libcfa/concurrency/thread

@@ -36 +36 @@
 forall( dtype T | is_thread(T) )
 static inline coroutine_desc* get_coroutine(T & this) {
-        return &get_thread(this)->cor;
+        return &get_thread(this)->self_cor;
 }
 
 forall( dtype T | is_thread(T) )
 static inline monitor_desc* get_monitor(T & this) {
-        return &get_thread(this)->mon;
+        return &get_thread(this)->self_mon;
 }
 
 static inline coroutine_desc* get_coroutine(thread_desc * this) {
-        return &this->cor;
+        return &this->self_cor;
 }
 
 static inline monitor_desc* get_monitor(thread_desc * this) {
-        return &this->mon;
+        return &this->self_mon;
 }
 

src/libcfa/concurrency/thread.c

@@ -33 +33 @@
 
 void ?{}(thread_desc& this) {
-        (this.cor){};
-        this.cor.name = "Anonymous Coroutine";
-        this.mon.owner = &this;
-        this.mon.recursion = 1;
+        (this.self_cor){};
+        this.self_cor.name = "Anonymous Coroutine";
+        this.self_mon.owner = &this;
+        this.self_mon.recursion = 1;
+        this.self_mon_p = &this.self_mon;
         this.next = NULL;
 
-        this.current_monitors      = &this.mon;
-        this.current_monitor_count = 1;
+        (this.monitors){ &this.self_mon_p, 1, (fptr_t)0 };
 }
 
 void ^?{}(thread_desc& this) {
-        ^(this.cor){};
+        ^(this.self_cor){};
 }
 

src/prelude/prelude.cf

@@ -42 +42 @@
 _Bool                   ?--( _Bool & ),                         ?--( volatile _Bool & );
 unsigned char           ?++( unsigned char & ),                 ?++( volatile unsigned char & );
+signed short            ?++( signed short & ),                  ?++( volatile signed short & );
+signed short            ?--( signed short & ),                  ?--( volatile signed short & );
+unsigned short          ?++( unsigned short & ),                ?++( volatile unsigned short & );
+unsigned short          ?--( unsigned short & ),                ?--( volatile unsigned short & );
 signed int              ?++( signed int & ),                    ?++( volatile signed int & );
 signed int              ?--( signed int & ),                    ?--( volatile signed int & );
@@ -92 +96 @@
 
 _Bool                   ++?( _Bool & ),                         --?( _Bool & );
+signed short    ++?( signed short & ),                  --?( signed short & );
 signed int              ++?( signed int & ),                    --?( signed int & );
-unsigned int            ++?( unsigned int & ),                  --?( unsigned int & );
+unsigned short          ++?( unsigned int & ),                  --?( unsigned int & );
+unsigned int            ++?( unsigned short & ),                --?( unsigned short & );
 signed long int         ++?( signed long int & ),               --?( signed long int & );
 unsigned long int       ++?( unsigned long int & ),             --?( unsigned long int & );

src/tests/Makefile.am

@@ -104 +104 @@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 
+sched-ext-parse : sched-ext-parse.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+
 gmp : gmp.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@}

src/tests/Makefile.in

@@ -856 +856 @@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 
+sched-ext-parse : sched-ext-parse.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+
 gmp : gmp.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@}

src/tests/sched-ext-parse.c

@@ -80 +80 @@
                 16;
         }
-        or waitfor( f1, a, a ) {
+        or waitfor( f2, a, a ) {
                 17;
         }

src/tests/sched-ext.c

@@ -45 +45 @@
         acceptable.monitors      = &a;
 
-        __accept_internal( 1, &acceptable );
+        __waitfor_internal( 1, &acceptable );
 
         sout | "Accepted" | endl;