Changeset d43cd01

Timestamp:

Jun 23, 2017, 10:12:09 AM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

2ac095d

Parents:

1c273d0 (diff), 653f2c7 (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:software/cfa/cfa-cc

Files:

• 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)

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 );
 }