Changeset 16c95e3

Timestamp:

Jun 27, 2017, 10:35:11 PM (8 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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:

fa4805f

Parents:

fda8168 (diff), 6385d62 (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 plg2:software/cfa/cfa-cc

Files:

• .gitignore (modified) (1 diff)
• doc/proposals/associated_types.md (added)
• doc/proposals/tagged-struct.txt (modified) (3 diffs)
• doc/working/exception/translate.c (modified) (7 diffs)
• src/Common/PassVisitor.h (modified) (8 diffs)
• src/Common/PassVisitor.impl.h (modified) (16 diffs)
• src/Common/PassVisitor.proto.h (modified) (3 diffs)
• src/ControlStruct/ExceptTranslate.cc (added)
• src/ControlStruct/ExceptTranslate.h (added)
• src/GenPoly/DeclMutator.cc (modified) (2 diffs)
• src/GenPoly/PolyMutator.cc (modified) (2 diffs)
• src/GenPoly/Specialize.cc (modified) (1 diff)
• src/InitTweak/InitTweak.cc (modified) (1 diff)
• src/Parser/StatementNode.cc (modified) (1 diff)
• src/SynTree/Constant.cc (modified) (2 diffs)
• src/SynTree/Constant.h (modified) (2 diffs)
• src/SynTree/Mutator.cc (modified) (3 diffs)
• src/SynTree/Visitor.cc (modified) (2 diffs)
• src/libcfa/Makefile.am (modified) (1 diff)
• src/libcfa/Makefile.in (modified) (1 diff)
• src/main.cc (modified) (1 diff)
• src/prelude/Makefile.am (modified) (3 diffs)
• src/prelude/Makefile.in (modified) (3 diffs)
• src/prelude/builtins.c (added)
• src/tests/preempt_longrun/Makefile.am (modified) (1 diff)
• src/tests/preempt_longrun/Makefile.in (modified) (1 diff)
• src/tests/preempt_longrun/barge.c (added)
• src/tests/preempt_longrun/block.c (added)
• src/tests/preempt_longrun/disjoint.c (added)
• src/tests/preempt_longrun/wait.c (added)
• src/tests/sched-int-block.c (modified) (1 diff)
• src/tests/sched-int-disjoint.c (modified) (1 diff)
• src/tests/sched-int-wait.c (modified) (1 diff)
• tools/repeat (modified) (1 diff)

.gitignore

@@ -31 +31 @@
 
 src/prelude/builtins.cf
-src/prelude/builtins.c
+src/prelude/gcc-builtins.cf
+src/prelude/gcc-builtins.c
 src/prelude/extras.cf
 src/prelude/bootloader.c

doc/proposals/tagged-struct.txt

@@ -14 +14 @@
 say which of the possible values is currently stored in the union. The idea
 here is similar, however the possibilities are more open ended.
+
+Alternate names include virtual structure and abstract structure.
 
 
@@ -36 +38 @@
 their parent's fields to their field list so they can be upcast.
 
+The type field may be public, if it is then it can be accessed through a
+simple field access "instance.type". The type field would then be able to be
+used to access the type object, which contains the information for the type.
+It may just be a pointer to the type object "*instance.type", although a
+lookup function could also be used.
+
+
+Usage:
+
+The central feature for tagged structs is a checked cast between pointer types
+to the structures. A cast is successful if the true type of the pointed object
+is of the type being cast to or any of its children, otherwise the cast
+returns null.
+
+The type field should also allow for equality comparison of types.
+
+Currently, with only these operations (and similar features) the type field
+could be hidden and the operations given through helper functions. However
+if the type object has more complex (or even open ended) information in it
+than providing direct access becomes very valuable.
+
 
 Implemenation:
 
-Adding to the field list is a simple matter, should be doable during
-translation. The type field is just a pointer to a type object. With proper
-linking we can create a single unique instance of the type object for each
-declared tagged struct. The instance's address is used as an id for the type.
-It also holds data about the type, such as its parent's id/a pointer to the
-parent type object.
+Adding to the field list would have to be handled during translation. The
+simple act of adding declarations should not be difficult, althought it might
+take a bit of work to find the parent's declarations.
 
-The type field could be hidden (as best as C can hide it) or it could be
-visible to the user with easy access to allow the user to examine the type
-object directly.
-
-Direct access is more useful if the data on the type-objects can change, other
-wise the build in function could handle all cases. Perhaps each root object
-can specify a type object to use or the type objects are themselves tagged,
-although there may not be a base case with the latter.
-
-In the simplest case the type object is a pointer to the parent type object.
-Additional data could be added, such as a name, or a function pointer to the
-destructor.
+Type objects are also simple in to generate, they should just be global
+(program lifetime) structures. Getting there to be exactly one instance of
+each allows the pointer to the structure to be used as the type id, and that
+should be possible to do during linking.
 
 
@@ -94 +106 @@
 If unions are declared tagged instead of creating a new tagged type, all
 possible values of the union must be of that tagged type or a child type.
+
+
+Custom Type Objects (Extention):
+
+Some method to define type objects used within a tree of types. One option is
+to allow the tree's type object to be specified by the tree root. It would
+then have to be filled in for each type in the tree, including the root.
+
+The only required field is the parent field, a pointer to the type object's
+type. (This is also the only required field on the tagged structure itself.)
+
+A further extention could allow expanding type objects, so child types could
+append fields to their parent's feild list. They might need their own type
+objects at that point, or maybe static checks will be enough to see the
+minimum field list.

doc/working/exception/translate.c

@@ -1 +1 @@
 /* Translation rules for exception handling code, from Cforall to C.
  *
- * Note that these are not final. Names, syntax and the exact translation
- * will be updated. The first section is the shared definitions, not generated
- * by the local translations but used by the translated code.
+ * Reminder: This is not final. Besides names and things it is also going very
+ * much for correctness and simplisity over efficiency.
+ *
+ * The first section is the shared definitions, not generated by the local
+ * translations but used by the translated code.
  *
  * Most of these exist only after translation (in C code). The first (the
@@ -16 +18 @@
 typedef int exception;
 
+// Will have to be availibe to user. Consider new name. Requires tagged types.
+forall(dtype parent | tagged(parent), dtype child | tagged(child))
+parent *dynamic_cast(child *);
+
 void __throw_terminate(exception except) __attribute__((noreturn));
 void __rethrow_terminate() __attribute__((noreturn));
@@ -116 +122 @@
                 }
                 int match1(exception except) {
-                        OtherException inner_except;
-                        if (dynamic_cast__SomeException(except)) {
-                                return 1;
-                        }
-                        else if ( (inner_except = dynamic_cast__OtherException(except)) &&
-                                        inner_except.priority > 3) {
-                                return 2;
-                        }
-                        else return 0;
+                        {
+                                if (dynamic_cast__SomeException(except)) {
+                                        return 1;
+                                }
+                        }
+                        {
+                                OtherException err;
+                                if ( (err = dynamic_cast__OtherException(except)) &&
+                                                err.priority > 3) {
+                                        return 2;
+                                }
+                        }
+                        return 0;
                 }
                 __try_terminate(try1, catch1, match1);
@@ -151 +161 @@
         {
                 bool handle1(exception except) {
-                        OtherException inner_except;
-                        if (dynamic_cast__SomeException(except)) {
-                                fiddleThing();
-                                return true;
-                        } else if (dynamic_cast__OtherException(except) &&
-                                        inner_except.priority > 3) {
-                                twiddleWidget();
-                                return true;
-                        } else {
-                                return false;
-                        }
+                        {
+                                if (dynamic_cast__SomeException(except)) {
+                                        fiddleThing();
+                                        return true;
+                                }
+                        }
+                        {
+                                OtherException err;
+                                if ( ( err = dynamic_cast__OtherException(except) ) &&
+                                                err.priority > 3) {
+                                        twiddleWidget();
+                                        return true;
+                                }
+                        }
+                        return false;
                 }
                 struct __try_resume_node data =
@@ -230 +244 @@
                 }
                 bool handle1(exception except) {
-                        if (dynamic_cast__SomeException(except)) {
-                                fiddleThing();
-                                return true;
-                        } else {
-                                return false;
-                        }
+                        {
+                                if (dynamic_cast__SomeException(except)) {
+                                        fiddleThing();
+                                        return true;
+                                }
+                        }
+                        return false;
                 }
                 struct __cleanup_hook generated_name
@@ -273 +288 @@
         {
                 bool handle1() {
-                        if (dynamic_cast__OtherException(except)) {
-                                twiddleWidget();
-                                return true;
+                        {
+                                if (dynamic_cast__OtherException(except)) {
+                                        twiddleWidget();
+                                        return true;
+                                }
                         }
                         return false;
@@ -297 +314 @@
                 }
                 int match1(exception except) {
-                        if (dynamic_cast__SomeException(except)) {
-                                return 1;
+                        {
+                                if (dynamic_cast__SomeException(except)) {
+                                        return 1;
+                                }
                         }
                         return 0;

src/Common/PassVisitor.h

@@ -25 +25 @@
 // | WithStmtsToAdd       - provides the ability to insert statements before or after the current statement by adding new statements into
 //                          stmtsToAddBefore or stmtsToAddAfter respectively.
-// | WithShortCircuiting  - provides the ability to skip visiting child nodes; set skip_children to true if pre{visit,mutate} to skip visiting children
+// | WithShortCircuiting  - provides the ability to skip visiting child nodes; set visit_children to false in pre{visit,mutate} to skip visiting children
 // | WithScopes           - provides the ability to save/restore data like a LIFO stack; to save, call GuardValue with the variable to save, the variable
 //                          will automatically be restored to its previous value after the corresponding postvisit/postmutate teminates.
@@ -37 +37 @@
         PassVisitor(Args &&... args)
                 : pass( std::forward<Args>( args )... )
-        {}
+        {
+                typedef PassVisitor<pass_type> this_t;
+                this_t * const * visitor = visitor_impl(pass, 0);
+                if(visitor) {
+                        *const_cast<this_t **>( visitor ) = this;
+                }
+        }
 
         virtual ~PassVisitor() = default;
@@ -214 +220 @@
 
 private:
+        template<typename pass_t> friend void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor );
+        template<typename pass_t> friend void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor );
+
         template<typename node_type> void call_previsit ( node_type * node ) { previsit_impl ( pass, node, 0 ); }
         template<typename node_type> void call_postvisit( node_type * node ) { postvisit_impl( pass, node, 0 ); }
@@ -225 +234 @@
         void set_env( TypeSubstitution * env ) { set_env_impl( pass, env, 0); }
 
-        void visitStatementList( std::list< Statement* > &statements );
+        template< typename func_t >
+        void handleStatementList( std::list< Statement * > & statements, func_t func );
+        void visitStatementList ( std::list< Statement* > &statements );
         void mutateStatementList( std::list< Statement* > &statements );
 
-        Statement * visitStatement( Statement * stmt );
+        template< typename func_t >
+        Statement * handleStatement( Statement * stmt, func_t func );
+        Statement * visitStatement ( Statement * stmt );
         Statement * mutateStatement( Statement * stmt );
 
-        void visitExpression( Expression * expr );
+        template< typename func_t >
+        Expression * handleExpression( Expression * expr, func_t func );
+        Expression * visitExpression ( Expression * expr );
         Expression * mutateExpression( Expression * expr );
 
@@ -238 +253 @@
         std::list< Statement* > *       get_beforeStmts() { return stmtsToAddBefore_impl( pass, 0); }
         std::list< Statement* > *       get_afterStmts () { return stmtsToAddAfter_impl ( pass, 0); }
-        bool visit_children() { bool* skip = skip_children_impl(pass, 0); return ! (skip && *skip); }
-        void reset_visit() { bool* skip = skip_children_impl(pass, 0); if(skip) *skip = false; }
+        std::list< Declaration* > *     get_beforeDecls() { return declsToAddBefore_impl( pass, 0); }
+        std::list< Declaration* > *     get_afterDecls () { return declsToAddAfter_impl ( pass, 0); }
+
+        void set_visit_children( bool& ref ) { bool_ref * ptr = visit_children_impl(pass, 0); if(ptr) ptr->set( ref ); }
 
         guard_value_impl init_guard() {
@@ -278 +295 @@
         std::list< Statement* > stmtsToAddAfter;
 };
-
 class WithShortCircuiting {
 protected:
@@ -285 +301 @@
 
 public:
-        bool skip_children;
+        bool_ref visit_children;
 };
 
@@ -304 +320 @@
 };
 
+template<typename pass_type>
+class WithVisitorRef {
+protected:
+        WithVisitorRef() = default;
+        ~WithVisitorRef() = default;
+
+public:
+        PassVisitor<pass_type> * const visitor;
+};
 
 #include "PassVisitor.impl.h"

src/Common/PassVisitor.impl.h

@@ -4 +4 @@
         __attribute__((unused))                   \
         const auto & guard = init_guard();        \
+        bool visit_children = true;               \
+        set_visit_children( visit_children );   \
         call_previsit( node );                    \
-        if( visit_children() ) {                  \
+        if( visit_children ) {                    \
 
 #define VISIT_END( node )                       \
         }                                         \
-        reset_visit();                            \
         call_postvisit( node );                   \
 
@@ -15 +16 @@
         __attribute__((unused))                   \
         const auto & guard = init_guard();        \
+        bool visit_children = true;               \
+        set_visit_children( visit_children );   \
         call_premutate( node );                   \
-        if( visit_children() ) {                  \
+        if( visit_children ) {                    \
 
 #define MUTATE_END( type, node )                \
         }                                         \
-        reset_visit();                            \
         return call_postmutate< type * >( node ); \
 
@@ -42 +44 @@
 }
 
-typedef std::list< Statement * > StmtList_t;
-
-template< typename pass_type >
-void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) {
+typedef std::list< Statement   * > StmtList_t;
+typedef std::list< Declaration * > DeclList_t;
+
+template<typename iterator_t>
+static inline void splice( iterator_t it, DeclList_t * decls ) {
+        std::transform(
+                decls->begin(),
+                decls->end(),
+                it,
+                [](Declaration * decl) -> auto {
+                        return new DeclStmt( noLabels, decl );
+                }
+        );
+        decls->clear();
+}
+
+template< typename pass_type >
+static inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) {
+
+        DeclList_t* beforeDecls = visitor.get_beforeDecls();
+        DeclList_t* afterDecls  = visitor.get_afterDecls();
+
+        for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
+                // splice in new declarations after previous decl
+                if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); } 
+
+                if ( i == decls.end() ) break;
+
+                // run mutator on declaration
+                maybeAccept( *i, visitor );
+
+                // splice in new declarations before current decl
+                if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
+        }
+}
+
+template< typename pass_type >
+static inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) {
+
+        DeclList_t* beforeDecls = mutator.get_beforeDecls();
+        DeclList_t* afterDecls  = mutator.get_afterDecls();
+
+        for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
+                // splice in new declarations after previous decl
+                if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); } 
+
+                if ( i == decls.end() ) break;
+
+                // run mutator on declaration
+                *i = maybeMutate( *i, mutator );
+
+                // splice in new declarations before current decl
+                if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
+        }
+}
+
+template< typename pass_type >
+template< typename func_t >
+void PassVisitor< pass_type >::handleStatementList( std::list< Statement * > & statements, func_t func ) {
         SemanticError errors;
 
         StmtList_t* beforeStmts = get_beforeStmts();
         StmtList_t* afterStmts  = get_afterStmts();
+        DeclList_t* beforeDecls = get_beforeDecls();
+        DeclList_t* afterDecls  = get_afterDecls();
 
         for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
+
+                if ( !empty( afterDecls ) ) { splice( std::inserter( statements, i ), afterDecls ); }
                 if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); }
+
                 try {
-                        (*i)->accept( *this );
+                        func( *i );
+                        assert(( empty( beforeStmts ) && empty( afterStmts ))
+                            || ( empty( beforeDecls ) && empty( afterDecls )) );
+
                 } catch ( SemanticError &e ) {
                         errors.append( e );
                 }
+
+                if ( !empty( beforeDecls ) ) { splice( std::inserter( statements, i ), beforeDecls ); }
                 if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
         }
 
+        if ( !empty( afterDecls ) ) { splice( std::back_inserter( statements ), afterDecls); }
         if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); }
         if ( !errors.isEmpty() ) { throw errors; }
@@ -66 +134 @@
 
 template< typename pass_type >
+void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) {
+        handleStatementList( statements, [this]( Statement * stmt) {
+                stmt->accept( *this );
+        });
+}
+
+template< typename pass_type >
 void PassVisitor< pass_type >::mutateStatementList( std::list< Statement * > & statements ) {
-        SemanticError errors;
+        handleStatementList( statements, [this]( Statement *& stmt) {
+                stmt = stmt->acceptMutator( *this );
+        });
+}
+
+
+template< typename pass_type >
+template< typename func_t >
+Statement * PassVisitor< pass_type >::handleStatement( Statement * stmt, func_t func ) {
+        // don't want statements from outer CompoundStmts to be added to this CompoundStmt
+        ValueGuardPtr< TypeSubstitution * >  oldEnv        ( get_env_ptr    () );
+        ValueGuardPtr< DeclList_t >          oldBeforeDecls( get_beforeDecls() );
+        ValueGuardPtr< DeclList_t >          oldAfterDecls ( get_afterDecls () );
+        ValueGuardPtr< StmtList_t >          oldBeforeStmts( get_beforeStmts() );
+        ValueGuardPtr< StmtList_t >          oldAfterStmts ( get_afterStmts () );
+
+        Statement *newStmt = func( stmt );
 
         StmtList_t* beforeStmts = get_beforeStmts();
         StmtList_t* afterStmts  = get_afterStmts();
-
-        for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
-                if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); }
-                try {
-                        *i = (*i)->acceptMutator( *this );
-                } catch ( SemanticError &e ) {
-                        errors.append( e );
-                }
-                if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
-        }
-
-        if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); }
-        if ( !errors.isEmpty() ) { throw errors; }
-}
-
-template< typename pass_type >
-Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
-        // don't want statements from outer CompoundStmts to be added to this CompoundStmt
-        ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
-        ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
-        ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
-
-        maybeAccept( stmt, *this );
-
-        StmtList_t* beforeStmts = get_beforeStmts();
-        StmtList_t* afterStmts  = get_afterStmts();
-
-        if( empty(beforeStmts) && empty(afterStmts) ) { return stmt; }
+        DeclList_t* beforeDecls = get_beforeDecls();
+        DeclList_t* afterDecls  = get_afterDecls();
+
+        if( empty(beforeStmts) && empty(afterStmts) && empty(beforeDecls) && empty(afterDecls) ) { return newStmt; }
+        assert(( empty( beforeStmts ) && empty( afterStmts ))
+            || ( empty( beforeDecls ) && empty( afterDecls )) );
 
         CompoundStmt *compound = new CompoundStmt( noLabels );
+        if( !empty(beforeDecls) ) { splice( std::back_inserter( compound->get_kids() ), beforeDecls ); }
         if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
-        compound->get_kids().push_back( stmt );
+        compound->get_kids().push_back( newStmt );
+        if( !empty(afterDecls) ) { splice( std::back_inserter( compound->get_kids() ), afterDecls ); }
         if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
         return compound;
@@ -108 +179 @@
 
 template< typename pass_type >
+Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
+        return handleStatement( stmt, [this]( Statement * stmt ) {
+                maybeAccept( stmt, *this ); 
+                return stmt;
+        });
+}
+
+template< typename pass_type >
 Statement * PassVisitor< pass_type >::mutateStatement( Statement * stmt ) {
-        // don't want statements from outer CompoundStmts to be added to this CompoundStmt
-        ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
-        ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
-        ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
-
-        Statement *newStmt = maybeMutate( stmt, *this );
-
-        StmtList_t* beforeStmts = get_beforeStmts();
-        StmtList_t* afterStmts  = get_afterStmts();
-
-        if( empty(beforeStmts) && empty(afterStmts) ) { return newStmt; }
-
-        CompoundStmt *compound = new CompoundStmt( noLabels );
-        if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
-        compound->get_kids().push_back( newStmt );
-        if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
-        return compound;
-}
-
-
-
-template< typename pass_type >
-void PassVisitor< pass_type >::visitExpression( Expression * expr ) {
-        if( !expr ) return;
+        return handleStatement( stmt, [this]( Statement * stmt ) {
+                return maybeMutate( stmt, *this );
+        });
+}
+
+template< typename pass_type >
+template< typename func_t >
+Expression * PassVisitor< pass_type >::handleExpression( Expression * expr, func_t func ) {
+        if( !expr ) return nullptr;
 
         auto env_ptr = get_env_ptr();
@@ -138 +202 @@
                 *env_ptr = expr->get_env();
         }
-        // xxx - should env be cloned (or moved) onto the result of the mutate?
-        expr->accept( *this );
+
+        // should env be cloned (or moved) onto the result of the mutate?
+        return func( expr );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::visitExpression( Expression * expr ) {
+        return handleExpression(expr, [this]( Expression * expr ) {
+                expr->accept( *this );
+                return expr;
+        });             
 }
 
 template< typename pass_type >
 Expression * PassVisitor< pass_type >::mutateExpression( Expression * expr ) {
-        if( !expr ) return nullptr;
-
-        auto env_ptr = get_env_ptr();
-        if ( env_ptr && expr->get_env() ) {
-                *env_ptr = expr->get_env();
-        }
-        // xxx - should env be cloned (or moved) onto the result of the mutate?
-        return expr->acceptMutator( *this );
-}
-
+        return handleExpression(expr, [this]( Expression * expr ) {
+                return expr->acceptMutator( *this );
+        });
+}
 
 //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -231 +298 @@
 void PassVisitor< pass_type >::visit( ExprStmt * node ) {
         VISIT_START( node );
-        call_beginScope();
 
         visitExpression( node->get_expr() );
 
-        call_endScope();
         VISIT_END( node );
 }
@@ -248 +313 @@
 }
 
+//--------------------------------------------------------------------------
+// AsmStmt
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( AsmStmt * node ) {
         VISIT_BODY( node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
+        MUTATE_BODY( Statement, node );
 }
 
@@ -300 +372 @@
 
 //--------------------------------------------------------------------------
-// WhileStmt
+// ForStmt
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( ForStmt * node ) {
@@ -348 +420 @@
 
 //--------------------------------------------------------------------------
-// SwitchStmt
+// CaseStmt
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( CaseStmt * node ) {
@@ -369 +441 @@
 }
 
+//--------------------------------------------------------------------------
+// BranchStmt
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( BranchStmt * node ) {
         VISIT_BODY( node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
+        MUTATE_BODY( Statement, node );
 }
 
@@ -415 +494 @@
         maybeAccept( node->get_block(), *this );
         acceptAll( node->get_catchers(), *this );
+        maybeAccept( node->get_finally(), *this );
 
         VISIT_END( node );
@@ -425 +505 @@
         node->set_block(  maybeMutate( node->get_block(), *this ) );
         mutateAll( node->get_catchers(), *this );
+        node->set_finally( maybeMutate( node->get_finally(), *this ) );
 
         MUTATE_END( Statement, node );
@@ -435 +516 @@
         VISIT_START( node );
 
+        maybeAccept( node->get_decl(), *this );
+        node->set_cond( visitExpression( node->get_cond() ) );
         node->set_body( visitStatement( node->get_body() ) );
-        maybeAccept( node->get_decl(), *this );
 
         VISIT_END( node );
@@ -445 +527 @@
         MUTATE_START( node );
 
-        node->set_body(  mutateStatement( node->get_body() ) );
-        node->set_decl(  maybeMutate( node->get_decl(), *this ) );
+        node->set_decl( maybeMutate( node->get_decl(), *this ) );
+        node->set_cond( mutateExpression( node->get_cond() ) );
+        node->set_body( mutateStatement( node->get_body() ) );
 
         MUTATE_END( Statement, node );
@@ -838 +921 @@
 
 template< typename pass_type >
-Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
-        MUTATE_BODY( Statement, node );
-}
-
-template< typename pass_type >
-Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
-        MUTATE_BODY( Statement, node );
-}
-
-template< typename pass_type >
 Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) {
         MUTATE_BODY( Statement, node );

src/Common/PassVisitor.proto.h

@@ -1 +1 @@
 #pragma once
+
+template<typename pass_type>
+class PassVisitor;
 
 typedef std::function<void( void * )> cleanup_func_t;
@@ -31 +34 @@
 
 typedef std::function< void( cleanup_func_t, void * ) > at_cleanup_t;
+
+class bool_ref {
+public:
+        bool_ref() = default;
+        ~bool_ref() = default;
+
+        operator bool() { return *m_ref; }
+        bool operator=( bool val ) { return *m_ref = val; }
+
+private:
+
+        template<typename pass>
+        friend class PassVisitor;
+
+        void set( bool & val ) { m_ref = &val; };
+
+        bool * m_ref;
+};
 
 //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -112 +133 @@
 FIELD_PTR( std::list< Statement* >, stmtsToAddBefore )
 FIELD_PTR( std::list< Statement* >, stmtsToAddAfter  )
-FIELD_PTR( bool, skip_children )
+FIELD_PTR( std::list< Declaration* >, declsToAddBefore )
+FIELD_PTR( std::list< Declaration* >, declsToAddAfter  )
+FIELD_PTR( bool_ref, visit_children )
 FIELD_PTR( at_cleanup_t, at_cleanup )
+FIELD_PTR( PassVisitor<pass_type> * const, visitor )

src/GenPoly/DeclMutator.cc

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Fri Nov 27 14:44:00 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug  4 11:16:43 2016
-// Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jun 22 13:49:00 2017
+// Update Count     : 4
 //
 
@@ -178 +178 @@
         Statement* DeclMutator::mutate(CatchStmt *catchStmt) {
                 catchStmt->set_decl( maybeMutate( catchStmt->get_decl(), *this ) );
+                catchStmt->set_cond( maybeMutate( catchStmt->get_cond(), *this ) );
                 catchStmt->set_body( mutateStatement( catchStmt->get_body() ) );
                 return catchStmt;

src/GenPoly/PolyMutator.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug  4 11:26:22 2016
-// Update Count     : 16
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jun 22 13:47:00 2017
+// Update Count     : 17
 //
 
@@ -123 +123 @@
 
         Statement * PolyMutator::mutate(TryStmt *tryStmt) {
-                tryStmt->set_block(  maybeMutate( tryStmt->get_block(), *this ) );
+                tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) );
                 mutateAll( tryStmt->get_catchers(), *this );
+                tryStmt->set_finally( maybeMutate( tryStmt->get_finally(), *this ) );
                 return tryStmt;
         }
 
         Statement * PolyMutator::mutate(CatchStmt *cathStmt) {
-                cathStmt->set_body(  mutateStatement( cathStmt->get_body() ) );
-                cathStmt->set_decl(  maybeMutate( cathStmt->get_decl(), *this ) );
+                cathStmt->set_body( mutateStatement( cathStmt->get_body() ) );
+                cathStmt->set_cond( maybeMutate( cathStmt->get_cond(), *this ) );
+                cathStmt->set_decl( maybeMutate( cathStmt->get_decl(), *this ) );
                 return cathStmt;
         }

src/GenPoly/Specialize.cc

@@ -99 +99 @@
                 if ( FunctionType * fftype = getFunctionType( formalType ) ) {
                         if ( fftype->isTtype() ) return true;
+                        // conversion of 0 (null) to function type does not require tuple specialization
+                        if ( dynamic_cast< ZeroType * >( actualType ) ) return false;
                         FunctionType * aftype = getFunctionType( actualType );
                         assertf( aftype, "formal type is a function type, but actual type is not." );

src/InitTweak/InitTweak.cc

@@ -474 +474 @@
         public:
                 ConstExprChecker() : isConstExpr( true ) {}
+
+                using Visitor::visit;
 
                 virtual void visit( __attribute((unused)) ApplicationExpr *applicationExpr ) { isConstExpr = false; }

src/Parser/StatementNode.cc

@@ -168 +168 @@
 
 Statement *build_resume_at( ExpressionNode *ctl, ExpressionNode *target ) {
-        std::list< Expression * > exps;
-        buildMoveList( ctl, exps );
-        assertf( exps.size() < 2, "This means we are leaking memory");
-        return new ThrowStmt( noLabels, ThrowStmt::Resume, !exps.empty() ? exps.back() : nullptr );
+        (void)ctl;
+        (void)target;
+        assertf( false, "resume at (non-local throw) is not yet supported," );
 }
 

src/SynTree/Constant.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun 21 16:44:48 2017
-// Update Count     : 27
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Jun 22 10:11:00 2017
+// Update Count     : 28
 //
 
@@ -29 +29 @@
 
 Constant::~Constant() { delete type; }
+
+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_int( int i ) {

src/SynTree/Constant.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun 21 16:44:48 2017
-// Update Count     : 14
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Jun 22 10:13:00 2017
+// Update Count     : 15
 //
 
@@ -33 +33 @@
         void set_value( std::string newValue ) { rep = newValue; }
 
+        /// generates a boolean constant of the given bool
+        static Constant from_bool( bool b );
         /// generates an integer constant of the given int
         static Constant from_int( int i );

src/SynTree/Mutator.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Mar  8 16:36:00 2017
-// Update Count     : 23
+// Last Modified On : Thu Jun 22 13:43:00 2017
+// Update Count     : 24
 //
 
@@ -162 +162 @@
         tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) );
         mutateAll( tryStmt->get_catchers(), *this );
+        tryStmt->set_finally( maybeMutate( tryStmt->get_finally(), *this ) );
         return tryStmt;
 }
@@ -167 +168 @@
 Statement *Mutator::mutate( CatchStmt *catchStmt ) {
         catchStmt->set_decl( maybeMutate( catchStmt->get_decl(), *this ) );
+        catchStmt->set_cond( maybeMutate( catchStmt->get_cond(), *this ) );
         catchStmt->set_body( maybeMutate( catchStmt->get_body(), *this ) );
         return catchStmt;

src/SynTree/Visitor.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Jun  8 16:31:00 2017
-// Update Count     : 25
+// Last Modified On : Thu Jun 22 13:41:00 2017
+// Update Count     : 26
 //
 
@@ -137 +137 @@
         maybeAccept( tryStmt->get_block(), *this );
         acceptAll( tryStmt->get_catchers(), *this );
+        maybeAccept( tryStmt->get_finally(), *this );
 }
 
 void Visitor::visit( CatchStmt *catchStmt ) {
         maybeAccept( catchStmt->get_decl(), *this );
+        maybeAccept( catchStmt->get_cond(), *this );
         maybeAccept( catchStmt->get_body(), *this );
 }

src/libcfa/Makefile.am

@@ -72 +72 @@
 libcfa_a_CFLAGS = -nodebug -O2
 libcfa_d_a_SOURCES = ${libsrc}
-libcfa_d_a_CFLAGS = -debug -O0
+libcfa_d_a_CFLAGS = -debug -O0 #No need for __CFA_DEBUG__ since we pass -debug
 
 stdhdr = ${shell echo stdhdr/*}

src/libcfa/Makefile.in

@@ -332 +332 @@
 libcfa_a_CFLAGS = -nodebug -O2
 libcfa_d_a_SOURCES = ${libsrc}
-libcfa_d_a_CFLAGS = -debug -O0
+libcfa_d_a_CFLAGS = -debug -O0 #No need for __CFA_DEBUG__ since we pass -debug
 stdhdr = ${shell echo stdhdr/*}
 cfa_includedir = $(CFA_INCDIR)

src/main.cc

@@ -186 +186 @@
                 if ( ! nopreludep ) {                                                   // include gcc builtins
                         // -l is for initial build ONLY and builtins.cf is not in the lib directory so access it here.
+                        // Read to cfa builtins, if not generating the cfa library
                         FILE * builtins = fopen( libcfap | treep ? "../prelude/builtins.cf" : CFA_LIBDIR "/builtins.cf", "r" );
                         assertf( builtins, "cannot open builtins.cf\n" );
                         parse( builtins, LinkageSpec::Compiler );
+
+                        // Read to gcc builtins, if not generating the cfa library
+                        FILE * gcc_builtins = fopen( libcfap | treep ? "../prelude/gcc-builtins.cf" : CFA_LIBDIR "/gcc-builtins.cf", "r" );
+                        assertf( gcc_builtins, "cannot open gcc-builtins.cf\n" );
+                        parse( gcc_builtins, LinkageSpec::Compiler );
 
                         // read the extra prelude in, if not generating the cfa library

src/prelude/Makefile.am

@@ -20 +20 @@
 # put into lib for now
 cfalibdir = ${CFA_LIBDIR}
-cfalib_DATA = builtins.cf extras.cf prelude.cf bootloader.c
+cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cf bootloader.c
 noinst_DATA = ../libcfa/libcfa-prelude.c
 
@@ -28 +28 @@
 
 # create forward declarations for gcc builtins
-builtins.cf : builtins.c prototypes.sed
+gcc-builtins.cf : gcc-builtins.c prototypes.sed
         ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -f prototypes.sed > $@
 
-builtins.c : builtins.def prototypes.awk
+gcc-builtins.c : builtins.def prototypes.awk
         ${AM_V_GEN}@BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@
 
@@ -38 +38 @@
 prototypes.awk :
 
-../libcfa/libcfa-prelude.c : prelude.cf extras.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
+# create forward declarations for cfa builtins
+builtins.cf : builtins.c
+        ${AM_V_GEN}@BACKEND_CC@ -E -P ${<} -o ${@}
+
+../libcfa/libcfa-prelude.c : prelude.cf extras.cf gcc-builtins.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
         ${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -l prelude.cf $@  # use src/cfa-cpp as not in lib until after install
 
-bootloader.c : bootloader.cf prelude.cf extras.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
+bootloader.c : bootloader.cf prelude.cf extras.cf gcc-builtins.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
         ${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -tpmL bootloader.cf $@  # use src/cfa-cpp as not in lib until after install
 
-MAINTAINERCLEANFILES = builtins.c builtins.cf extras.cf bootloader.c ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}
+MAINTAINERCLEANFILES = gcc-builtins.c gcc-builtins.cf builtins.cf extras.cf bootloader.c ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}

src/prelude/Makefile.in

@@ -211 +211 @@
 # put into lib for now
 cfalibdir = ${CFA_LIBDIR}
-cfalib_DATA = builtins.cf extras.cf prelude.cf bootloader.c
+cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cf bootloader.c
 noinst_DATA = ../libcfa/libcfa-prelude.c
-MAINTAINERCLEANFILES = builtins.c builtins.cf extras.cf bootloader.c ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}
+MAINTAINERCLEANFILES = gcc-builtins.c gcc-builtins.cf builtins.cf extras.cf bootloader.c ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}
 all: all-am
 
@@ -425 +425 @@
 
 # create forward declarations for gcc builtins
-builtins.cf : builtins.c prototypes.sed
+gcc-builtins.cf : gcc-builtins.c prototypes.sed
         ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -f prototypes.sed > $@
 
-builtins.c : builtins.def prototypes.awk
+gcc-builtins.c : builtins.def prototypes.awk
         ${AM_V_GEN}@BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@
 
@@ -435 +435 @@
 prototypes.awk :
 
-../libcfa/libcfa-prelude.c : prelude.cf extras.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
+# create forward declarations for cfa builtins
+builtins.cf : builtins.c
+        ${AM_V_GEN}@BACKEND_CC@ -E -P ${<} -o ${@}
+
+../libcfa/libcfa-prelude.c : prelude.cf extras.cf gcc-builtins.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
         ${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -l prelude.cf $@  # use src/cfa-cpp as not in lib until after install
 
-bootloader.c : bootloader.cf prelude.cf extras.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
+bootloader.c : bootloader.cf prelude.cf extras.cf gcc-builtins.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
         ${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -tpmL bootloader.cf $@  # use src/cfa-cpp as not in lib until after install
 

src/tests/preempt_longrun/Makefile.am

@@ -26 +26 @@
 CC = @CFA_BINDIR@/@CFA_NAME@
 
-TESTS = create stack yield
+TESTS = barge block create disjoint processor stack wait yield
 
 .INTERMEDIATE: ${TESTS}

src/tests/preempt_longrun/Makefile.in

@@ -183 +183 @@
 REPEAT = ${abs_top_srcdir}/tools/repeat -s
 BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ -debug -O2 -DN=${N} -DPREEMPTION_RATE=${preempt}
-TESTS = create stack yield
+TESTS = barge block create disjoint processor stack wait yield
 all: all-am
 

src/tests/sched-int-block.c

@@ -5 +5 @@
 #include <thread>
 
-static const unsigned N = 100_000;
+#ifndef N
+#define N 100_000
+#endif
 
 enum state_t { WAITED, SIGNAL, BARGE };

src/tests/sched-int-disjoint.c

@@ -4 +4 @@
 #include <thread>
 
+#ifndef N
 #define N 100_000
+#endif
 
 enum state_t { WAIT, SIGNAL, BARGE };

src/tests/sched-int-wait.c

@@ -5 +5 @@
 #include <thread>
 
-static const int N = 10_000;
+#ifndef N
+#define N 10_000
+#endif
 
 monitor global_t {};

tools/repeat

@@ -20 +20 @@
 for (( i = 0; i < ITERATION; i ++ )); do
         echo -ne "\r$i / $ITERATION"
-        $@ &
+        $@ > /dev/null &
         child=$! 
         wait "$child"