Changeset 67fa9f9 for src

Timestamp:

Jul 5, 2017, 10:50:22 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:

0614d14

Parents:

11dbfe1 (diff), 307a732 (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

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (3 diffs)
• CodeGen/CodeGenerator.h (modified) (2 diffs)
• Common/PassVisitor.h (modified) (9 diffs)
• Common/PassVisitor.impl.h (modified) (9 diffs)
• Common/PassVisitor.proto.h (modified) (3 diffs)
• Common/utility.h (modified) (1 diff)
• ControlStruct/ExceptTranslate.cc (modified) (27 diffs)
• ControlStruct/ExceptTranslate.h (modified) (2 diffs)
• ControlStruct/module.mk (modified) (1 diff)
• GenPoly/Box.cc (modified) (4 diffs)
• GenPoly/InstantiateGeneric.cc (modified) (11 diffs)
• InitTweak/FixInit.cc (modified) (8 diffs)
• InitTweak/GenInit.cc (modified) (8 diffs)
• InitTweak/InitTweak.cc (modified) (1 diff)
• MakeLibCfa.cc (modified) (1 diff)
• Makefile.in (modified) (12 diffs)
• Parser/InitializerNode.cc (modified) (1 diff)
• Parser/TypeData.cc (modified) (2 diffs)
• Parser/parser.yy (modified) (4 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (4 diffs)
• ResolvExpr/AlternativeFinder.h (modified) (1 diff)
• ResolvExpr/CurrentObject.cc (added)
• ResolvExpr/CurrentObject.h (added)
• ResolvExpr/Resolver.cc (modified) (10 diffs)
• ResolvExpr/Unify.cc (modified) (4 diffs)
• ResolvExpr/module.mk (modified) (2 diffs)
• SymTab/Autogen.h (modified) (3 diffs)
• SymTab/ImplementationType.cc (modified) (2 diffs)
• SymTab/Indexer.cc (modified) (4 diffs)
• SymTab/Validate.cc (modified) (9 diffs)
• SynTree/Constant.cc (modified) (2 diffs)
• SynTree/Constant.h (modified) (2 diffs)
• SynTree/Expression.cc (modified) (3 diffs)
• SynTree/Expression.h (modified) (1 diff)
• SynTree/Initializer.cc (modified) (3 diffs)
• SynTree/Initializer.h (modified) (7 diffs)
• SynTree/Mutator.cc (modified) (4 diffs)
• SynTree/Mutator.h (modified) (2 diffs)
• SynTree/SynTree.h (modified) (2 diffs)
• SynTree/TupleType.cc (modified) (1 diff)
• SynTree/Type.h (modified) (3 diffs)
• SynTree/VarExprReplacer.cc (modified) (1 diff)
• SynTree/VarExprReplacer.h (modified) (1 diff)
• SynTree/Visitor.cc (modified) (4 diffs)
• SynTree/Visitor.h (modified) (2 diffs)
• Tuples/TupleExpansion.cc (modified) (2 diffs)
• libcfa/Makefile.am (modified) (1 diff)
• libcfa/Makefile.in (modified) (9 diffs)
• libcfa/exception.c (modified) (8 diffs)
• libcfa/exception.h (modified) (1 diff)
• libcfa/fstream (modified) (3 diffs)
• libcfa/fstream.c (modified) (6 diffs)
• libcfa/iostream (modified) (4 diffs)
• libcfa/iostream.c (modified) (3 diffs)
• libcfa/lsda.h (added)
• main.cc (modified) (4 diffs)
• prelude/Makefile.am (modified) (2 diffs)
• prelude/Makefile.in (modified) (2 diffs)
• tests/.expect/designations.txt (added)
• tests/.expect/io.txt (modified) (3 diffs)
• tests/designations.c (added)
• tests/except-0.c (added)
• tests/exception.c (deleted)
• tests/io.c (modified) (9 diffs)

src/CodeGen/CodeGenerator.cc

@@ -288 +288 @@
         }
 
-        void CodeGenerator::printDesignators( std::list< Expression * > & designators ) {
-                typedef std::list< Expression * > DesignatorList;
+        void CodeGenerator::visit( Designation * designation ) {
+                std::list< Expression * > designators = designation->get_designators();
                 if ( designators.size() == 0 ) return;
-                for ( DesignatorList::iterator iter = designators.begin(); iter != designators.end(); ++iter ) {
-                        if ( dynamic_cast< NameExpr * >( *iter ) ) {
-                                // if expression is a name, then initializing aggregate member
+                for ( Expression * des : designators ) {
+                        if ( dynamic_cast< NameExpr * >( des ) || dynamic_cast< VariableExpr * >( des ) ) {
+                                // if expression is a NameExpr or VariableExpr, then initializing aggregate member
                                 output << ".";
-                                (*iter)->accept( *this );
+                                des->accept( *this );
                         } else {
-                                // if not a simple name, it has to be a constant expression, i.e. an array designator
+                                // otherwise, it has to be a ConstantExpr or CastExpr, initializing array eleemnt
                                 output << "[";
-                                (*iter)->accept( *this );
+                                des->accept( *this );
                                 output << "]";
                         } // if
@@ -307 +307 @@
 
         void CodeGenerator::visit( SingleInit * init ) {
-                printDesignators( init->get_designators() );
                 init->get_value()->accept( *this );
         }
 
         void CodeGenerator::visit( ListInit * init ) {
-                printDesignators( init->get_designators() );
+                auto initBegin = init->begin();
+                auto initEnd = init->end();
+                auto desigBegin = init->get_designations().begin();
+                auto desigEnd = init->get_designations().end();
+
                 output << "{ ";
-                genCommaList( init->begin(), init->end() );
+                for ( ; initBegin != initEnd && desigBegin != desigEnd; ) {
+                        (*desigBegin)->accept( *this );
+                        (*initBegin)->accept( *this );
+                        ++initBegin, ++desigBegin;
+                        if ( initBegin != initEnd ) {
+                                output << ", ";
+                        }
+                }
                 output << " }";
+                assertf( initBegin == initEnd && desigBegin == desigEnd, "Initializers and designators not the same length. %s", toString( init ).c_str() );
         }
 
@@ -716 +727 @@
 
         void CodeGenerator::visit( TypeExpr * typeExpr ) {
-                assertf( ! genC, "TypeExpr should not reach code generation." );
-                output<< genType( typeExpr->get_type(), "", pretty, genC );
+                // if ( genC ) std::cerr << "typeexpr still exists: " << typeExpr << std::endl;
+                // assertf( ! genC, "TypeExpr should not reach code generation." );
+                if ( ! genC ) {
+                        output<< genType( typeExpr->get_type(), "", pretty, genC );
+                }
         }
 

src/CodeGen/CodeGenerator.h

@@ -47 +47 @@
 
                 //*** Initializer
+                virtual void visit( Designation * );
                 virtual void visit( SingleInit * );
                 virtual void visit( ListInit * );
@@ -137 +138 @@
                 bool lineMarks = false;
 
-                void printDesignators( std::list< Expression * > & );
                 void handleStorageClass( DeclarationWithType *decl );
                 void handleAggregate( AggregateDecl *aggDecl, const std::string & kind );

src/Common/PassVisitor.h

@@ -12 +12 @@
 #include "SynTree/Expression.h"
 #include "SynTree/Constant.h"
+#include "SynTree/TypeSubstitution.h"
 
 #include "PassVisitor.proto.h"
@@ -26 +27 @@
 //                          stmtsToAddBefore or stmtsToAddAfter respectively.
 // | 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
+// | WithGuards           - 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.
 //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -32 +33 @@
 class PassVisitor final : public Visitor, public Mutator {
 public:
-        PassVisitor() = default;
 
         template< typename... Args >
@@ -257 +257 @@
 
         void set_visit_children( bool& ref ) { bool_ref * ptr = visit_children_impl(pass, 0); if(ptr) ptr->set( ref ); }
-
-        guard_value_impl init_guard() {
-                guard_value_impl guard;
-                auto at_cleanup = at_cleanup_impl(pass, 0);
-                if( at_cleanup ) {
-                        *at_cleanup = [&guard]( cleanup_func_t && func, void* val ) {
-                                guard.push( std::move( func ), val );
-                        };
-                }
-                return guard;
-        }
 };
 
@@ -283 +272 @@
 
 public:
-        TypeSubstitution * env;
+        TypeSubstitution * env = nullptr;
 };
 
@@ -295 +284 @@
         std::list< Statement* > stmtsToAddAfter;
 };
+
+class WithDeclsToAdd {
+protected:
+        WithDeclsToAdd() = default;
+        ~WithDeclsToAdd() = default;
+
+public:
+        std::list< Declaration* > declsToAddBefore;
+        std::list< Declaration* > declsToAddAfter;
+};
+
 class WithShortCircuiting {
 protected:
@@ -304 +304 @@
 };
 
-class WithScopes {
-protected:
-        WithScopes() = default;
-        ~WithScopes() = default;
+class WithGuards {
+protected:
+        WithGuards() = default;
+        ~WithGuards() = default;
 
 public:
@@ -318 +318 @@
                 }, static_cast< void * >( & val ) );
         }
+
+        template< typename T >
+        void GuardScope( T& val ) {
+                val.beginScope();
+                at_cleanup( []( void * val ) {
+                        static_cast< T * >( val )->endScope();
+                }, static_cast< void * >( & val ) );
+        }
+
+        template< typename Func >
+        void GuardAction( Func func ) {
+                at_cleanup( [func](__attribute__((unused)) void *) { func(); }, nullptr );
+        }
 };
 
@@ -323 +336 @@
 class WithVisitorRef {
 protected:
-        WithVisitorRef() = default;
-        ~WithVisitorRef() = default;
-
-public:
-        PassVisitor<pass_type> * const visitor;
+        WithVisitorRef() {}
+        ~WithVisitorRef() {}
+
+public:
+        PassVisitor<pass_type> * const visitor = nullptr;
 };
 

src/Common/PassVisitor.impl.h

@@ -3 +3 @@
 #define VISIT_START( node )                     \
         __attribute__((unused))                   \
-        const auto & guard = init_guard();        \
+        guard_value_impl guard( at_cleanup_impl(pass, 0) );       \
         bool visit_children = true;               \
         set_visit_children( visit_children );   \
@@ -15 +15 @@
 #define MUTATE_START( node )                    \
         __attribute__((unused))                   \
-        const auto & guard = init_guard();        \
+        guard_value_impl guard( at_cleanup_impl(pass, 0) );       \
         bool visit_children = true;               \
         set_visit_children( visit_children );   \
@@ -68 +68 @@
         for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
                 // splice in new declarations after previous decl
-                if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); } 
+                if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
 
                 if ( i == decls.end() ) break;
@@ -88 +88 @@
         for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
                 // splice in new declarations after previous decl
-                if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); } 
+                if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
 
                 if ( i == decls.end() ) break;
@@ -104 +104 @@
 void PassVisitor< pass_type >::handleStatementList( std::list< Statement * > & statements, func_t func ) {
         SemanticError errors;
+
+        // don't want statements from outer CompoundStmts to be added to this CompoundStmt
+        ValueGuardPtr< StmtList_t > oldBeforeStmts( get_beforeStmts() );
+        ValueGuardPtr< StmtList_t > oldAfterStmts ( get_afterStmts () );
+        ValueGuardPtr< DeclList_t > oldBeforeDecls( get_beforeDecls() );
+        ValueGuardPtr< DeclList_t > oldAfterDecls ( get_afterDecls () );
 
         StmtList_t* beforeStmts = get_beforeStmts();
@@ -181 +187 @@
 Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
         return handleStatement( stmt, [this]( Statement * stmt ) {
-                maybeAccept( stmt, *this ); 
+                maybeAccept( stmt, *this );
                 return stmt;
         });
@@ -212 +218 @@
                 expr->accept( *this );
                 return expr;
-        });             
+        });
 }
 
@@ -565 +571 @@
         VISIT_START( node );
 
+        // maybeAccept( node->get_env(), *this );
+        maybeAccept( node->get_result(), *this );
+
         for ( auto expr : node->get_args() ) {
                 visitExpression( expr );
@@ -575 +584 @@
 Expression * PassVisitor< pass_type >::mutate( UntypedExpr * node ) {
         MUTATE_START( node );
+
+        node->set_env( maybeMutate( node->get_env(), *this ) );
+        node->set_result( maybeMutate( node->get_result(), *this ) );
 
         for ( auto& expr : node->get_args() ) {

src/Common/PassVisitor.proto.h

@@ -5 +5 @@
 
 typedef std::function<void( void * )> cleanup_func_t;
+typedef std::function< void( cleanup_func_t, void * ) > at_cleanup_t;
 
 class guard_value_impl {
 public:
-        guard_value_impl() = default;
+        guard_value_impl( at_cleanup_t * at_cleanup ) {
+                if( at_cleanup ) {
+                        *at_cleanup = [this]( cleanup_func_t && func, void* val ) {
+                                push( std::move( func ), val );
+                        };
+                }
+        }
 
         ~guard_value_impl() {
@@ -33 +40 @@
 };
 
-typedef std::function< void( cleanup_func_t, void * ) > at_cleanup_t;
 
 class bool_ref {
@@ -56 +62 @@
 // Deep magic (a.k.a template meta programming) to make the templated visitor work
 // Basically the goal is to make 2 previsit_impl
-// 1 - Use when a pass implements a valid previsit. This uses overloading which means the any overload of 
+// 1 - Use when a pass implements a valid previsit. This uses overloading which means the any overload of
 //     'pass.previsit( node )' that compiles will be used for that node for that type
 //     This requires that this option only compile for passes that actually define an appropriate visit.

src/Common/utility.h

@@ -305 +305 @@
 // for ( val : group_iterate( container1, container2, ... ) ) {}
 // syntax to have a for each that iterates multiple containers of the same length
-// TODO: update to use variadic arguments
+// TODO: update to use variadic arguments, perfect forwarding
 
 template< typename T1, typename T2 >

src/ControlStruct/ExceptTranslate.cc

@@ -10 +10 @@
 // Created On       : Wed Jun 14 16:49:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr Jun 22 15:57:00 2017
-// Update Count     : 0
+// Last Modified On : Fri Jun 30 13:30:00 2017
+// Update Count     : 1
 //
 
 #include "ExceptTranslate.h"
 #include "Common/PassVisitor.h"
-
-namespace ControlFlow {
+#include "SynTree/Statement.h"
+#include "SynTree/Declaration.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Type.h"
+#include "SynTree/Attribute.h"
+
+namespace ControlStruct {
 
         // This (large) section could probably be moved out of the class
@@ -24 +29 @@
         // Type(Qualifiers &, false, std::list<Attribute *> &)
 
-        // void (*function)()
-        static FunctionType void_func_t(Type::Qualifiers(), false);
+        // void (*function)();
+        static FunctionType try_func_t(Type::Qualifiers(), false);
         // void (*function)(int, exception);
         static FunctionType catch_func_t(Type::Qualifiers(), false);
@@ -32 +37 @@
         // bool (*function)(exception);
         static FunctionType handle_func_t(Type::Qualifiers(), false);
+        // void (*function)(__attribute__((unused)) void *);
+        static FunctionType finally_func_t(Type::Qualifiers(), false);
 
         static void init_func_types() {
-                static init_complete = false;
+                static bool init_complete = false;
                 if (init_complete) {
                         return;
                 }
                 ObjectDecl index_obj(
-                        "index_t",
+                        "__handler_index",
                         Type::StorageClasses(),
                         LinkageSpec::Cforall,
                         /*bitfieldWidth*/ NULL,
-                        new BasicType(emptyQualifiers, BasicType::UnsignedInt),
+                        new BasicType( emptyQualifiers, BasicType::SignedInt ),
                         /*init*/ NULL
-                );
+                        );
                 ObjectDecl exception_obj(
-                        "exception_t",
+                        "__exception_inst",
                         Type::StorageClasses(),
                         LinkageSpec::Cforall,
                         /*bitfieldWidth*/ NULL,
-                        new BasicType(emptyQualifiers, BasicType::UnsignedInt),
+                        new PointerType(
+                                emptyQualifiers,
+                                new BasicType( emptyQualifiers, BasicType::SignedInt )
+                                ),
                         /*init*/ NULL
-                );
+                        );
                 ObjectDecl bool_obj(
-                        "bool_t",
+                        "__ret_bool",
                         Type::StorageClasses(),
                         LinkageSpec::Cforall,
@@ -61 +71 @@
                         new BasicType(emptyQualifiers, BasicType::Bool),
                         /*init*/ NULL
-                );
-
-                catch_func_t.get_parameters().push_back(index_obj.clone());
-                catch_func_t.get_parameters().push_back(exception_obj.clone());
-                match_func_t.get_returnVals().push_back(index_obj.clone());
-                match_func_t.get_parameters().push_back(exception_obj.clone());
-                handle_func_t.get_returnVals().push_back(bool_obj.clone());
-                handle_func_t.get_parameters().push_back(exception_obj.clone());
+                        );
+                ObjectDecl voidptr_obj(
+                        "__hook",
+                        Type::StorageClasses(),
+                        LinkageSpec::Cforall,
+                        NULL,
+                        new PointerType(
+                                emptyQualifiers,
+                                new VoidType(
+                                        emptyQualifiers
+                                        ),
+                                std::list<Attribute *>{new Attribute("unused")}
+                                ),
+                        NULL
+                        );
+
+                catch_func_t.get_parameters().push_back( index_obj.clone() );
+                catch_func_t.get_parameters().push_back( exception_obj.clone() );
+                match_func_t.get_returnVals().push_back( index_obj.clone() );
+                match_func_t.get_parameters().push_back( exception_obj.clone() );
+                handle_func_t.get_returnVals().push_back( bool_obj.clone() );
+                handle_func_t.get_parameters().push_back( exception_obj.clone() );
+                finally_func_t.get_parameters().push_back( voidptr_obj.clone() );
 
                 init_complete = true;
@@ -78 +103 @@
 
         void split( CatchList& allHandlers, CatchList& terHandlers,
-                    CatchList& resHandlers ) {
+                                CatchList& resHandlers ) {
                 while ( !allHandlers.empty() ) {
-                        Statement * stmt = allHandlers.front();
+                        CatchStmt * stmt = allHandlers.front();
                         allHandlers.pop_front();
-                        if (CaseStmt::Terminate == stmt->get_kind()) {
+                        if (CatchStmt::Terminate == stmt->get_kind()) {
                                 terHandlers.push_back(stmt);
                         } else {
@@ -92 +117 @@
         template<typename T>
         void free_all( std::list<T *> &list ) {
-                std::list<T *>::iterator it;
+                typename std::list<T *>::iterator it;
                 for ( it = list.begin() ; it != list.end() ; ++it ) {
                         delete *it;
@@ -100 +125 @@
 
         void appendDeclStmt( CompoundStmt * block, Declaration * item ) {
-                block->push_back(new DeclStmt(no_labels, item));
-        }
-
-        Expression * nameOf( FunctionDecl * function ) {
-                return new VariableExpr( function );
+                block->push_back(new DeclStmt(noLabels, item));
+        }
+
+        Expression * nameOf( DeclarationWithType * decl ) {
+                return new VariableExpr( decl );
         }
 
         // ThrowStmt Mutation Helpers
 
-        Statement * create_terminate_throw( ThrowStmt *throwStmt ) {
-                // __throw_terminate( EXPR );
-                ApplicationExpr * call = new ApplicationExpr( /* ... */ );
-                call->get_args.push_back( throwStmt->get_expr() );
-                Statement * result = new ExprStmt( throwStmt->get_labels(), call );
+        Statement * create_given_throw(
+                        const char * throwFunc, ThrowStmt * throwStmt ) {
+                // { int NAME = EXPR; throwFunc( &NAME ); }
+                CompoundStmt * result = new CompoundStmt( noLabels );
+                ObjectDecl * local = new ObjectDecl(
+                        "__local_exception_copy",
+                        Type::StorageClasses(),
+                        LinkageSpec::Cforall,
+                        NULL,
+                        new BasicType( emptyQualifiers, BasicType::SignedInt ),
+                        new SingleInit( throwStmt->get_expr() )
+                        );
+                appendDeclStmt( result, local );
+                UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
+                call->get_args().push_back( new AddressExpr( nameOf( local ) ) );
+                result->push_back( new ExprStmt( throwStmt->get_labels(), call ) );
                 throwStmt->set_expr( nullptr );
                 delete throwStmt;
                 return result;
         }
+
+        Statement * create_terminate_throw( ThrowStmt *throwStmt ) {
+                // { int NAME = EXPR; __throw_terminate( &NAME ); }
+                return create_given_throw( "__cfaehm__throw_termination", throwStmt );
+        }
         Statement * create_terminate_rethrow( ThrowStmt *throwStmt ) {
                 // __rethrow_terminate();
+                assert( nullptr == throwStmt->get_expr() );
                 Statement * result = new ExprStmt(
                         throwStmt->get_labels(),
-                        new ApplicationExpr( /* ... */ );
+                        new UntypedExpr( new NameExpr( "__cfaehm__rethrow_termination" ) )
                         );
                 delete throwStmt;
@@ -129 +171 @@
         Statement * create_resume_throw( ThrowStmt *throwStmt ) {
                 // __throw_resume( EXPR );
-                ApplicationExpr * call = new ApplicationExpr( /* ... */ );
-                call->get_args.push_back( throwStmt->get_expr() );
-                Statement * result = new ExprStmt( throwStmt->get_labels(), call );
-                throwStmt->set_expr( nullptr );
-                delete throwStmt;
-                return result;
+                return create_given_throw( "__cfaehm__throw_resumption", throwStmt );
         }
         Statement * create_resume_rethrow( ThrowStmt *throwStmt ) {
@@ -140 +177 @@
                 Statement * result = new ReturnStmt(
                         throwStmt->get_labels(),
-                        new ConstantExpr(
-                                Constant(
-                                        new BasicType(
-                                                Type::Qualifiers(),
-                                                BasicType::Bool
-                                                ),
-                                        "0")
-                                )
+                        new ConstantExpr( Constant::from_bool( false ) )
                         );
                 delete throwStmt;
@@ -160 +190 @@
                 return block;
         }
-        FunctionDecl * create_try_wrapper( TryStmt *tryStmt ) {
-                CompoundStmt * body = base_try->get_block();
-                base_try->set_block(nullptr);
-
-                return new FunctionDecl("try", Type::StorageClasses(),
-                        LinkageSpec::Cforall, void_func_t, body);
+        FunctionDecl * create_try_wrapper( CompoundStmt *body ) {
+
+                return new FunctionDecl( "try", Type::StorageClasses(),
+                        LinkageSpec::Cforall, try_func_t.clone(), body );
         }
 
         FunctionDecl * create_terminate_catch( CatchList &handlers ) {
                 std::list<CaseStmt *> handler_wrappers;
+
+                FunctionType *func_type = catch_func_t.clone();
+                DeclarationWithType * index_obj = func_type->get_parameters().front();
+        //      DeclarationWithType * except_obj = func_type->get_parameters().back();
 
                 // Index 1..{number of handlers}
@@ -178 +210 @@
                         CatchStmt * handler = *it;
 
-                        std::list<Statement *> core;
-                        if ( /*the exception is named*/ ) {
-                                ObjectDecl * local_except = /* Dynamic case, same */;
-                                core->push_back( new DeclStmt( noLabel, local_except ) );
-                        }
-                        // Append the provided statement to the handler.
-                        core->push_back( cur_handler->get_body() );
-                        // Append return onto the inner block? case stmt list?
-                        CaseStmt * wrapper = new CaseStmt(
+                        // INTEGERconstant Version
+                        // case `index`:
+                        // {
+                        //     `handler.body`
+                        // }
+                        // return;
+                        std::list<Statement *> caseBody;
+                        caseBody.push_back( handler->get_body() );
+                        handler->set_body( nullptr );
+                        caseBody.push_back( new ReturnStmt( noLabels, nullptr ) );
+
+                        handler_wrappers.push_back( new CaseStmt(
                                 noLabels,
                                 new ConstantExpr( Constant::from_int( index ) ),
-                                core
-                                );
-                        handler_wrappers.push_back(wrapper);
+                                caseBody
+                                ) );
                 }
                 // TODO: Some sort of meaningful error on default perhaps?
+
+                std::list<Statement*> stmt_handlers;
+                while ( !handler_wrappers.empty() ) {
+                        stmt_handlers.push_back( handler_wrappers.front() );
+                        handler_wrappers.pop_front();
+                }
 
                 SwitchStmt * handler_lookup = new SwitchStmt(
                         noLabels,
-                        /*parameter 0: index*/,
-                        handler_wrappers,
-                        false
+                        nameOf( index_obj ),
+                        stmt_handlers
                         );
                 CompoundStmt * body = new CompoundStmt( noLabels );
@@ -205 +244 @@
 
                 return new FunctionDecl("catch", Type::StorageClasses(),
-                        LinkageSpec::Cforall, catch_func_t, body);
+                        LinkageSpec::Cforall, func_type, body);
         }
 
         // Create a single check from a moddified handler.
-        CompoundStmt *create_single_matcher( CatchStmt * modded_handler ) {
-                CompoundStmt * block = new CompoundStmt( noLables );
-
-                appendDeclStmt( block, modded_handler->get_decl() );
-
-                // TODO: This is not the actual check.
-                LogicalExpr * cond = new ConstantExpr( Constant::from_bool( false ) );
+        // except_obj is referenced, modded_handler will be freed.
+        CompoundStmt *create_single_matcher(
+                        DeclarationWithType * except_obj, CatchStmt * modded_handler ) {
+                CompoundStmt * block = new CompoundStmt( noLabels );
+
+                // INTEGERconstant Version
+                assert( nullptr == modded_handler->get_decl() );
+                ConstantExpr * number =
+                        dynamic_cast<ConstantExpr*>( modded_handler->get_cond() );
+                assert( number );
+                modded_handler->set_cond( nullptr );
+
+                Expression * cond;
+                {
+                        std::list<Expression *> args;
+                        args.push_back( number );
+
+                        std::list<Expression *> rhs_args;
+                        rhs_args.push_back( nameOf( except_obj ) );
+                        Expression * rhs = new UntypedExpr(
+                                new NameExpr( "*?" ), rhs_args );
+                        args.push_back( rhs );
+
+                        cond = new UntypedExpr( new NameExpr( "?==?" /*???*/), args );
+                }
 
                 if ( modded_handler->get_cond() ) {
-                        cond = new LogicalExpr( cond, modded_handler->get_cond() )q
+                        cond = new LogicalExpr( cond, modded_handler->get_cond() );
                 }
                 block->push_back( new IfStmt( noLabels,
-                        cond, modded_handler->get_body() );
+                        cond, modded_handler->get_body(), nullptr ) );
 
                 modded_handler->set_decl( nullptr );
@@ -232 +289 @@
         FunctionDecl * create_terminate_match( CatchList &handlers ) {
                 CompoundStmt * body = new CompoundStmt( noLabels );
+
+                FunctionType * func_type = match_func_t.clone();
+                DeclarationWithType * except_obj = func_type->get_parameters().back();
 
                 // Index 1..{number of handlers}
@@ -240 +300 @@
                         CatchStmt * handler = *it;
 
-                        // body should have been taken by create_terminate_catch.
-                        // assert( nullptr == handler->get_body() );
+                        // Body should have been taken by create_terminate_catch.
+                        assert( nullptr == handler->get_body() );
+
+                        // Create new body.
                         handler->set_body( new ReturnStmt( noLabels,
                                 new ConstantExpr( Constant::from_int( index ) ) ) );
 
-                        body->push_back( create_single_matcher( handler ) );
-                }
+                        // Create the handler.
+                        body->push_back( create_single_matcher( except_obj, handler ) );
+                        *it = nullptr;
+                }
+
+                body->push_back( new ReturnStmt( noLabels, new ConstantExpr(
+                        Constant::from_int( 0 ) ) ) );
 
                 return new FunctionDecl("match", Type::StorageClasses(),
-                        LinkageSpec::Cforall, match_func_t, body);
-        }
-
-        Statement * create_terminate_caller(
+                        LinkageSpec::Cforall, func_type, body);
+        }
+
+        CompoundStmt * create_terminate_caller(
                         FunctionDecl * try_wrapper,
                         FunctionDecl * terminate_catch,
                         FunctionDecl * terminate_match) {
 
-                ApplicationExpr * caller = new ApplicationExpr( /* ... */ );
-                std::list<Expression *>& args = caller.get_args();
+                UntypedExpr * caller = new UntypedExpr( new NameExpr(
+                        "__cfaehm__try_terminate" ) );
+                std::list<Expression *>& args = caller->get_args();
                 args.push_back( nameOf( try_wrapper ) );
                 args.push_back( nameOf( terminate_catch ) );
                 args.push_back( nameOf( terminate_match ) );
 
-                return new ExprStmt( noLabels, caller );
+                CompoundStmt * callStmt = new CompoundStmt( noLabels );
+                callStmt->push_back( new ExprStmt( noLabels, caller ) );
+                return callStmt;
         }
 
         FunctionDecl * create_resume_handler( CatchList &handlers ) {
-                CompoundStmt * body = new CompountStmt( noLabels );
+                CompoundStmt * body = new CompoundStmt( noLabels );
+
+                FunctionType * func_type = match_func_t.clone();
+                DeclarationWithType * except_obj = func_type->get_parameters().back();
 
                 CatchList::iterator it;
@@ -280 +353 @@
                                 handling_code->push_back( handler->get_body() );
                         }
-                        handling_code->push_back( new ReturnStmt( noLabel,
+                        handling_code->push_back( new ReturnStmt( noLabels,
                                 new ConstantExpr( Constant::from_bool( false ) ) ) );
                         handler->set_body( handling_code );
 
                         // Create the handler.
-                        body->push_back( create_single_matcher( handler ) );
+                        body->push_back( create_single_matcher( except_obj, handler ) );
+                        *it = nullptr;
                 }
 
                 return new FunctionDecl("handle", Type::StorageClasses(),
-                        LinkageSpec::Cforall, handle_func_t, body);
-        }
-
-        Statement * create_resume_wrapper(
+                        LinkageSpec::Cforall, func_type, body);
+        }
+
+        CompoundStmt * create_resume_wrapper(
+                        StructDecl * node_decl,
                         Statement * wraps,
                         FunctionDecl * resume_handler ) {
                 CompoundStmt * body = new CompoundStmt( noLabels );
 
-                // struct node = {current top resume handler, call to resume_handler};
-                // __attribute__((cleanup( ... )));
-                // set top resume handler to node.
-                // The wrapped statement.
-
-                ListInit * node_init;
-                {
-                        std::list<Initializer*> field_inits;
-                        field_inits.push_back( new SingleInit( /* ... */ ) );
-                        field_inits.push_back( new SingleInit( nameOf( resume_handler ) ) );
-                        node_init = new ListInit( field_inits );
-                }
+                // struct __try_resume_node __resume_node
+                //      __attribute__((cleanup( __cfaehm__try_resume_cleanup )));
+                // ** unwinding of the stack here could cause problems **
+                // ** however I don't think that can happen currently **
+                // __cfaehm__try_resume_setup( &__resume_node, resume_handler );
 
                 std::list< Attribute * > attributes;
                 {
                         std::list< Expression * > attr_params;
-                        attr_params.push_back( nameOf( /* ... deconstructor ... */ ) );
-                        attrributes.push_back( new Attribute( "cleanup", attr_params ) );
-                }
-
-                appendDeclStmt( body,
-                /**/ ObjectDecl(
-                        "resume_node",
+                        attr_params.push_back( new NameExpr(
+                                "__cfaehm__try_resume_cleanup" ) );
+                        attributes.push_back( new Attribute( "cleanup", attr_params ) );
+                }
+
+                ObjectDecl * obj = new ObjectDecl(
+                        "__resume_node",
                         Type::StorageClasses(),
                         LinkageSpec::Cforall,
                         nullptr,
-                        /* Type* = resume_node */,
-                        node_init,
+                        new StructInstType(
+                                Type::Qualifiers(),
+                                node_decl
+                                ),
+                        nullptr,
                         attributes
-                        )
-                );
+                        );
+                appendDeclStmt( body, obj );
+
+                UntypedExpr *setup = new UntypedExpr( new NameExpr(
+                        "__cfaehm__try_resume_setup" ) );
+                setup->get_args().push_back( new AddressExpr( nameOf( obj ) ) );
+                setup->get_args().push_back( nameOf( resume_handler ) );
+
+                body->push_back( new ExprStmt( noLabels, setup ) );
+
                 body->push_back( wraps );
                 return body;
@@ -333 +412 @@
 
         FunctionDecl * create_finally_wrapper( TryStmt * tryStmt ) {
-                CompoundStmt * body = tryStmt->get_finally();
+                FinallyStmt * finally = tryStmt->get_finally();
+                CompoundStmt * body = finally->get_block();
+                finally->set_block( nullptr );
+                delete finally;
                 tryStmt->set_finally( nullptr );
 
                 return new FunctionDecl("finally", Type::StorageClasses(),
-                        LinkageSpec::Cforall, void_func_t, body);
-        }
-
-        ObjectDecl * create_finally_hook( FunctionDecl * finally_wrapper ) {
-                // struct _cleanup_hook NAME __attribute__((cleanup( ... )));
+                        LinkageSpec::Cforall, finally_func_t.clone(), body);
+        }
+
+        ObjectDecl * create_finally_hook(
+                        StructDecl * hook_decl, FunctionDecl * finally_wrapper ) {
+                // struct __cfaehm__cleanup_hook __finally_hook
+                //      __attribute__((cleanup( finally_wrapper )));
 
                 // Make Cleanup Attribute.
@@ -348 +432 @@
                         std::list< Expression * > attr_params;
                         attr_params.push_back( nameOf( finally_wrapper ) );
-                        attrributes.push_back( new Attribute( "cleanup", attr_params ) );
-                }
-
-                return ObjectDecl( /* ... */
-                        const std::string &name "finally_hook",
+                        attributes.push_back( new Attribute( "cleanup", attr_params ) );
+                }
+
+                return new ObjectDecl(
+                        "__finally_hook",
                         Type::StorageClasses(),
                         LinkageSpec::Cforall,
                         nullptr,
-                        /* ... Type * ... */,
+                        new StructInstType(
+                                emptyQualifiers,
+                                hook_decl
+                                ),
                         nullptr,
                         attributes
@@ -363 +450 @@
 
 
-        class ExceptionMutatorCore : public WithScoping {
+        class ExceptionMutatorCore : public WithGuards {
                 enum Context { NoHandler, TerHandler, ResHandler };
 
@@ -370 +457 @@
                 // loop, switch or the goto stays within the function.
 
-                Context curContext;
+                Context cur_context;
 
                 // We might not need this, but a unique base for each try block's
@@ -377 +464 @@
                 //unsigned int try_count = 0;
 
+                StructDecl *node_decl;
+                StructDecl *hook_decl;
 
         public:
                 ExceptionMutatorCore() :
-                        curContext(NoHandler)
+                        cur_context(NoHandler),
+                        node_decl(nullptr), hook_decl(nullptr)
                 {}
 
-                void premutate( CatchStmt *tryStmt );
+                void premutate( CatchStmt *catchStmt );
+                void premutate( StructDecl *structDecl );
                 Statement * postmutate( ThrowStmt *throwStmt );
                 Statement * postmutate( TryStmt *tryStmt );
@@ -393 +484 @@
                         if ( throwStmt->get_expr() ) {
                                 return create_terminate_throw( throwStmt );
-                        } else if ( TerHandler == curContext ) {
+                        } else if ( TerHandler == cur_context ) {
                                 return create_terminate_rethrow( throwStmt );
                         } else {
                                 assertf(false, "Invalid throw in %s at %i\n",
-                                        throwStmt->location.filename,
+                                        throwStmt->location.filename.c_str(),
                                         throwStmt->location.linenumber);
                                 return nullptr;
@@ -404 +495 @@
                         if ( throwStmt->get_expr() ) {
                                 return create_resume_throw( throwStmt );
-                        } else if ( ResHandler == curContext ) {
+                        } else if ( ResHandler == cur_context ) {
                                 return create_resume_rethrow( throwStmt );
                         } else {
                                 assertf(false, "Invalid throwResume in %s at %i\n",
-                                        throwStmt->location.filename,
+                                        throwStmt->location.filename.c_str(),
                                         throwStmt->location.linenumber);
                                 return nullptr;
@@ -416 +507 @@
 
         Statement * ExceptionMutatorCore::postmutate( TryStmt *tryStmt ) {
+                assert( node_decl );
+                assert( hook_decl );
+
                 // Generate a prefix for the function names?
 
-                CompoundStmt * block = new CompoundStmt();
-                Statement * inner = take_try_block( tryStmt );
+                CompoundStmt * block = new CompoundStmt( noLabels );
+                CompoundStmt * inner = take_try_block( tryStmt );
 
                 if ( tryStmt->get_finally() ) {
@@ -427 +521 @@
                         appendDeclStmt( block, finally_block );
                         // Create and add the finally cleanup hook.
-                        appendDeclStmt( block, create_finally_hook( finally_block ) );
-                }
-
-                StatementList termination_handlers;
-                StatementList resumption_handlers;
-                split( tryStmt->get_handlers(),
-                       termination_handlers, resumption_handlers );
-
-                if ( resumeption_handlers.size() ) {
+                        appendDeclStmt( block,
+                                create_finally_hook( hook_decl, finally_block ) );
+                }
+
+                CatchList termination_handlers;
+                CatchList resumption_handlers;
+                split( tryStmt->get_catchers(),
+                           termination_handlers, resumption_handlers );
+
+                if ( resumption_handlers.size() ) {
                         // Define the helper function.
                         FunctionDecl * resume_handler =
@@ -441 +536 @@
                         appendDeclStmt( block, resume_handler );
                         // Prepare hooks
-                        inner = create_resume_wrapper( inner, resume_handler );
+                        inner = create_resume_wrapper( node_decl, inner, resume_handler );
                 }
 
@@ -462 +557 @@
                 block->push_back( inner );
 
-                free_all( termination_handlers );
-                free_all( resumption_handlers );
+                //free_all( termination_handlers );
+                //free_all( resumption_handlers );
 
                 return block;
@@ -469 +564 @@
 
         void ExceptionMutatorCore::premutate( CatchStmt *catchStmt ) {
-                GuardValue( curContext );
-                if ( CatchStmt::Termination == catchStmt->get_kind() ) {
-                        curContext = TerHandler;
+                GuardValue( cur_context );
+                if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
+                        cur_context = TerHandler;
                 } else {
-                        curContext = ResHandler;
-                }
-        }
-
-    void translateEHM( std::list< Declaration *> & translationUnit ) {
+                        cur_context = ResHandler;
+                }
+        }
+
+        void ExceptionMutatorCore::premutate( StructDecl *structDecl ) {
+                if ( !structDecl->has_body() ) {
+                        // Skip children?
+                        return;
+                } else if ( structDecl->get_name() == "__cfaehm__try_resume_node" ) {
+                        assert( nullptr == node_decl );
+                        node_decl = structDecl;
+                } else if ( structDecl->get_name() == "__cfaehm__cleanup_hook" ) {
+                        assert( nullptr == hook_decl );
+                        hook_decl = structDecl;
+                }
+                // Later we might get the exception type as well.
+        }
+
+        void translateEHM( std::list< Declaration *> & translationUnit ) {
+                init_func_types();
+
                 PassVisitor<ExceptionMutatorCore> translator;
                 for ( Declaration * decl : translationUnit ) {
-                        decl->mutate( translator );
+                        decl->acceptMutator( translator );
                 }
         }

src/ControlStruct/ExceptTranslate.h

@@ -10 +10 @@
 // Created On       : Tus Jun 06 10:13:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr Jun 22 15:57:00 2017
-// Update Count     : 0
+// Last Modified On : Fri Jun 30 10:20:00 2017
+// Update Count     : 2
 //
 
@@ -17 +17 @@
 #define EXCEPT_TRANSLATE_H
 
-namespace ControlFlow {
+#include <list>
+#include "SynTree/SynTree.h"
+
+namespace ControlStruct {
         void translateEHM( std::list< Declaration *> & translationUnit );
         /* Converts exception handling structures into their underlying C code.

src/ControlStruct/module.mk

@@ -10 +10 @@
 ## Author           : Richard C. Bilson
 ## Created On       : Mon Jun  1 17:49:17 2015
-## Last Modified By : Peter A. Buhr
-## Last Modified On : Thu Aug  4 11:38:06 2016
-## Update Count     : 3
+## Last Modified By : Andrew Beach
+## Last Modified On : Wed Jun 28 16:15:00 2017
+## Update Count     : 4
 ###############################################################################
 
 SRC +=  ControlStruct/LabelGenerator.cc \
         ControlStruct/LabelFixer.cc \
-        ControlStruct/MLEMutator.cc \
+        ControlStruct/MLEMutator.cc \
         ControlStruct/Mutate.cc \
-        ControlStruct/ForExprMutator.cc
-
+        ControlStruct/ForExprMutator.cc \
+        ControlStruct/ExceptTranslate.cc

src/GenPoly/Box.cc

@@ -504 +504 @@
                 DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
                         if ( functionDecl->get_statements() ) {         // empty routine body ?
+                                // std::cerr << "mutating function: " << functionDecl->get_mangleName() << std::endl;
                                 doBeginScope();
                                 scopeTyVars.beginScope();
@@ -548 +549 @@
                                 retval = oldRetval;
                                 doEndScope();
+                                // std::cerr << "end function: " << functionDecl->get_mangleName() << std::endl;
                         } // if
                         return functionDecl;
@@ -1116 +1118 @@
 
                 Expression *Pass1::mutate( ApplicationExpr *appExpr ) {
-                        // std::cerr << "mutate appExpr: ";
+                        // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl;
                         // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
                         //      std::cerr << i->first << " ";
@@ -1141 +1143 @@
                         ReferenceToType *dynRetType = isDynRet( function, exprTyVars );
 
+                        // std::cerr << function << std::endl;
+                        // std::cerr << "scopeTyVars: ";
+                        // printTyVarMap( std::cerr, scopeTyVars );
+                        // std::cerr << "exprTyVars: ";
+                        // printTyVarMap( std::cerr, exprTyVars );
+                        // std::cerr << "env: " << *env << std::endl;
+                        // std::cerr << needsAdapter( function, scopeTyVars ) << ! needsAdapter( function, exprTyVars) << std::endl;
+
                         // NOTE: addDynRetParam needs to know the actual (generated) return type so it can make a temp variable, so pass the result type from the appExpr
                         // passTypeVars needs to know the program-text return type (i.e. the distinction between _conc_T30 and T3(int))
                         // concRetType may not be a good name in one or both of these places. A more appropriate name change is welcome.
                         if ( dynRetType ) {
+                                // std::cerr << "dynRetType: " << dynRetType << std::endl;
                                 Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result();
                                 ret = addDynRetParam( appExpr, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType

src/GenPoly/InstantiateGeneric.cc

@@ -22 +22 @@
 #include "InstantiateGeneric.h"
 
-#include "DeclMutator.h"
 #include "GenPoly.h"
 #include "ScopedSet.h"
 #include "ScrubTyVars.h"
-#include "PolyMutator.h"
+
+#include "Common/PassVisitor.h"
+#include "Common/ScopedMap.h"
+#include "Common/UniqueName.h"
+#include "Common/utility.h"
 
 #include "ResolvExpr/typeops.h"
@@ -34 +37 @@
 #include "SynTree/Type.h"
 
-#include "Common/ScopedMap.h"
-#include "Common/UniqueName.h"
-#include "Common/utility.h"
+
+#include "InitTweak/InitTweak.h"
+
 
 namespace GenPoly {
@@ -153 +156 @@
         }
 
-        // collect the environments of each TypeInstType so that type variables can be replaced
-        // xxx - possibly temporary solution. Access to type environments is required in GenericInstantiator, but it needs to be a DeclMutator which does not provide easy access to the type environments.
-        class EnvFinder final : public GenPoly::PolyMutator {
-        public:
-                using GenPoly::PolyMutator::mutate;
-                virtual Type * mutate( TypeInstType * inst ) override {
-                        if ( env ) envMap[inst] = env;
-                        return inst;
-                }
-
-                // don't want to associate an environment with TypeInstTypes that occur in function types - this may actually only apply to function types belonging to DeclarationWithTypes (or even just FunctionDecl)?
-                virtual Type * mutate( FunctionType * ftype ) override {
-                        return ftype;
-                }
-                std::unordered_map< ReferenceToType *, TypeSubstitution * > envMap;
-        };
-
         /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
-        class GenericInstantiator final : public DeclMutator {
+        struct GenericInstantiator final : public WithTypeSubstitution, public WithDeclsToAdd, public WithVisitorRef<GenericInstantiator>, public WithGuards {
                 /// Map of (generic type, parameter list) pairs to concrete type instantiations
                 InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
@@ -178 +164 @@
                 /// Namer for concrete types
                 UniqueName typeNamer;
-                /// Reference to mapping of environments
-                const std::unordered_map< ReferenceToType *, TypeSubstitution * > & envMap;
-        public:
-                GenericInstantiator( const std::unordered_map< ReferenceToType *, TypeSubstitution * > & envMap ) : DeclMutator(), instantiations(), dtypeStatics(), typeNamer("_conc_"), envMap( envMap ) {}
-
-                using DeclMutator::mutate;
-                virtual Type* mutate( StructInstType *inst ) override;
-                virtual Type* mutate( UnionInstType *inst ) override;
-
-                virtual void doBeginScope() override;
-                virtual void doEndScope() override;
+                /// Should not make use of type environment to replace types of function parameter and return values.
+                bool inFunctionType = false;
+                GenericInstantiator() : instantiations(), dtypeStatics(), typeNamer("_conc_") {}
+
+                Type* postmutate( StructInstType *inst );
+                Type* postmutate( UnionInstType *inst );
+
+                void premutate( FunctionType * ftype ) {
+                        GuardValue( inFunctionType );
+                        inFunctionType = true;
+                }
+
+                void beginScope();
+                void endScope();
         private:
                 /// Wrap instantiation lookup for structs
@@ -207 +196 @@
 
         void instantiateGeneric( std::list< Declaration* > &translationUnit ) {
-                EnvFinder finder;
-                mutateAll( translationUnit, finder );
-                GenericInstantiator instantiator( finder.envMap );
-                instantiator.mutateDeclarationList( translationUnit );
+                PassVisitor<GenericInstantiator> instantiator;
+                mutateAll( translationUnit, instantiator );
         }
 
@@ -306 +293 @@
         Type *GenericInstantiator::replaceWithConcrete( Type *type, bool doClone ) {
                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
-                        if ( envMap.count( typeInst ) ) {
-                                TypeSubstitution * env = envMap.at( typeInst );
+                        if ( env && ! inFunctionType ) {
                                 Type *concrete = env->lookup( typeInst->get_name() );
                                 if ( concrete ) {
@@ -331 +317 @@
 
 
-        Type* GenericInstantiator::mutate( StructInstType *inst ) {
-                // mutate subtypes
-                Type *mutated = Mutator::mutate( inst );
-                inst = dynamic_cast< StructInstType* >( mutated );
-                if ( ! inst ) return mutated;
-
+        Type* GenericInstantiator::postmutate( StructInstType *inst ) {
                 // exit early if no need for further mutation
                 if ( inst->get_parameters().empty() ) return inst;
@@ -368 +349 @@
                                 substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
                                 insert( inst, typeSubs, concDecl ); // must insert before recursion
-                                concDecl->acceptMutator( *this ); // recursively instantiate members
-                                DeclMutator::addDeclaration( concDecl ); // must occur before declaration is added so that member instantiations appear first
+                                concDecl->acceptMutator( *visitor ); // recursively instantiate members
+                                declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first
                         }
                         StructInstType *newInst = new StructInstType( inst->get_qualifiers(), concDecl->get_name() );
@@ -388 +369 @@
         }
 
-        Type* GenericInstantiator::mutate( UnionInstType *inst ) {
-                // mutate subtypes
-                Type *mutated = Mutator::mutate( inst );
-                inst = dynamic_cast< UnionInstType* >( mutated );
-                if ( ! inst ) return mutated;
-
+        Type* GenericInstantiator::postmutate( UnionInstType *inst ) {
                 // exit early if no need for further mutation
                 if ( inst->get_parameters().empty() ) return inst;
@@ -423 +399 @@
                                 substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
                                 insert( inst, typeSubs, concDecl ); // must insert before recursion
-                                concDecl->acceptMutator( *this ); // recursively instantiate members
-                                DeclMutator::addDeclaration( concDecl ); // must occur before declaration is added so that member instantiations appear first
+                                concDecl->acceptMutator( *visitor ); // recursively instantiate members
+                                declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first
                         }
                         UnionInstType *newInst = new UnionInstType( inst->get_qualifiers(), concDecl->get_name() );
@@ -442 +418 @@
         }
 
-        void GenericInstantiator::doBeginScope() {
-                DeclMutator::doBeginScope();
+        void GenericInstantiator::beginScope() {
                 instantiations.beginScope();
                 dtypeStatics.beginScope();
         }
 
-        void GenericInstantiator::doEndScope() {
-                DeclMutator::doEndScope();
+        void GenericInstantiator::endScope() {
                 instantiations.endScope();
                 dtypeStatics.endScope();

src/InitTweak/FixInit.cc

@@ -104 +104 @@
                         typedef AddStmtVisitor Parent;
                         using Parent::visit;
-                        typedef std::set< ObjectDecl * > ObjectSet;
+                        // use ordered data structure to maintain ordering for set_difference and for consistent error messages
+                        typedef std::list< ObjectDecl * > ObjectSet;
                         virtual void visit( CompoundStmt *compoundStmt ) override;
                         virtual void visit( DeclStmt *stmt ) override;
@@ -116 +117 @@
 
                 // debug
-                struct printSet {
-                        typedef ObjDeclCollector::ObjectSet ObjectSet;
-                        printSet( const ObjectSet & objs ) : objs( objs ) {}
+                template<typename ObjectSet>
+                struct PrintSet {
+                        PrintSet( const ObjectSet & objs ) : objs( objs ) {}
                         const ObjectSet & objs;
                 };
-                std::ostream & operator<<( std::ostream & out, const printSet & set) {
+                template<typename ObjectSet>
+                PrintSet<ObjectSet> printSet( const ObjectSet & objs ) { return PrintSet<ObjectSet>( objs ); }
+                template<typename ObjectSet>
+                std::ostream & operator<<( std::ostream & out, const PrintSet<ObjectSet> & set) {
                         out << "{ ";
                         for ( ObjectDecl * obj : set.objs ) {
@@ -724 +728 @@
                                                 // static bool __objName_uninitialized = true
                                                 BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
-                                                SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant::from_int( 1 ) ), noDesignators );
+                                                SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant::from_int( 1 ) ) );
                                                 ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, boolType, boolInitExpr );
                                                 isUninitializedVar->fixUniqueId();
@@ -745 +749 @@
 
                                                 Statement * dtor = ctorInit->get_dtor();
-                                                objDecl->set_init( NULL );
-                                                ctorInit->set_ctor( NULL );
+                                                objDecl->set_init( nullptr );
+                                                ctorInit->set_ctor( nullptr );
                                                 ctorInit->set_dtor( nullptr );
                                                 if ( dtor ) {
@@ -799 +803 @@
                                                 } else {
                                                         stmtsToAddAfter.push_back( ctor );
-                                                        objDecl->set_init( NULL );
-                                                        ctorInit->set_ctor( NULL );
+                                                        objDecl->set_init( nullptr );
+                                                        ctorInit->set_ctor( nullptr );
                                                 }
                                         } // if
                                 } else if ( Initializer * init = ctorInit->get_init() ) {
                                         objDecl->set_init( init );
-                                        ctorInit->set_init( NULL );
+                                        ctorInit->set_init( nullptr );
                                 } else {
                                         // no constructor and no initializer, which is okay
-                                        objDecl->set_init( NULL );
+                                        objDecl->set_init( nullptr );
                                 } // if
                                 delete ctorInit;
@@ -816 +820 @@
 
                 void ObjDeclCollector::visit( CompoundStmt * compoundStmt ) {
-                        std::set< ObjectDecl * > prevVars = curVars;
+                        ObjectSet prevVars = curVars;
                         Parent::visit( compoundStmt );
                         curVars = prevVars;
@@ -824 +828 @@
                         // keep track of all variables currently in scope
                         if ( ObjectDecl * objDecl = dynamic_cast< ObjectDecl * > ( stmt->get_decl() ) ) {
-                                curVars.insert( objDecl );
+                                curVars.push_back( objDecl );
                         } // if
                         Parent::visit( stmt );
@@ -939 +943 @@
                         )
                         if ( ! diff.empty() ) {
+                                // create an auxilliary set for fast lookup -- can't make diff a set, because diff ordering should be consistent for error messages.
+                                std::unordered_set<ObjectDecl *> needsDestructor( diff.begin(), diff.end() );
+
                                 // go through decl ordered list of objectdecl. for each element that occurs in diff, output destructor
                                 OrderedDecls ordered;
                                 for ( OrderedDecls & rdo : reverseDeclOrder ) {
                                         // add elements from reverseDeclOrder into ordered if they occur in diff - it is key that this happens in reverse declaration order.
-                                        copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return diff.count( objDecl ); } );
+                                        copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return needsDestructor.count( objDecl ); } );
                                 } // for
                                 insertDtors( ordered.begin(), ordered.end(), back_inserter( stmtsToAdd ) );

src/InitTweak/GenInit.cc

@@ -44 +44 @@
         }
 
-        class ReturnFixer : public WithStmtsToAdd, public WithScopes {
-          public:
+        struct ReturnFixer : public WithStmtsToAdd, public WithGuards {
                 /// consistently allocates a temporary variable for the return value
                 /// of a function so that anything which the resolver decides can be constructed
@@ -59 +58 @@
         };
 
-        class CtorDtor final : public GenPoly::PolyMutator {
-          public:
-                typedef GenPoly::PolyMutator Parent;
-                using Parent::mutate;
+        struct CtorDtor : public WithGuards, public WithShortCircuiting  {
                 /// create constructor and destructor statements for object declarations.
                 /// the actual call statements will be added in after the resolver has run
@@ -69 +65 @@
                 static void generateCtorDtor( std::list< Declaration * > &translationUnit );
 
-                virtual DeclarationWithType * mutate( ObjectDecl * ) override;
-                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
+                void previsit( ObjectDecl * );
+                void previsit( FunctionDecl *functionDecl );
+
                 // should not traverse into any of these declarations to find objects
                 // that need to be constructed or destructed
-                virtual Declaration* mutate( StructDecl *aggregateDecl ) override;
-                virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; }
-                virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; }
-                virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; }
-                virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; }
-                virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; }
-
-                virtual Type * mutate( FunctionType *funcType ) override { return funcType; }
-
-                virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override;
+                void previsit( StructDecl *aggregateDecl );
+                void previsit( UnionDecl *aggregateDecl ) { visit_children = false; }
+                void previsit( EnumDecl *aggregateDecl ) { visit_children = false; }
+                void previsit( TraitDecl *aggregateDecl ) { visit_children = false; }
+                void previsit( TypeDecl *typeDecl ) { visit_children = false; }
+                void previsit( TypedefDecl *typeDecl ) { visit_children = false; }
+
+                void previsit( FunctionType *funcType ) { visit_children = false; }
+
+                void previsit( CompoundStmt * compoundStmt );
 
           private:
@@ -211 +208 @@
 
         void CtorDtor::generateCtorDtor( std::list< Declaration * > & translationUnit ) {
-                CtorDtor ctordtor;
-                mutateAll( translationUnit, ctordtor );
+                PassVisitor<CtorDtor> ctordtor;
+                acceptAll( translationUnit, ctordtor );
         }
 
@@ -289 +286 @@
         }
 
-        DeclarationWithType * CtorDtor::mutate( ObjectDecl * objDecl ) {
+        void CtorDtor::previsit( ObjectDecl * objDecl ) {
                 handleDWT( objDecl );
                 // hands off if @=, extern, builtin, etc.
@@ -301 +298 @@
                         objDecl->set_init( genCtorInit( objDecl ) );
                 }
-                return Parent::mutate( objDecl );
-        }
-
-        DeclarationWithType * CtorDtor::mutate( FunctionDecl *functionDecl ) {
-                ValueGuard< bool > oldInFunc = inFunction;
+        }
+
+        void CtorDtor::previsit( FunctionDecl *functionDecl ) {
+                GuardValue( inFunction );
                 inFunction = true;
 
                 handleDWT( functionDecl );
 
-                managedTypes.beginScope();
+                GuardScope( managedTypes );
                 // go through assertions and recursively add seen ctor/dtors
                 for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) {
@@ -317 +313 @@
                         }
                 }
-                // parameters should not be constructed and destructed, so don't mutate FunctionType
-                functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
-
-                managedTypes.endScope();
-                return functionDecl;
-        }
-
-        Declaration* CtorDtor::mutate( StructDecl *aggregateDecl ) {
+
+                PassVisitor<CtorDtor> newCtorDtor;
+                newCtorDtor.pass = *this;
+                maybeAccept( functionDecl->get_statements(), newCtorDtor );
+                visit_children = false;  // do not try and construct parameters or forall parameters - must happen after maybeAccept
+        }
+
+        void CtorDtor::previsit( StructDecl *aggregateDecl ) {
+                visit_children = false; // do not try to construct and destruct aggregate members
+
                 // don't construct members, but need to take note if there is a managed member,
                 // because that means that this type is also managed
@@ -336 +334 @@
                         }
                 }
-                return aggregateDecl;
-        }
-
-        CompoundStmt * CtorDtor::mutate( CompoundStmt * compoundStmt ) {
-                managedTypes.beginScope();
-                CompoundStmt * stmt = Parent::mutate( compoundStmt );
-                managedTypes.endScope();
-                return stmt;
-        }
-
+        }
+
+        void CtorDtor::previsit( CompoundStmt * compoundStmt ) {
+                GuardScope( managedTypes );
+        }
 } // namespace InitTweak
 

src/InitTweak/InitTweak.cc

@@ -14 +14 @@
                 public:
                         bool hasDesignations = false;
-                        template<typename Init>
-                        void handleInit( Init * init ) {
-                                if ( ! init->get_designators().empty() ) hasDesignations = true;
-                                else Visitor::visit( init );
-                        }
-                        virtual void visit( SingleInit * singleInit ) { handleInit( singleInit); }
-                        virtual void visit( ListInit * listInit ) { handleInit( listInit); }
+                        virtual void visit( Designation * des ) {
+                                if ( ! des->get_designators().empty() ) hasDesignations = true;
+                                else Visitor::visit( des );
+                        }
                 };
 

src/MakeLibCfa.cc

@@ -92 +92 @@
                 assert( ! objDecl->get_init() );
                 std::list< Expression* > noDesignators;
-                objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), noDesignators, false ) ); // cannot be constructed
+                objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), false ) ); // cannot be constructed
                 newDecls.push_back( objDecl );
         }

src/Makefile.in

@@ -119 +119 @@
         ControlStruct/driver_cfa_cpp-Mutate.$(OBJEXT) \
         ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT) \
+        ControlStruct/driver_cfa_cpp-ExceptTranslate.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-Box.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT) \
@@ -161 +162 @@
         ResolvExpr/driver_cfa_cpp-Occurs.$(OBJEXT) \
         ResolvExpr/driver_cfa_cpp-TypeEnvironment.$(OBJEXT) \
+        ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT) \
         SymTab/driver_cfa_cpp-Indexer.$(OBJEXT) \
         SymTab/driver_cfa_cpp-Mangler.$(OBJEXT) \
@@ -394 +396 @@
         ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \
         ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \
-        ControlStruct/ForExprMutator.cc GenPoly/Box.cc \
+        ControlStruct/ForExprMutator.cc \
+        ControlStruct/ExceptTranslate.cc GenPoly/Box.cc \
         GenPoly/GenPoly.cc GenPoly/PolyMutator.cc \
         GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \
@@ -414 +417 @@
         ResolvExpr/RenameVars.cc ResolvExpr/FindOpenVars.cc \
         ResolvExpr/PolyCost.cc ResolvExpr/Occurs.cc \
-        ResolvExpr/TypeEnvironment.cc SymTab/Indexer.cc \
-        SymTab/Mangler.cc SymTab/Validate.cc SymTab/FixFunction.cc \
-        SymTab/ImplementationType.cc SymTab/TypeEquality.cc \
-        SymTab/Autogen.cc SynTree/Type.cc SynTree/VoidType.cc \
-        SynTree/BasicType.cc SynTree/PointerType.cc \
-        SynTree/ArrayType.cc SynTree/FunctionType.cc \
-        SynTree/ReferenceToType.cc SynTree/TupleType.cc \
-        SynTree/TypeofType.cc SynTree/AttrType.cc \
+        ResolvExpr/TypeEnvironment.cc ResolvExpr/CurrentObject.cc \
+        SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \
+        SymTab/FixFunction.cc SymTab/ImplementationType.cc \
+        SymTab/TypeEquality.cc SymTab/Autogen.cc SynTree/Type.cc \
+        SynTree/VoidType.cc SynTree/BasicType.cc \
+        SynTree/PointerType.cc SynTree/ArrayType.cc \
+        SynTree/FunctionType.cc SynTree/ReferenceToType.cc \
+        SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \
         SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
         SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
@@ -592 +595 @@
         ControlStruct/$(DEPDIR)/$(am__dirstamp)
 ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT):  \
+        ControlStruct/$(am__dirstamp) \
+        ControlStruct/$(DEPDIR)/$(am__dirstamp)
+ControlStruct/driver_cfa_cpp-ExceptTranslate.$(OBJEXT):  \
         ControlStruct/$(am__dirstamp) \
         ControlStruct/$(DEPDIR)/$(am__dirstamp)
@@ -721 +727 @@
         ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
+ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT):  \
+        ResolvExpr/$(am__dirstamp) \
+        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
 SymTab/$(am__dirstamp):
         @$(MKDIR_P) SymTab
@@ -853 +862 @@
         -rm -f Common/driver_cfa_cpp-UniqueName.$(OBJEXT)
         -rm -f Concurrency/driver_cfa_cpp-Keywords.$(OBJEXT)
+        -rm -f ControlStruct/driver_cfa_cpp-ExceptTranslate.$(OBJEXT)
         -rm -f ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT)
         -rm -f ControlStruct/driver_cfa_cpp-LabelFixer.$(OBJEXT)
@@ -890 +900 @@
         -rm -f ResolvExpr/driver_cfa_cpp-CommonType.$(OBJEXT)
         -rm -f ResolvExpr/driver_cfa_cpp-ConversionCost.$(OBJEXT)
+        -rm -f ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT)
         -rm -f ResolvExpr/driver_cfa_cpp-FindOpenVars.$(OBJEXT)
         -rm -f ResolvExpr/driver_cfa_cpp-Occurs.$(OBJEXT)
@@ -965 +976 @@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-UniqueName.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Concurrency/$(DEPDIR)/driver_cfa_cpp-Keywords.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-ForExprMutator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelFixer.Po@am__quote@
@@ -1002 +1014 @@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CommonType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ConversionCost.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-FindOpenVars.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-Occurs.Po@am__quote@
@@ -1355 +1368 @@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ControlStruct/driver_cfa_cpp-ForExprMutator.obj `if test -f 'ControlStruct/ForExprMutator.cc'; then $(CYGPATH_W) 'ControlStruct/ForExprMutator.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/ForExprMutator.cc'; fi`
 
+ControlStruct/driver_cfa_cpp-ExceptTranslate.o: ControlStruct/ExceptTranslate.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ControlStruct/driver_cfa_cpp-ExceptTranslate.o -MD -MP -MF ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Tpo -c -o ControlStruct/driver_cfa_cpp-ExceptTranslate.o `test -f 'ControlStruct/ExceptTranslate.cc' || echo '$(srcdir)/'`ControlStruct/ExceptTranslate.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Tpo ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ControlStruct/ExceptTranslate.cc' object='ControlStruct/driver_cfa_cpp-ExceptTranslate.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ControlStruct/driver_cfa_cpp-ExceptTranslate.o `test -f 'ControlStruct/ExceptTranslate.cc' || echo '$(srcdir)/'`ControlStruct/ExceptTranslate.cc
+
+ControlStruct/driver_cfa_cpp-ExceptTranslate.obj: ControlStruct/ExceptTranslate.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ControlStruct/driver_cfa_cpp-ExceptTranslate.obj -MD -MP -MF ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Tpo -c -o ControlStruct/driver_cfa_cpp-ExceptTranslate.obj `if test -f 'ControlStruct/ExceptTranslate.cc'; then $(CYGPATH_W) 'ControlStruct/ExceptTranslate.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/ExceptTranslate.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Tpo ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ControlStruct/ExceptTranslate.cc' object='ControlStruct/driver_cfa_cpp-ExceptTranslate.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ControlStruct/driver_cfa_cpp-ExceptTranslate.obj `if test -f 'ControlStruct/ExceptTranslate.cc'; then $(CYGPATH_W) 'ControlStruct/ExceptTranslate.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/ExceptTranslate.cc'; fi`
+
 GenPoly/driver_cfa_cpp-Box.o: GenPoly/Box.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-Box.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-Box.Tpo -c -o GenPoly/driver_cfa_cpp-Box.o `test -f 'GenPoly/Box.cc' || echo '$(srcdir)/'`GenPoly/Box.cc
@@ -1942 +1969 @@
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-TypeEnvironment.obj `if test -f 'ResolvExpr/TypeEnvironment.cc'; then $(CYGPATH_W) 'ResolvExpr/TypeEnvironment.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/TypeEnvironment.cc'; fi`
+
+ResolvExpr/driver_cfa_cpp-CurrentObject.o: ResolvExpr/CurrentObject.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ResolvExpr/driver_cfa_cpp-CurrentObject.o -MD -MP -MF ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.o `test -f 'ResolvExpr/CurrentObject.cc' || echo '$(srcdir)/'`ResolvExpr/CurrentObject.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ResolvExpr/CurrentObject.cc' object='ResolvExpr/driver_cfa_cpp-CurrentObject.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.o `test -f 'ResolvExpr/CurrentObject.cc' || echo '$(srcdir)/'`ResolvExpr/CurrentObject.cc
+
+ResolvExpr/driver_cfa_cpp-CurrentObject.obj: ResolvExpr/CurrentObject.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ResolvExpr/driver_cfa_cpp-CurrentObject.obj -MD -MP -MF ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.obj `if test -f 'ResolvExpr/CurrentObject.cc'; then $(CYGPATH_W) 'ResolvExpr/CurrentObject.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/CurrentObject.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ResolvExpr/CurrentObject.cc' object='ResolvExpr/driver_cfa_cpp-CurrentObject.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.obj `if test -f 'ResolvExpr/CurrentObject.cc'; then $(CYGPATH_W) 'ResolvExpr/CurrentObject.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/CurrentObject.cc'; fi`
 
 SymTab/driver_cfa_cpp-Indexer.o: SymTab/Indexer.cc

src/Parser/InitializerNode.cc

@@ -74 +74 @@
 
         InitializerNode *moreInit;
-        if  ( get_next() != 0 && ((moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) != 0) )
+        if ( (moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) ) {
                 moreInit->printOneLine( os );
+        }
 }
 
 Initializer *InitializerNode::build() const {
         if ( aggregate ) {
+                // steal designators from children
+                std::list< Designation * > designlist;
+                InitializerNode * child = next_init();
+                for ( ; child != nullptr; child = dynamic_cast< InitializerNode * >( child->get_next() ) ) {
+                        std::list< Expression * > desList;
+                        buildList< Expression, ExpressionNode >( child->designator, desList );
+                        designlist.push_back( new Designation( desList ) );
+                } // for
                 std::list< Initializer * > initlist;
                 buildList< Initializer, InitializerNode >( next_init(), initlist );
-
-                std::list< Expression * > designlist;
-
-                if ( designator != 0 ) {
-                        buildList< Expression, ExpressionNode >( designator, designlist );
-                } // if
-
                 return new ListInit( initlist, designlist, maybeConstructed );
         } else {
-                std::list< Expression * > designators;
-
-                if ( designator != 0 )
-                        buildList< Expression, ExpressionNode >( designator, designators );
-
-                if ( get_expression() != 0)
-                        return new SingleInit( maybeBuild< Expression >( get_expression() ), designators, maybeConstructed );
+                if ( get_expression() != 0) {
+                        return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed );
+                }
         } // if
-
         return 0;
 }

src/Parser/TypeData.cc

@@ -760 +760 @@
                 if ( cur->has_enumeratorValue() ) {
                         ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
-                        member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), list< Expression * >() ) );
+                        member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) );
                 } // if
         } // for
@@ -777 +777 @@
 TupleType * buildTuple( const TypeData * td ) {
         assert( td->kind == TypeData::Tuple );
-        TupleType * ret = new TupleType( buildQualifiers( td ) );
-        buildTypeList( td->tuple, ret->get_types() );
+        std::list< Type * > types;
+        buildTypeList( td->tuple, types );
+        TupleType * ret = new TupleType( buildQualifiers( td ), types );
         buildForall( td->forall, ret->get_forall() );
         return ret;

src/Parser/parser.yy

@@ -9 +9 @@
 // Author           : Peter A. Buhr
 // Created On       : Sat Sep  1 20:22:55 2001
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun 28 22:11:22 2017
-// Update Count     : 2414
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jun 30 15:38:00 2017
+// Update Count     : 2415
 //
 
@@ -104 +104 @@
         std::string * str;
         bool flag;
+        CatchStmt::Kind catch_kind;
 }
 
@@ -192 +193 @@
 %type<sn> switch_clause_list_opt                switch_clause_list                      choose_clause_list_opt          choose_clause_list
 %type<sn> /* handler_list */                    handler_clause                          finally_clause
+%type<catch_kind> handler_key
 
 // declarations
@@ -958 +960 @@
 handler_clause:
         // TEMPORARY, TEST EXCEPTIONS
-        CATCH '(' push push INTEGERconstant pop ')' compound_statement pop
-                { $$ = new StatementNode( build_catch( CatchStmt::Terminate, nullptr, new ExpressionNode( build_constantInteger( *$5 ) ), $8 ) ); }
-        | handler_clause CATCH '(' push push INTEGERconstant pop ')' compound_statement pop
-                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( CatchStmt::Terminate, nullptr, new ExpressionNode( build_constantInteger( *$6 ) ), $9 ) ) ); }
-
-        | CATCH '(' push push exception_declaration pop ')' compound_statement pop
-                { $$ = new StatementNode( build_catch( CatchStmt::Terminate, $5, nullptr, $8 ) ); }
-        | handler_clause CATCH '(' push push exception_declaration pop ')' compound_statement pop
-                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( CatchStmt::Terminate, $6, nullptr, $9 ) ) ); }
-        | CATCHRESUME '(' push push exception_declaration pop ')' compound_statement pop
-                { $$ = new StatementNode( build_catch( CatchStmt::Resume, $5, nullptr, $8 ) ); }
-        | handler_clause CATCHRESUME '(' push push exception_declaration pop ')' compound_statement pop
-                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( CatchStmt::Resume, $6, nullptr, $9 ) ) ); }
+        handler_key '(' push push INTEGERconstant pop ')' compound_statement pop
+                { $$ = new StatementNode( build_catch( $1, nullptr, new ExpressionNode( build_constantInteger( *$5 ) ), $8 ) ); }
+        | handler_clause handler_key '(' push push INTEGERconstant pop ')' compound_statement pop
+                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, nullptr, new ExpressionNode( build_constantInteger( *$6 ) ), $9 ) ) ); }
+
+        | handler_key '(' push push exception_declaration pop ')' compound_statement pop
+                { $$ = new StatementNode( build_catch( $1, $5, nullptr, $8 ) ); }
+        | handler_clause handler_key '(' push push exception_declaration pop ')' compound_statement pop
+                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $6, nullptr, $9 ) ) ); }
+        ;
+
+handler_key:
+        CATCH
+                { $$ = CatchStmt::Terminate; }
+        | CATCHRESUME
+                { $$ = CatchStmt::Resume; }
         ;
 

src/ResolvExpr/AlternativeFinder.cc

@@ -604 +604 @@
 //          )
                 SymTab::Indexer decls( indexer );
-                PRINT(
-                        std::cerr << "============= original indexer" << std::endl;
-                        indexer.print( std::cerr );
-                        std::cerr << "============= new indexer" << std::endl;
-                        decls.print( std::cerr );
-                )
+                // PRINT(
+                //      std::cerr << "============= original indexer" << std::endl;
+                //      indexer.print( std::cerr );
+                //      std::cerr << "============= new indexer" << std::endl;
+                //      decls.print( std::cerr );
+                // )
                 addToIndexer( have, decls );
                 AssertionSet newNeed;
@@ -809 +809 @@
         }
 
+        Expression * restructureCast( Expression * argExpr, Type * toType ) {
+                if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() ) {
+                        // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
+                        // to its corresponding target type, producing the tuple of those cast expressions. If there are
+                        // more components of the tuple than components in the target type, then excess components do not
+                        // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
+                        if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
+                                // expressions which may contain side effects require a single unique instance of the expression.
+                                argExpr = new UniqueExpr( argExpr );
+                        }
+                        std::list< Expression * > componentExprs;
+                        for ( unsigned int i = 0; i < toType->size(); i++ ) {
+                                // cast each component
+                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
+                                componentExprs.push_back( restructureCast( idx, toType->getComponent( i ) ) );
+                        }
+                        delete argExpr;
+                        assert( componentExprs.size() > 0 );
+                        // produce the tuple of casts
+                        return new TupleExpr( componentExprs );
+                } else {
+                        // handle normally
+                        return new CastExpr( argExpr, toType->clone() );
+                }
+        }
+
         void AlternativeFinder::visit( CastExpr *castExpr ) {
                 Type *& toType = castExpr->get_result();
@@ -840 +866 @@
                                 thisCost += Cost( 0, 0, discardedValues );
 
-                                Expression * argExpr = i->expr->clone();
-                                if ( argExpr->get_result()->size() > 1 && ! castExpr->get_result()->isVoid() ) {
-                                        // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
-                                        // to its corresponding target type, producing the tuple of those cast expressions. If there are
-                                        // more components of the tuple than components in the target type, then excess components do not
-                                        // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
-                                        if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
-                                                // expressions which may contain side effects require a single unique instance of the expression.
-                                                argExpr = new UniqueExpr( argExpr );
-                                        }
-                                        std::list< Expression * > componentExprs;
-                                        for ( unsigned int i = 0; i < castExpr->get_result()->size(); i++ ) {
-                                                // cast each component
-                                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
-                                                componentExprs.push_back( new CastExpr( idx, castExpr->get_result()->getComponent( i )->clone() ) );
-                                        }
-                                        delete argExpr;
-                                        assert( componentExprs.size() > 0 );
-                                        // produce the tuple of casts
-                                        candidates.push_back( Alternative( new TupleExpr( componentExprs ), i->env, i->cost, thisCost ) );
-                                } else {
-                                        // handle normally
-                                        candidates.push_back( Alternative( new CastExpr( argExpr->clone(), toType->clone() ), i->env, i->cost, thisCost ) );
-                                }
+                                candidates.push_back( Alternative( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ) );
                         } // if
                 } // for
@@ -1182 +1185 @@
         }
 
+        void AlternativeFinder::visit( UntypedInitExpr *initExpr ) {
+                // handle each option like a cast
+                AltList candidates;
+                PRINT( std::cerr << "untyped init expr: " << initExpr << std::endl; )
+                // O(N^2) checks of d-types with e-types
+                for ( InitAlternative & initAlt : initExpr->get_initAlts() ) {
+                        Type * toType = resolveTypeof( initAlt.type, indexer );
+                        SymTab::validateType( toType, &indexer );
+                        adjustExprType( toType, env, indexer );
+                        // Ideally the call to findWithAdjustment could be moved out of the loop, but unfortunately it currently has to occur inside or else
+                        // polymorphic return types are not properly bound to the initialization type, since return type variables are only open for the duration of resolving
+                        // the UntypedExpr. This is only actually an issue in initialization contexts that allow more than one possible initialization type, but it is still suboptimal.
+                        AlternativeFinder finder( indexer, env );
+                        finder.targetType = toType;
+                        finder.findWithAdjustment( initExpr->get_expr() );
+                        for ( Alternative & alt : finder.get_alternatives() ) {
+                                TypeEnvironment newEnv( alt.env );
+                                AssertionSet needAssertions, haveAssertions;
+                                OpenVarSet openVars;  // find things in env that don't have a "representative type" and claim those are open vars?
+                                PRINT( std::cerr << "  @ " << toType << " " << initAlt.designation << std::endl; )
+                                // It's possible that a cast can throw away some values in a multiply-valued expression.  (An example is a
+                                // cast-to-void, which casts from one value to zero.)  Figure out the prefix of the subexpression results
+                                // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
+                                // to.
+                                int discardedValues = alt.expr->get_result()->size() - toType->size();
+                                if ( discardedValues < 0 ) continue;
+                                // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not
+                                // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
+                                // unification run for side-effects
+                                unify( toType, alt.expr->get_result(), newEnv, needAssertions, haveAssertions, openVars, indexer ); // xxx - do some inspecting on this line... why isn't result bound to initAlt.type??
+
+                                Cost thisCost = castCost( alt.expr->get_result(), toType, indexer, newEnv );
+                                if ( thisCost != Cost::infinity ) {
+                                        // count one safe conversion for each value that is thrown away
+                                        thisCost += Cost( 0, 0, discardedValues );
+                                        candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) );
+                                }
+                        }
+                }
+
+                // findMinCost selects the alternatives with the lowest "cost" members, but has the side effect of copying the
+                // cvtCost member to the cost member (since the old cost is now irrelevant).  Thus, calling findMinCost twice
+                // selects first based on argument cost, then on conversion cost.
+                AltList minArgCost;
+                findMinCost( candidates.begin(), candidates.end(), std::back_inserter( minArgCost ) );
+                findMinCost( minArgCost.begin(), minArgCost.end(), std::back_inserter( alternatives ) );
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/AlternativeFinder.h

@@ -73 +73 @@
                 virtual void visit( UniqueExpr *unqExpr );
                 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.

src/ResolvExpr/Resolver.cc

@@ -14 +14 @@
 //
 
+#include <iostream>
+
+#include "Alternative.h"
+#include "AlternativeFinder.h"
+#include "CurrentObject.h"
+#include "RenameVars.h"
 #include "Resolver.h"
-#include "AlternativeFinder.h"
-#include "Alternative.h"
-#include "RenameVars.h"
 #include "ResolveTypeof.h"
 #include "typeops.h"
+
+#include "SynTree/Expression.h"
+#include "SynTree/Initializer.h"
 #include "SynTree/Statement.h"
 #include "SynTree/Type.h"
-#include "SynTree/Expression.h"
-#include "SynTree/Initializer.h"
+
+#include "SymTab/Autogen.h"
 #include "SymTab/Indexer.h"
-#include "SymTab/Autogen.h"
+
 #include "Common/utility.h"
+
 #include "InitTweak/InitTweak.h"
 
-#include <iostream>
 using namespace std;
 
@@ -39 +45 @@
                         if ( const Resolver * res = dynamic_cast< const Resolver * >( &other ) ) {
                                 functionReturn = res->functionReturn;
-                                initContext = res->initContext;
+                                currentObject = res->currentObject;
                                 inEnumDecl = res->inEnumDecl;
                         }
@@ -64 +70 @@
                 virtual void visit( BranchStmt *branchStmt ) override;
                 virtual void visit( ReturnStmt *returnStmt ) override;
+                virtual void visit( ThrowStmt *throwStmt ) override;
 
                 virtual void visit( SingleInit *singleInit ) override;
@@ -79 +86 @@
 
                 Type * functionReturn = nullptr;
-                Type *initContext = nullptr;
+                CurrentObject currentObject = nullptr;
                 bool inEnumDecl = false;
         };
@@ -186 +193 @@
                 // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting
                 // the RHS.
-                Type *temp = initContext;
-                initContext = new_type;
-                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
+                ValueGuard<CurrentObject> temp( currentObject );
+                currentObject = CurrentObject( objectDecl->get_type() );
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
                         // enumerator initializers should not use the enum type to initialize, since
                         // the enum type is still incomplete at this point. Use signed int instead.
-                        initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
+                        currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
                 }
                 Parent::visit( objectDecl );
-                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
                         // delete newly created signed int type
-                        delete initContext;
-                }
-                initContext = temp;
+                        // delete currentObject.getType();
+                }
         }
 
@@ -315 +321 @@
 
         void Resolver::visit( SwitchStmt *switchStmt ) {
-                ValueGuard< Type * > oldInitContext( initContext );
+                ValueGuard< CurrentObject > oldCurrentObject( currentObject );
                 Expression *newExpr;
                 newExpr = findIntegralExpression( switchStmt->get_condition(), *this );
@@ -321 +327 @@
                 switchStmt->set_condition( newExpr );
 
-                initContext = newExpr->get_result();
+                currentObject = CurrentObject( newExpr->get_result() );
                 Parent::visit( switchStmt );
         }
@@ -327 +333 @@
         void Resolver::visit( CaseStmt *caseStmt ) {
                 if ( caseStmt->get_condition() ) {
-                        assert( initContext );
-                        CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initContext->clone() );
+                        std::list< InitAlternative > initAlts = currentObject.getOptions();
+                        assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
+                        CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() );
                         Expression * newExpr = findSingleExpression( castExpr, *this );
                         castExpr = safe_dynamic_cast< CastExpr * >( newExpr );
@@ -360 +367 @@
         }
 
+        void Resolver::visit( ThrowStmt *throwStmt ) {
+                if ( throwStmt->get_expr() ) {
+                        Expression * wrapped = new CastExpr( throwStmt->get_expr(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+                        Expression * newExpr = findSingleExpression( wrapped, *this );
+                        throwStmt->set_expr( newExpr );
+                }
+        }
+
         template< typename T >
         bool isCharType( T t ) {
@@ -370 +385 @@
 
         void Resolver::visit( SingleInit *singleInit ) {
-                if ( singleInit->get_value() ) {
-                        // // find all the d's
-                        // std::list<Expression *> &designators = singleInit->get_designators();
-                        // std::list<Type *> types1{ initContext }, types2;
-                        // for ( Expression * expr: designators ) {
-                        //      cerr << expr << endl;
-                        //      if ( NameExpr * nexpr = dynamic_cast<NameExpr *>( expr ) ) {
-                        //              for ( Type * type: types1 ) {
-                        //                      cerr << type << endl;
-                        //                      ReferenceToType * fred = dynamic_cast<ReferenceToType *>(type);
-                        //                      std::list<Declaration *> members;
-                        //                      if ( fred ) {
-                        //                              fred->lookup( nexpr->get_name(), members ); // concatenate identical field name
-                        //                              for ( Declaration * mem: members ) {
-                        //                                      if ( DeclarationWithType * dwt = dynamic_cast<DeclarationWithType *>(mem) ) {
-                        //                                              types2.push_back( dwt->get_type() );
-                        //                                      } // if
-                        //                              } // for
-                        //                      } // if
-                        //              } // for
-                        //              types1 = types2;
-                        //              types2.clear();
-                        //      } // if
-                        // } // for
-                        // // for ( Type * type: types1 ) {
-                        // //   cerr << type << endl;
-                        // // } // for
-
-                        // // O(N^2) checks of d-types with f-types
-                        // // find the minimum cost
-                        CastExpr *castExpr = new CastExpr( singleInit->get_value(), initContext->clone() );
-                        Expression *newExpr = findSingleExpression( castExpr, *this );
-                        delete castExpr;
-                        singleInit->set_value( newExpr );
-
-                        // check if initializing type is char[]
-                        if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
-                                if ( isCharType( at->get_base() ) ) {
-                                        // check if the resolved type is char *
-                                        if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
-                                                if ( isCharType( pt->get_base() ) ) {
-                                                        // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
-                                                        CastExpr *ce = dynamic_cast< CastExpr * >( newExpr );
-                                                        singleInit->set_value( ce->get_arg() );
-                                                        ce->set_arg( NULL );
-                                                        delete ce;
-                                                }
+                // resolve initialization using the possibilities as determined by the currentObject cursor
+                UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
+                Expression * newExpr = findSingleExpression( untyped, *this );
+                InitExpr * initExpr = safe_dynamic_cast< InitExpr * >( newExpr );
+
+                // move cursor to the object that is actually initialized
+                currentObject.setNext( initExpr->get_designation() );
+
+                // discard InitExpr wrapper and retain relevant pieces
+                newExpr = initExpr->get_expr();
+                newExpr->set_env( initExpr->get_env() );
+                initExpr->set_expr( nullptr );
+                initExpr->set_env( nullptr );
+                delete initExpr;
+
+                // get the actual object's type (may not exactly match what comes back from the resolver due to conversions)
+                Type * initContext = currentObject.getCurrentType();
+
+                // check if actual object's type is char[]
+                if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
+                        if ( isCharType( at->get_base() ) ) {
+                                // check if the resolved type is char *
+                                if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
+                                        if ( isCharType( pt->get_base() ) ) {
+                                                // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
+                                                CastExpr *ce = safe_dynamic_cast< CastExpr * >( newExpr );
+                                                newExpr = ce->get_arg();
+                                                ce->set_arg( nullptr );
+                                                delete ce;
                                         }
                                 }
                         }
-                } // if
-        }
-
-        template< typename AggrInst >
-        TypeSubstitution makeGenericSubstitutuion( AggrInst * inst ) {
-                assert( inst );
-                assert( inst->get_baseParameters() );
-                std::list< TypeDecl * > baseParams = *inst->get_baseParameters();
-                std::list< Expression * > typeSubs = inst->get_parameters();
-                TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
-                return subs;
-        }
-
-        ReferenceToType * isStructOrUnion( Type * type ) {
-                if ( StructInstType * sit = dynamic_cast< StructInstType * >( type ) ) {
-                        return sit;
-                } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( type ) ) {
-                        return uit;
-                }
-                return nullptr;
-        }
-
-        void Resolver::resolveSingleAggrInit( Declaration * dcl, InitIterator & init, InitIterator & initEnd, TypeSubstitution sub ) {
-                DeclarationWithType * dt = dynamic_cast< DeclarationWithType * >( dcl );
-                assert( dt );
-                // need to substitute for generic types, so that casts are to concrete types
-                initContext = dt->get_type()->clone();
-                sub.apply( initContext );
-
-                try {
-                        if ( init == initEnd ) return; // stop when there are no more initializers
-                        (*init)->accept( *this );
-                        ++init; // made it past an initializer
-                } catch( SemanticError & ) {
-                        // need to delve deeper, if you can
-                        if ( ReferenceToType * type = isStructOrUnion( initContext ) ) {
-                                resolveAggrInit( type, init, initEnd );
-                        } else {
-                                // member is not an aggregate type, so can't go any deeper
-
-                                // might need to rethink what is being thrown
-                                throw;
-                        } // if
-                }
-        }
-
-        void Resolver::resolveAggrInit( ReferenceToType * inst, InitIterator & init, InitIterator & initEnd ) {
-                if ( StructInstType * sit = dynamic_cast< StructInstType * >( inst ) ) {
-                        TypeSubstitution sub = makeGenericSubstitutuion( sit );
-                        StructDecl * st = sit->get_baseStruct();
-                        if(st->get_members().empty()) return;
-                        // want to resolve each initializer to the members of the struct,
-                        // but if there are more initializers than members we should stop
-                        list< Declaration * >::iterator it = st->get_members().begin();
-                        for ( ; it != st->get_members().end(); ++it) {
-                                resolveSingleAggrInit( *it, init, initEnd, sub );
-                        }
-                } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( inst ) ) {
-                        TypeSubstitution sub = makeGenericSubstitutuion( uit );
-                        UnionDecl * un = uit->get_baseUnion();
-                        if(un->get_members().empty()) return;
-                        // only resolve to the first member of a union
-                        resolveSingleAggrInit( *un->get_members().begin(), init, initEnd, sub );
-                } // if
+                }
+
+                // set initializer expr to resolved express
+                singleInit->set_value( newExpr );
+
+                // move cursor to next object in preparation for next initializer
+                currentObject.increment();
         }
 
         void Resolver::visit( ListInit * listInit ) {
-                InitIterator iter = listInit->begin();
-                InitIterator end = listInit->end();
-
-                if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
-                        // resolve each member to the base type of the array
-                        for ( ; iter != end; ++iter ) {
-                                initContext = at->get_base();
-                                (*iter)->accept( *this );
-                        } // for
-                } else if ( TupleType * tt = dynamic_cast< TupleType * > ( initContext ) ) {
-                        for ( Type * t : *tt ) {
-                                if ( iter == end ) break;
-                                initContext = t;
-                                (*iter++)->accept( *this );
-                        }
-                } else if ( ReferenceToType * type = isStructOrUnion( initContext ) ) {
-                        resolveAggrInit( type, iter, end );
-                } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
-                        Type * base = tt->get_baseType()->get_base();
-                        if ( base ) {
-                                // know the implementation type, so try using that as the initContext
-                                initContext = base;
-                                visit( listInit );
-                        } else {
-                                // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
-                                Parent::visit( listInit );
-                        }
-                } else {
-                        assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext )
-                                || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) || dynamic_cast < EnumInstType * > ( initContext ) );
-                        // basic types are handled here
-                        Parent::visit( listInit );
-                }
-
-#if 0
-                if ( ArrayType *at = dynamic_cast<ArrayType*>(initContext) ) {
-                        std::list<Initializer *>::iterator iter( listInit->begin_initializers() );
-                        for ( ; iter != listInit->end_initializers(); ++iter ) {
-                                initContext = at->get_base();
-                                (*iter)->accept( *this );
-                        } // for
-                } else if ( StructInstType *st = dynamic_cast<StructInstType*>(initContext) ) {
-                        StructDecl *baseStruct = st->get_baseStruct();
-                        std::list<Declaration *>::iterator iter1( baseStruct->get_members().begin() );
-                        std::list<Initializer *>::iterator iter2( listInit->begin_initializers() );
-                        for ( ; iter1 != baseStruct->get_members().end() && iter2 != listInit->end_initializers(); ++iter2 ) {
-                                if ( (*iter2)->get_designators().empty() ) {
-                                        DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *iter1 );
-                                        initContext = dt->get_type();
-                                        (*iter2)->accept( *this );
-                                        ++iter1;
-                                } else {
-                                        StructDecl *st = baseStruct;
-                                        iter1 = st->get_members().begin();
-                                        std::list<Expression *>::iterator iter3( (*iter2)->get_designators().begin() );
-                                        for ( ; iter3 != (*iter2)->get_designators().end(); ++iter3 ) {
-                                                NameExpr *key = dynamic_cast<NameExpr *>( *iter3 );
-                                                assert( key );
-                                                for ( ; iter1 != st->get_members().end(); ++iter1 ) {
-                                                        if ( key->get_name() == (*iter1)->get_name() ) {
-                                                                (*iter1)->print( cout );
-                                                                cout << key->get_name() << endl;
-                                                                ObjectDecl *fred = dynamic_cast<ObjectDecl *>( *iter1 );
-                                                                assert( fred );
-                                                                StructInstType *mary = dynamic_cast<StructInstType*>( fred->get_type() );
-                                                                assert( mary );
-                                                                st = mary->get_baseStruct();
-                                                                iter1 = st->get_members().begin();
-                                                                break;
-                                                        } // if
-                                                }  // for
-                                        } // for
-                                        ObjectDecl *fred = dynamic_cast<ObjectDecl *>( *iter1 );
-                                        assert( fred );
-                                        initContext = fred->get_type();
-                                        (*listInit->begin_initializers())->accept( *this );
-                                } // if
-                        } // for
-                } else if ( UnionInstType *st = dynamic_cast<UnionInstType*>(initContext) ) {
-                        DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *st->get_baseUnion()->get_members().begin() );
-                        initContext = dt->get_type();
-                        (*listInit->begin_initializers())->accept( *this );
-                } // if
-#endif
+                // move cursor into brace-enclosed initializer-list
+                currentObject.enterListInit();
+                // xxx - fix this so that the list isn't copied, iterator should be used to change current element
+                std::list<Designation *> newDesignations;
+                for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) {
+                        // iterate designations and initializers in pairs, moving the cursor to the current designated object and resolving
+                        // the initializer against that object.
+                        Designation * des = std::get<0>(p);
+                        Initializer * init = std::get<1>(p);
+                        newDesignations.push_back( currentObject.findNext( des ) );
+                        init->accept( *this );
+                }
+                // set the set of 'resolved' designations and leave the brace-enclosed initializer-list
+                listInit->get_designations() = newDesignations; // xxx - memory management
+                currentObject.exitListInit();
+
+                // xxx - this part has not be folded into CurrentObject yet
+                // } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
+                //      Type * base = tt->get_baseType()->get_base();
+                //      if ( base ) {
+                //              // know the implementation type, so try using that as the initContext
+                //              ObjectDecl tmpObj( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, base->clone(), nullptr );
+                //              currentObject = &tmpObj;
+                //              visit( listInit );
+                //      } else {
+                //              // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
+                //              Parent::visit( listInit );
+                //      }
+                // } else {
         }
 

src/ResolvExpr/Unify.cc

@@ -606 +606 @@
                         } else if ( tupleParam ) {
                                 // bundle other parameters into tuple to match
-                                TupleType* binder = new TupleType{ paramTy->get_qualifiers() };
+                                std::list< Type * > binderTypes;
 
                                 do {
-                                        binder->get_types().push_back( otherParam->get_type()->clone() );
+                                        binderTypes.push_back( otherParam->get_type()->clone() );
                                         ++jt;
 
@@ -618 +618 @@
                                 } while (true);
 
-                                otherParamTy = binder;
+                                otherParamTy = new TupleType{ paramTy->get_qualifiers(), binderTypes };
                                 ++it;  // skip ttype parameter for break
                         } else if ( otherTupleParam ) {
                                 // bundle parameters into tuple to match other
-                                TupleType* binder = new TupleType{ otherParamTy->get_qualifiers() };
+                                std::list< Type * > binderTypes;
 
                                 do {
-                                        binder->get_types().push_back( param->get_type()->clone() );
+                                        binderTypes.push_back( param->get_type()->clone() );
                                         ++it;
 
@@ -634 +634 @@
                                 } while (true);
 
-                                paramTy = binder;
+                                paramTy = new TupleType{ otherParamTy->get_qualifiers(), binderTypes };
                                 ++jt;  // skip ttype parameter for break
                         }
@@ -756 +756 @@
                         return function->get_returnVals().front()->get_type()->clone();
                 } else {
-                        TupleType * tupleType = new TupleType( Type::Qualifiers() );
+                        std::list< Type * > types;
                         for ( DeclarationWithType * decl : function->get_returnVals() ) {
-                                tupleType->get_types().push_back( decl->get_type()->clone() );
+                                types.push_back( decl->get_type()->clone() );
                         } // for
-                        return tupleType;
+                        return new TupleType( Type::Qualifiers(), types );
                 }
         }

src/ResolvExpr/module.mk

@@ -6 +6 @@
 ## file "LICENCE" distributed with Cforall.
 ##
-## module.mk -- 
+## module.mk --
 ##
 ## Author           : Richard C. Bilson
@@ -31 +31 @@
        ResolvExpr/PolyCost.cc \
        ResolvExpr/Occurs.cc \
-       ResolvExpr/TypeEnvironment.cc
+       ResolvExpr/TypeEnvironment.cc \
+       ResolvExpr/CurrentObject.cc

src/SymTab/Autogen.h

@@ -25 +25 @@
 
 namespace SymTab {
-    /// Generates assignment operators, constructors, and destructor for aggregate types as required
-    void autogenerateRoutines( std::list< Declaration * > &translationUnit );
+        /// Generates assignment operators, constructors, and destructor for aggregate types as required
+        void autogenerateRoutines( std::list< Declaration * > &translationUnit );
 
-    /// returns true if obj's name is the empty string and it has a bitfield width
-    bool isUnnamedBitfield( ObjectDecl * obj );
+        /// returns true if obj's name is the empty string and it has a bitfield width
+        bool isUnnamedBitfield( ObjectDecl * obj );
 
-    /// size_t type - set when size_t typedef is seen. Useful in a few places,
-    /// such as in determining array dimension type
-    extern Type * SizeType;
+        /// size_t type - set when size_t typedef is seen. Useful in a few places,
+        /// such as in determining array dimension type
+        extern Type * SizeType;
 
-    /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
-    template< typename OutputIterator >
+        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
+        template< typename OutputIterator >
         Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false, bool forward = true );
 
-    /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
-    /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
-    template< typename OutputIterator >
+        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
+        /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
+        template< typename OutputIterator >
         Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) {
         // want to be able to generate assignment, ctor, and dtor generically,
@@ -50 +50 @@
         dstParam = new AddressExpr( dstParam );
         if ( addCast ) {
-            // cast to T* with qualifiers removed, so that qualified objects can be constructed
-            // and destructed with the same functions as non-qualified objects.
-            // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
-            // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
-            // remove lvalue as a qualifier, this can change to
-            //   type->get_qualifiers() = Type::Qualifiers();
-            assert( type );
-            Type * castType = type->clone();
-//                      castType->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, false);
-            castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
-            castType->set_lvalue( true ); // xxx - might not need this
-            dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
+                // cast to T* with qualifiers removed, so that qualified objects can be constructed
+                // and destructed with the same functions as non-qualified objects.
+                // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
+                // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
+                // remove lvalue as a qualifier, this can change to
+                //   type->get_qualifiers() = Type::Qualifiers();
+                assert( type );
+                Type * castType = type->clone();
+                castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                castType->set_lvalue( true ); // xxx - might not need this
+                dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
         }
         fExpr->get_args().push_back( dstParam );
@@ -75 +74 @@
 
         return listInit;
-    }
-
-    /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments.
-    /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
-    template< typename OutputIterator >
-        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) {
-        static UniqueName indexName( "_index" );
-
-        // for a flexible array member nothing is done -- user must define own assignment
-        if ( ! array->get_dimension() ) return ;
-
-        Expression * begin, * end, * update, * cmp;
-        if ( forward ) {
-            // generate: for ( int i = 0; i < N; ++i )
-            begin = new ConstantExpr( Constant::from_int( 0 ) );
-            end = array->get_dimension()->clone();
-            cmp = new NameExpr( "?<?" );
-            update = new NameExpr( "++?" );
-        } else {
-            // generate: for ( int i = N-1; i >= 0; --i )
-            begin = new UntypedExpr( new NameExpr( "?-?" ) );
-            ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() );
-            ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
-            end = new ConstantExpr( Constant::from_int( 0 ) );
-            cmp = new NameExpr( "?>=?" );
-            update = new NameExpr( "--?" );
         }
 
-        ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
+        /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments.
+        /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
+        template< typename OutputIterator >
+        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) {
+                static UniqueName indexName( "_index" );
 
-        UntypedExpr *cond = new UntypedExpr( cmp );
-        cond->get_args().push_back( new VariableExpr( index ) );
-        cond->get_args().push_back( end );
+                // for a flexible array member nothing is done -- user must define own assignment
+                if ( ! array->get_dimension() ) return ;
 
-        UntypedExpr *inc = new UntypedExpr( update );
-        inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
+                Expression * begin, * end, * update, * cmp;
+                if ( forward ) {
+                        // generate: for ( int i = 0; i < N; ++i )
+                        begin = new ConstantExpr( Constant::from_int( 0 ) );
+                        end = array->get_dimension()->clone();
+                        cmp = new NameExpr( "?<?" );
+                        update = new NameExpr( "++?" );
+                } else {
+                        // generate: for ( int i = N-1; i >= 0; --i )
+                        begin = new UntypedExpr( new NameExpr( "?-?" ) );
+                        ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() );
+                        ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
+                        end = new ConstantExpr( Constant::from_int( 0 ) );
+                        cmp = new NameExpr( "?>=?" );
+                        update = new NameExpr( "--?" );
+                }
 
-        UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
-        dstIndex->get_args().push_back( dstParam );
-        dstIndex->get_args().push_back( new VariableExpr( index ) );
-        dstParam = dstIndex;
+                ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin ) );
 
-        // srcParam must keep track of the array indices to build the
-        // source parameter and/or array list initializer
-        srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() );
+                UntypedExpr *cond = new UntypedExpr( cmp );
+                cond->get_args().push_back( new VariableExpr( index ) );
+                cond->get_args().push_back( end );
 
-        // for stmt's body, eventually containing call
-        CompoundStmt * body = new CompoundStmt( noLabels );
-        Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward );
+                UntypedExpr *inc = new UntypedExpr( update );
+                inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
 
-        // block containing for stmt and index variable
-        std::list<Statement *> initList;
-        CompoundStmt * block = new CompoundStmt( noLabels );
-        block->get_kids().push_back( new DeclStmt( noLabels, index ) );
-        if ( listInit ) block->get_kids().push_back( listInit );
-        block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
+                UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
+                dstIndex->get_args().push_back( dstParam );
+                dstIndex->get_args().push_back( new VariableExpr( index ) );
+                dstParam = dstIndex;
 
-        *out++ = block;
-    }
+                // srcParam must keep track of the array indices to build the
+                // source parameter and/or array list initializer
+                srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() );
 
-    template< typename OutputIterator >
+                // for stmt's body, eventually containing call
+                CompoundStmt * body = new CompoundStmt( noLabels );
+                Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward );
+
+                // block containing for stmt and index variable
+                std::list<Statement *> initList;
+                CompoundStmt * block = new CompoundStmt( noLabels );
+                block->get_kids().push_back( new DeclStmt( noLabels, index ) );
+                if ( listInit ) block->get_kids().push_back( listInit );
+                block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
+
+                *out++ = block;
+        }
+
+        template< typename OutputIterator >
         Statement * genCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
-        if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
-            genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
-            return 0;
-        } else {
-            return genScalarCall( srcParam, dstParam, fname, out, type, addCast );
+                if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
+                        genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
+                        return 0;
+                } else {
+                        return genScalarCall( srcParam, dstParam, fname, out, type, addCast );
+                }
         }
-    }
 
-    /// inserts into out a generated call expression to function fname with arguments dstParam
-    /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the
-    /// object being constructed. The function wraps constructor and destructor calls in an
-    /// ImplicitCtorDtorStmt node.
-    template< typename OutputIterator >
+        /// inserts into out a generated call expression to function fname with arguments dstParam
+        /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the
+        /// object being constructed. The function wraps constructor and destructor calls in an
+        /// ImplicitCtorDtorStmt node.
+        template< typename OutputIterator >
         void genImplicitCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
-        ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
-        assert( obj );
-        // unnamed bit fields are not copied as they cannot be accessed
-        if ( isUnnamedBitfield( obj ) ) return;
+                ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
+                assert( obj );
+                // unnamed bit fields are not copied as they cannot be accessed
+                if ( isUnnamedBitfield( obj ) ) return;
 
-        bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) );
-        std::list< Statement * > stmts;
-        genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward );
+                bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) );
+                std::list< Statement * > stmts;
+                genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward );
 
-        // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call
-        assert( stmts.size() <= 1 );
-        if ( stmts.size() == 1 ) {
-            Statement * callStmt = stmts.front();
-            if ( addCast ) {
-                // implicitly generated ctor/dtor calls should be wrapped
-                // so that later passes are aware they were generated.
-                // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield,
-                // because this causes the address to be taken at codegen, which is illegal in C.
-                callStmt = new ImplicitCtorDtorStmt( callStmt );
-            }
-            *out++ = callStmt;
+                // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call
+                assert( stmts.size() <= 1 );
+                if ( stmts.size() == 1 ) {
+                        Statement * callStmt = stmts.front();
+                        if ( addCast ) {
+                                // implicitly generated ctor/dtor calls should be wrapped
+                                // so that later passes are aware they were generated.
+                                // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield,
+                                // because this causes the address to be taken at codegen, which is illegal in C.
+                                callStmt = new ImplicitCtorDtorStmt( callStmt );
+                        }
+                        *out++ = callStmt;
+                }
         }
-    }
 } // namespace SymTab
 #endif // AUTOGEN_H

src/SymTab/ImplementationType.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ImplementationType.cc -- 
+// ImplementationType.cc --
 //
 // Author           : Richard C. Bilson
@@ -92 +92 @@
 
         void ImplementationType::visit(TupleType *tupleType) {
-                TupleType *newType = new TupleType( Type::Qualifiers() );
+                std::list< Type * > types;
                 for ( std::list< Type* >::iterator i = tupleType->get_types().begin(); i != tupleType->get_types().end(); ++i ) {
                         Type *implType = implementationType( *i, indexer );
                         implType->get_qualifiers() |= tupleType->get_qualifiers();
-                        newType->get_types().push_back( implType );
+                        types.push_back( implType );
                 } // for
-                result = newType;
+                result = new TupleType( Type::Qualifiers(), types );
         }
 

src/SymTab/Indexer.cc

@@ -652 +652 @@
                         for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
                                 // check for C decls with the same name, skipping those with a compatible type (by mangleName)
-                                if ( decl->second->get_linkage() == LinkageSpec::C && decl->first != mangleName ) return true;
+                                if ( ! LinkageSpec::isMangled( decl->second->get_linkage() ) && decl->first != mangleName ) return true;
                         }
                 }
@@ -669 +669 @@
                                 // check for C decls with the same name, skipping
                                 // those with an incompatible type (by mangleName)
-                                if ( decl->second->get_linkage() == LinkageSpec::C && decl->first == mangleName ) return true;
+                                if ( ! LinkageSpec::isMangled( decl->second->get_linkage() ) && decl->first == mangleName ) return true;
                         }
                 }
@@ -724 +724 @@
                         // new definition shadows the autogenerated one, even at the same scope
                         return false;
-                } else if ( added->get_linkage() != LinkageSpec::C || ResolvExpr::typesCompatible( added->get_type(), existing->get_type(), Indexer() ) ) {
+                } else if ( LinkageSpec::isMangled( added->get_linkage() ) || ResolvExpr::typesCompatible( added->get_type(), existing->get_type(), Indexer() ) ) {
                         // typesCompatible doesn't really do the right thing here. When checking compatibility of function types,
                         // we should ignore outermost pointer qualifiers, except _Atomic?
@@ -765 +765 @@
 
                 // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage
-                if ( decl->get_linkage() == LinkageSpec::C ) {
+                if ( ! LinkageSpec::isMangled( decl->get_linkage() ) ) {
                         // NOTE this is broken in Richard's original code in such a way that it never triggers (it
                         // doesn't check decls that have the same manglename, and all C-linkage decls are defined to

src/SymTab/Validate.cc

@@ -106 +106 @@
 
         /// Fix return types so that every function returns exactly one value
-        class ReturnTypeFixer {
-          public:
+        struct ReturnTypeFixer {
                 static void fix( std::list< Declaration * > &translationUnit );
 
@@ -115 +114 @@
 
         /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers.
-        class EnumAndPointerDecay {
-        public:
+        struct EnumAndPointerDecay {
                 void previsit( EnumDecl *aggregateDecl );
                 void previsit( FunctionType *func );
@@ -159 +157 @@
         };
 
-        class ReturnChecker : public WithScopes {
-          public:
+        struct ReturnChecker : public WithGuards {
                 /// Checks that return statements return nothing if their return type is void
                 /// and return something if the return type is non-void.
                 static void checkFunctionReturns( std::list< Declaration * > & translationUnit );
-          private:
+
                 void previsit( FunctionDecl * functionDecl );
                 void previsit( ReturnStmt * returnStmt );
@@ -205 +202 @@
         };
 
-        class VerifyCtorDtorAssign {
-        public:
+        struct VerifyCtorDtorAssign {
                 /// ensure that constructors, destructors, and assignment have at least one
                 /// parameter, the first of which must be a pointer, and that ctor/dtors have no
@@ -216 +212 @@
 
         /// ensure that generic types have the correct number of type arguments
-        class ValidateGenericParameters {
-        public:
+        struct ValidateGenericParameters {
                 void previsit( StructInstType * inst );
                 void previsit( UnionInstType * inst );
         };
 
-        class ArrayLength {
-        public:
+        struct ArrayLength {
                 /// for array types without an explicit length, compute the length and store it so that it
                 /// is known to the rest of the phases. For example,
@@ -236 +230 @@
         };
 
-        class CompoundLiteral final : public GenPoly::DeclMutator {
+        struct CompoundLiteral final : public WithDeclsToAdd, public WithVisitorRef<CompoundLiteral> {
                 Type::StorageClasses storageClasses;
 
-                using GenPoly::DeclMutator::mutate;
-                DeclarationWithType * mutate( ObjectDecl *objectDecl ) final;
-                Expression *mutate( CompoundLiteralExpr *compLitExpr ) final;
+                void premutate( ObjectDecl *objectDecl );
+                Expression * postmutate( CompoundLiteralExpr *compLitExpr );
         };
 
@@ -248 +241 @@
                 LinkReferenceToTypes lrt( doDebug, 0 );
                 ForallPointerDecay fpd( 0 );
-                CompoundLiteral compoundliteral;
+                PassVisitor<CompoundLiteral> compoundliteral;
                 PassVisitor<ValidateGenericParameters> genericParams;
 
@@ -263 +256 @@
                 Concurrency::implementThreadStarter( translationUnit );
                 ReturnChecker::checkFunctionReturns( translationUnit );
-                compoundliteral.mutateDeclarationList( translationUnit );
+                mutateAll( translationUnit, compoundliteral );
                 acceptAll( translationUnit, fpd );
                 ArrayLength::computeLength( translationUnit );
@@ -883 +876 @@
         }
 
-        DeclarationWithType * CompoundLiteral::mutate( ObjectDecl *objectDecl ) {
+        void CompoundLiteral::premutate( ObjectDecl *objectDecl ) {
                 storageClasses = objectDecl->get_storageClasses();
-                DeclarationWithType * temp = Mutator::mutate( objectDecl );
-                return temp;
-        }
-
-        Expression *CompoundLiteral::mutate( CompoundLiteralExpr *compLitExpr ) {
+        }
+
+        Expression *CompoundLiteral::postmutate( CompoundLiteralExpr *compLitExpr ) {
                 // transform [storage_class] ... (struct S){ 3, ... };
                 // into [storage_class] struct S temp =  { 3, ... };
                 static UniqueName indexName( "_compLit" );
 
-                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, 0, compLitExpr->get_result(), compLitExpr->get_initializer() );
-                compLitExpr->set_result( 0 );
-                compLitExpr->set_initializer( 0 );
+                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, nullptr, compLitExpr->get_result(), compLitExpr->get_initializer() );
+                compLitExpr->set_result( nullptr );
+                compLitExpr->set_initializer( nullptr );
                 delete compLitExpr;
-                DeclarationWithType * newtempvar = mutate( tempvar );
-                addDeclaration( newtempvar );                                   // add modified temporary to current block
-                return new VariableExpr( newtempvar );
+                declsToAddBefore.push_back( tempvar );                                  // add modified temporary to current block
+                return new VariableExpr( tempvar );
         }
 

src/SynTree/Constant.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Constant.cc -- 
+// Constant.cc --
 //
 // Author           : Richard C. Bilson
@@ -46 +46 @@
 }
 
+unsigned long long Constant::get_ival() const {
+        assertf( safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." );
+        return val.ival;
+}
+
+double Constant::get_dval() const {
+        assertf( ! safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve dval from integer constant." );
+        return val.dval;
+}
+
 void Constant::print( std::ostream &os ) const {
         os << "(" << rep << " " << val.ival;

src/SynTree/Constant.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Constant.h -- 
+// Constant.h --
 //
 // Author           : Richard C. Bilson
@@ -32 +32 @@
         std::string & get_value() { return rep; }
         void set_value( std::string newValue ) { rep = newValue; }
+        unsigned long long get_ival() const;
+        double get_dval() const;
 
         /// generates a boolean constant of the given bool

src/SynTree/Expression.cc

@@ -21 +21 @@
 #include <iterator>
 
+#include "Declaration.h"
+#include "Expression.h"
+#include "Initializer.h"
+#include "Statement.h"
 #include "Type.h"
-#include "Initializer.h"
-#include "Expression.h"
-#include "Declaration.h"
-#include "Statement.h"
 #include "TypeSubstitution.h"
+#include "VarExprReplacer.h"
+
 #include "Common/utility.h"
+#include "Common/PassVisitor.h"
+
 #include "InitTweak/InitTweak.h"
 
@@ -92 +96 @@
 
         Declaration *decl = get_var();
-        // if ( decl != 0) decl->print(os, indent + 2);
         if ( decl != 0) decl->printShort(os, indent + 2);
         os << std::endl;
@@ -657 +660 @@
 }
 
+InitAlternative::InitAlternative( Type * type, Designation * designation ) : type( type ), designation( designation ) {}
+InitAlternative::InitAlternative( const InitAlternative & other ) : type( maybeClone( other.type ) ), designation( maybeClone( other.designation ) ) {}
+InitAlternative::~InitAlternative() {
+        delete type;
+        delete designation;
+}
+
+UntypedInitExpr::UntypedInitExpr( Expression * expr, const std::list<InitAlternative> & initAlts ) : expr( expr ), initAlts( initAlts ) {}
+UntypedInitExpr::UntypedInitExpr( const UntypedInitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), initAlts( other.initAlts ) {}
+UntypedInitExpr::~UntypedInitExpr() {
+        delete expr;
+}
+
+void UntypedInitExpr::print( std::ostream & os, int indent ) const {
+        os << "Untyped Init Expression" << std::endl << std::string( indent+2, ' ' );
+        expr->print( os, indent+2 );
+        if ( ! initAlts.empty() ) {
+                for ( const InitAlternative & alt : initAlts ) {
+                        os << std::string( indent+2, ' ' ) <<  "InitAlternative: ";
+                        alt.type->print( os, indent+2 );
+                        alt.designation->print( os, indent+2 );
+                }
+        }
+}
+
+InitExpr::InitExpr( Expression * expr, Designation * designation ) : expr( expr ), designation( designation ) {
+        set_result( expr->get_result()->clone() );
+}
+InitExpr::InitExpr( const InitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), designation( maybeClone( other.designation) ) {}
+InitExpr::~InitExpr() {
+        delete expr;
+        delete designation;
+}
+
+void InitExpr::print( std::ostream & os, int indent ) const {
+        os << "Init Expression" << std::endl << std::string( indent+2, ' ' );
+        expr->print( os, indent+2 );
+        os << std::string( indent+2, ' ' ) << "with designation: ";
+        designation->print( os, indent+2 );
+}
+
+
 std::ostream & operator<<( std::ostream & out, const Expression * expr ) {
         if ( expr ) {

src/SynTree/Expression.h

@@ -744 +744 @@
 };
 
+struct InitAlternative {
+public:
+        Type * type = nullptr;
+        Designation * designation = nullptr;
+        InitAlternative( Type * type, Designation * designation );
+        InitAlternative( const InitAlternative & other );
+        InitAlternative & operator=( const Initializer & other ) = delete; // at the moment this isn't used, and I don't want to implement it
+        ~InitAlternative();
+};
+
+class UntypedInitExpr : public Expression {
+public:
+        UntypedInitExpr( Expression * expr, const std::list<InitAlternative> & initAlts );
+        UntypedInitExpr( const UntypedInitExpr & other );
+        ~UntypedInitExpr();
+
+        Expression * get_expr() const { return expr; }
+        UntypedInitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
+
+        std::list<InitAlternative> & get_initAlts() { return initAlts; }
+
+        virtual UntypedInitExpr * clone() const { return new UntypedInitExpr( * this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+private:
+        Expression * expr;
+        std::list<InitAlternative> initAlts;
+};
+
+class InitExpr : public Expression {
+public:
+        InitExpr( Expression * expr, Designation * designation );
+        InitExpr( const InitExpr & other );
+        ~InitExpr();
+
+        Expression * get_expr() const { return expr; }
+        InitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
+
+        Designation * get_designation() const { return designation; }
+        InitExpr * set_designation( Designation * newValue ) { designation = newValue; return this; }
+
+        virtual InitExpr * clone() const { return new InitExpr( * this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+private:
+        Expression * expr;
+        Designation * designation;
+};
+
+
 std::ostream & operator<<( std::ostream & out, const Expression * expr );
 

src/SynTree/Initializer.cc

@@ -19 +19 @@
 #include "Common/utility.h"
 
+Designation::Designation( const std::list< Expression * > & designators ) : designators( designators ) {}
+Designation::Designation( const Designation & other ) : BaseSyntaxNode( other ) {
+        // std::cerr << "cloning designation" << std::endl;
+        cloneAll( other.designators, designators );
+        // std::cerr << "finished cloning designation" << std::endl;
+}
+
+Designation::~Designation() {
+        // std::cerr << "destroying designation" << std::endl;
+        deleteAll( designators );
+        // std::cerr << "finished destroying designation" << std::endl;
+}
+
+void Designation::print( std::ostream &os, int indent ) const {
+        if ( ! designators.empty() ) {
+                os << std::string(indent + 2, ' ' ) << "designated by: " << std::endl;
+                for ( std::list < Expression * >::const_iterator i = designators.begin(); i != designators.end(); i++ ) {
+                        os << std::string(indent + 4, ' ' );
+                        ( *i )->print(os, indent + 4 );
+                }
+                os << std::endl;
+        } // if
+}
+
 Initializer::Initializer( bool maybeConstructed ) : maybeConstructed( maybeConstructed ) {}
 Initializer::Initializer( const Initializer & other ) : BaseSyntaxNode( other ), maybeConstructed( other.maybeConstructed ) {
 }
-
-
 Initializer::~Initializer() {}
 
-std::string Initializer::designator_name( Expression *des ) {
-        if ( NameExpr *n = dynamic_cast<NameExpr *>(des) )
-                return n->get_name();
-        else
-                throw 0;
-}
-
-// void Initializer::print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent ) {}
-
-SingleInit::SingleInit( Expression *v, const std::list< Expression *> &_designators, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ), designators( _designators ) {
+SingleInit::SingleInit( Expression *v, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ) {
 }
 
 SingleInit::SingleInit( const SingleInit &other ) : Initializer(other), value ( maybeClone( other.value ) ) {
-        cloneAll(other.designators, designators );
 }
 
 SingleInit::~SingleInit() {
         delete value;
-        deleteAll(designators);
 }
 
-void SingleInit::print( std::ostream &os, int indent ) {
-        os << std::endl << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl;
+void SingleInit::print( std::ostream &os, int indent ) const {
+        os << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl;
         os << std::string(indent+4, ' ' );
         value->print( os, indent+4 );
-
-        if ( ! designators.empty() ) {
-                os << std::endl << std::string(indent + 2, ' ' ) << "designated by: " << std::endl;
-                for ( std::list < Expression * >::iterator i = designators.begin(); i != designators.end(); i++ ) {
-                        os << std::string(indent + 4, ' ' );
-                        ( *i )->print(os, indent + 4 );
-                }
-        } // if
 }
 
-ListInit::ListInit( const std::list<Initializer*> &_initializers, const std::list<Expression *> &_designators, bool maybeConstructed )
-        : Initializer( maybeConstructed ), initializers( _initializers ), designators( _designators ) {
+
+ListInit::ListInit( const std::list<Initializer*> &inits, const std::list<Designation *> &des, bool maybeConstructed )
+        : Initializer( maybeConstructed ), initializers( inits ), designations( des ) {
+                // handle the common case where a ListInit is created without designations by making a list of empty designations with the same length as the initializer
+                if ( designations.empty() ) {
+                        for ( auto & i : initializers ) {
+                                (void)i;
+                                designations.push_back( new Designation( {} ) );
+                        }
+                }
+                assertf( initializers.size() == designations.size(), "Created ListInit with mismatching initializers (%d) and designations (%d)", initializers.size(), designations.size() );
 }
 
 ListInit::ListInit( const ListInit & other ) : Initializer( other ) {
         cloneAll( other.initializers, initializers );
-        cloneAll( other.designators, designators );
+        cloneAll( other.designations, designations );
 }
-
 
 ListInit::~ListInit() {
         deleteAll( initializers );
-        deleteAll( designators );
+        deleteAll( designations );
 }
 
-void ListInit::print( std::ostream &os, int indent ) {
-        os << std::endl << std::string(indent, ' ') << "Compound initializer:  ";
-        if ( ! designators.empty() ) {
-                os << std::string(indent + 2, ' ' ) << "designated by: [";
-                for ( std::list < Expression * >::iterator i = designators.begin();
-                          i != designators.end(); i++ ) {
-                        ( *i )->print(os, indent + 4 );
-                } // for
+void ListInit::print( std::ostream &os, int indent ) const {
+        os << std::string(indent, ' ') << "Compound initializer:  " << std::endl;
+        for ( Designation * d : designations ) {
+                d->print( os, indent + 2 );
+        }
 
-                os << std::string(indent + 2, ' ' ) << "]";
-        } // if
-
-        for ( std::list<Initializer *>::iterator i = initializers.begin(); i != initializers.end(); i++ )
-                (*i)->print( os, indent + 2 );
+        for ( const Initializer * init : initializers ) {
+                init->print( os, indent + 2 );
+                os << std::endl;
+        }
 }
 
@@ -103 +110 @@
 }
 
-void ConstructorInit::print( std::ostream &os, int indent ) {
+void ConstructorInit::print( std::ostream &os, int indent ) const {
         os << std::endl << std::string(indent, ' ') << "Constructor initializer: " << std::endl;
         if ( ctor ) {
@@ -124 +131 @@
 }
 
-std::ostream & operator<<( std::ostream & out, Initializer * init ) {
-        init->print( out );
+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;
 }

src/SynTree/Initializer.h

@@ -25 +25 @@
 #include "Visitor.h"
 
-const std::list<Expression*> noDesignators;
+// Designation: list of designator (NameExpr, VariableExpr, and ConstantExpr) expressions that specify an object being initialized.
+class Designation : public BaseSyntaxNode {
+public:
+        Designation( const std::list< Expression * > & designators );
+        Designation( const Designation & other );
+        virtual ~Designation();
+
+        std::list< Expression * > & get_designators() { return designators; }
+
+        virtual Designation * clone() const { return new Designation( *this ); };
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+        std::list< Expression * > designators;
+};
+
+const std::list<Designation *> noDesignators;
 
 // Initializer: base class for object initializers (provide default values)
 class Initializer : public BaseSyntaxNode {
   public:
-        //      Initializer( std::string _name = std::string(""), int _pos = 0 );
         Initializer( bool maybeConstructed );
         Initializer( const Initializer & other );
         virtual ~Initializer();
-
-        static std::string designator_name( Expression *designator );
-
-        //      void set_name( std::string newValue ) { name = newValue; }
-        //      std::string get_name() const { return name; }
-
-        //      void set_pos( int newValue ) { pos = newValue; }
-        //      int get_pos() const { return pos; }
-        virtual void set_designators( std::list<Expression *> & ) { assert(false); }
-        virtual std::list<Expression *> &get_designators() {
-                assert(false);
-                std::list<Expression *> *ret = 0; return *ret;  // never reached
-        }
 
         bool get_maybeConstructed() { return maybeConstructed; }
@@ -53 +56 @@
         virtual void accept( Visitor &v ) = 0;
         virtual Initializer *acceptMutator( Mutator &m ) = 0;
-        virtual void print( std::ostream &os, int indent = 0 ) = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const = 0;
   private:
-        //      std::string name;
-        //      int pos;
         bool maybeConstructed;
 };
@@ -63 +64 @@
 class SingleInit : public Initializer {
   public:
-        SingleInit( Expression *value, const std::list< Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false );
+        SingleInit( Expression *value, bool maybeConstructed = false );
         SingleInit( const SingleInit &other );
         virtual ~SingleInit();
@@ -70 +71 @@
         void set_value( Expression *newValue ) { value = newValue; }
 
-        std::list<Expression *> &get_designators() { return designators; }
-        void set_designators( std::list<Expression *> &newValue ) { designators = 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 );
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         //Constant *value;
         Expression *value;      // has to be a compile-time constant
-        std::list< Expression * > designators;
 };
 
@@ -88 +85 @@
   public:
         ListInit( const std::list<Initializer*> &initializers,
-                          const std::list<Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false );
+                          const std::list<Designation *> &designators = {}, bool maybeConstructed = false );
         ListInit( const ListInit & other );
         virtual ~ListInit();
 
-        void set_designators( std::list<Expression *> &newValue ) { designators = newValue; }
-        std::list<Expression *> &get_designators() { return designators; }
-        void set_initializers( std::list<Initializer*> &newValue ) { initializers = newValue; }
-        std::list<Initializer*> &get_initializers() { return initializers; }
+        std::list<Designation *> & get_designations() { return designations; }
+        std::list<Initializer *> & get_initializers() { return initializers; }
 
         typedef std::list<Initializer*>::iterator iterator;
+        typedef std::list<Initializer*>::const_iterator const_iterator;
         iterator begin() { return initializers.begin(); }
         iterator end() { return initializers.end(); }
+        const_iterator begin() const { return initializers.begin(); }
+        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 );
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
-        std::list<Initializer*> initializers;  // order *is* important
-        std::list<Expression *> designators;
+        std::list<Initializer *> initializers;  // order *is* important
+        std::list<Designation *> designations;  // order/length is consistent with initializers
 };
 
@@ -130 +128 @@
         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 );
+        virtual void print( std::ostream &os, int indent = 0 ) const;
 
   private:
@@ -140 +138 @@
 };
 
-std::ostream & operator<<( std::ostream & out, Initializer * init );
+std::ostream & operator<<( std::ostream & out, const Initializer * init );
+std::ostream & operator<<( std::ostream & out, const Designation * des );
 
 #endif // INITIALIZER_H

src/SynTree/Mutator.cc

@@ -433 +433 @@
 }
 
+Expression *Mutator::mutate( UntypedInitExpr * initExpr ) {
+        initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) );
+        initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) );
+        initExpr->set_expr( maybeMutate( initExpr->get_expr(), *this ) );
+        // not currently mutating initAlts, but this doesn't matter since this node is only used in the resolver.
+        return initExpr;
+}
+
+Expression *Mutator::mutate( InitExpr * initExpr ) {
+        initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) );
+        initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) );
+        initExpr->set_expr( maybeMutate( initExpr->get_expr(), *this ) );
+        initExpr->set_designation( maybeMutate( initExpr->get_designation(), *this ) );
+        return initExpr;
+}
+
 
 Type *Mutator::mutate( VoidType *voidType ) {
@@ -499 +515 @@
         mutateAll( tupleType->get_forall(), *this );
         mutateAll( tupleType->get_types(), *this );
+        mutateAll( tupleType->get_members(), *this );
         return tupleType;
 }
@@ -535 +552 @@
 
 
+Designation *Mutator::mutate( Designation * designation ) {
+        mutateAll( designation->get_designators(), *this );
+        return designation;
+}
+
 Initializer *Mutator::mutate( SingleInit *singleInit ) {
         singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) );
@@ -541 +563 @@
 
 Initializer *Mutator::mutate( ListInit *listInit ) {
-        mutateAll( listInit->get_designators(), *this );
+        mutateAll( listInit->get_designations(), *this );
         mutateAll( listInit->get_initializers(), *this );
         return listInit;

src/SynTree/Mutator.h

@@ -85 +85 @@
         virtual Expression* mutate( StmtExpr * stmtExpr );
         virtual Expression* mutate( UniqueExpr * uniqueExpr );
+        virtual Expression* mutate( UntypedInitExpr * initExpr );
+        virtual Expression* mutate( InitExpr * initExpr );
 
         virtual Type* mutate( VoidType *basicType );
@@ -103 +105 @@
         virtual Type* mutate( OneType *oneType );
 
+        virtual Designation* mutate( Designation *designation );
         virtual Initializer* mutate( SingleInit *singleInit );
         virtual Initializer* mutate( ListInit *listInit );

src/SynTree/SynTree.h

@@ -93 +93 @@
 class StmtExpr;
 class UniqueExpr;
+class UntypedInitExpr;
+class InitExpr;
 
 class Type;
@@ -113 +115 @@
 class OneType;
 
+class Designation;
 class Initializer;
 class SingleInit;

src/SynTree/TupleType.cc

@@ -14 +14 @@
 //
 
+#include "Declaration.h"
+#include "Initializer.h"
 #include "Type.h"
 #include "Common/utility.h"
+#include "Parser/LinkageSpec.h"
 
 TupleType::TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), types( types ) {
+        for ( Type * t : *this ) {
+                // xxx - this is very awkward. TupleTypes should contain objects so that members can be named, but if they don't have an initializer node then
+                // they end up getting constructors, which end up being inserted causing problems. This happens because the object decls have to be visited so that
+                // their types are kept in sync with the types list here. Ultimately, the types list here should be eliminated and perhaps replaced with a list-view
+                // of the object types list, but I digress. The temporary solution here is to make a ListInit with maybeConstructed = false, that way even when the
+                // object is visited, it is never constructed. Ultimately, a better solution might be either:
+                // a) to separate TupleType from its declarations, into TupleDecl and Tuple{Inst?}Type, ala StructDecl and StructInstType
+                // b) separate initializer nodes better, e.g. add a MaybeConstructed node that is replaced by genInit, rather than what currently exists in a bool
+                members.push_back( new ObjectDecl( "" , Type::StorageClasses(), LinkageSpec::Cforall, nullptr, t->clone(), new ListInit( {}, {}, false ) ) );
+        }
 }
 
 TupleType::TupleType( const TupleType& other ) : Type( other ) {
         cloneAll( other.types, types );
+        cloneAll( other.members, members );
 }
 
 TupleType::~TupleType() {
         deleteAll( types );
+        deleteAll( members );
 }
 

src/SynTree/Type.h

@@ -481 +481 @@
 class TupleType : public Type {
   public:
-        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TupleType( const TupleType& );
         virtual ~TupleType();
@@ -488 +488 @@
         typedef value_type::iterator iterator;
 
-        std::list<Type*>& get_types() { return types; }
+        std::list<Type *> & get_types() { return types; }
         virtual unsigned size() const { return types.size(); };
+
+        // For now, this is entirely synthetic -- tuple types always have unnamed members.
+        // Eventually, we may allow named tuples, in which case members should subsume types
+        std::list<Declaration *> & get_members() { return members; }
 
         iterator begin() { return types.begin(); }
@@ -506 +510 @@
         virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
-        std::list<Type*> types;
+        std::list<Type *> types;
+        std::list<Declaration *> members;
 };
 

src/SynTree/VarExprReplacer.cc

@@ -14 +14 @@
 //
 
+#include "Declaration.h"
 #include "Expression.h"
 #include "VarExprReplacer.h"
 
-VarExprReplacer::VarExprReplacer( const DeclMap & declMap ) : declMap( declMap ) {}
+VarExprReplacer::VarExprReplacer( const DeclMap & declMap, bool debug ) : declMap( declMap ), debug( debug ) {}
 
 // replace variable with new node from decl map
 void VarExprReplacer::visit( VariableExpr * varExpr ) {
-  // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
-  if ( declMap.count( varExpr->get_var() ) ) {
-    varExpr->set_var( declMap.at( varExpr->get_var() ) );
-  }
+        // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
+        if ( declMap.count( varExpr->get_var() ) ) {
+                if ( debug ) {
+                        std::cerr << "replacing variable reference: " << (void*)varExpr->get_var() << " " << varExpr->get_var() << " with " << (void*)declMap.at( varExpr->get_var() ) << " " << declMap.at( varExpr->get_var() ) << std::endl;
+                }
+                varExpr->set_var( declMap.at( varExpr->get_var() ) );
+        }
 }

src/SynTree/VarExprReplacer.h

@@ -27 +27 @@
 private:
         const DeclMap & declMap;
+  bool debug;
 public:
-        VarExprReplacer( const DeclMap & declMap );
+        VarExprReplacer( const DeclMap & declMap, bool debug = false );
 
         // replace variable with new node from decl map

src/SynTree/Visitor.cc

@@ -340 +340 @@
 }
 
+void Visitor::visit( UntypedInitExpr * initExpr ) {
+        maybeAccept( initExpr->get_result(), *this );
+        maybeAccept( initExpr->get_expr(), *this );
+        // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
+}
+
+void Visitor::visit( InitExpr * initExpr ) {
+        maybeAccept( initExpr->get_result(), *this );
+        maybeAccept( initExpr->get_expr(), *this );
+        maybeAccept( initExpr->get_designation(), *this );
+}
+
 
 void Visitor::visit( VoidType *voidType ) {
@@ -395 +407 @@
         acceptAll( tupleType->get_forall(), *this );
         acceptAll( tupleType->get_types(), *this );
+        acceptAll( tupleType->get_members(), *this );
 }
 
@@ -424 +437 @@
 }
 
+void Visitor::visit( Designation * designation ) {
+        acceptAll( designation->get_designators(), *this );
+}
 
 void Visitor::visit( SingleInit *singleInit ) {
@@ -430 +446 @@
 
 void Visitor::visit( ListInit *listInit ) {
-        acceptAll( listInit->get_designators(), *this );
+        acceptAll( listInit->get_designations(), *this );
         acceptAll( listInit->get_initializers(), *this );
 }

src/SynTree/Visitor.h

@@ -88 +88 @@
         virtual void visit( StmtExpr * stmtExpr );
         virtual void visit( UniqueExpr * uniqueExpr );
+        virtual void visit( UntypedInitExpr * initExpr );
+        virtual void visit( InitExpr * initExpr );
 
         virtual void visit( VoidType *basicType );
@@ -106 +108 @@
         virtual void visit( OneType *oneType );
 
+        virtual void visit( Designation *designation );
         virtual void visit( SingleInit *singleInit );
         virtual void visit( ListInit *listInit );

src/Tuples/TupleExpansion.cc

@@ -192 +192 @@
                         }
                         ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ),
-                                                                                                        new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ), noDesignators ) );
+                                                                                                        new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ) ) );
                         addDeclaration( finished );
                         // (finished ? _unq_expr_N : (_unq_expr_N = <unqExpr->get_expr()>, finished = 1, _unq_expr_N))
@@ -310 +310 @@
         Type * makeTupleType( const std::list< Expression * > & exprs ) {
                 // produce the TupleType which aggregates the types of the exprs
-                TupleType *tupleType = new TupleType( Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex ) );
-                Type::Qualifiers &qualifiers = tupleType->get_qualifiers();
+                std::list< Type * > types;
+                Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex );
                 for ( Expression * expr : exprs ) {
                         assert( expr->get_result() );
                         if ( expr->get_result()->isVoid() ) {
                                 // if the type of any expr is void, the type of the entire tuple is void
-                                delete tupleType;
                                 return new VoidType( Type::Qualifiers() );
                         }
                         Type * type = expr->get_result()->clone();
-                        tupleType->get_types().push_back( type );
+                        types.push_back( type );
                         // the qualifiers on the tuple type are the qualifiers that exist on all component types
                         qualifiers &= type->get_qualifiers();
                 } // for
                 if ( exprs.empty() ) qualifiers = Type::Qualifiers();
-                return tupleType;
+                return new TupleType( qualifiers, types );
         }
 

src/libcfa/Makefile.am

@@ -50 +50 @@
 
 libobjs = ${headers:=.o}
-libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c}
+libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} exception.c
 
 # not all platforms support concurrency, add option do disable it

src/libcfa/Makefile.in

@@ -102 +102 @@
         containers/pair.c containers/result.c containers/vector.c \
         concurrency/coroutine.c concurrency/thread.c \
-        concurrency/kernel.c concurrency/monitor.c \
+        concurrency/kernel.c concurrency/monitor.c exception.c \
         concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
         concurrency/invoke.c concurrency/preemption.c
@@ -126 +126 @@
         libcfa_d_a-interpose.$(OBJEXT) \
         libhdr/libcfa_d_a-libdebug.$(OBJEXT) $(am__objects_2) \
-        $(am__objects_3)
+        libcfa_d_a-exception.$(OBJEXT) $(am__objects_3)
 am_libcfa_d_a_OBJECTS = $(am__objects_4)
 libcfa_d_a_OBJECTS = $(am_libcfa_d_a_OBJECTS)
@@ -136 +136 @@
         containers/pair.c containers/result.c containers/vector.c \
         concurrency/coroutine.c concurrency/thread.c \
-        concurrency/kernel.c concurrency/monitor.c \
+        concurrency/kernel.c concurrency/monitor.c exception.c \
         concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
         concurrency/invoke.c concurrency/preemption.c
@@ -158 +158 @@
         libcfa_a-interpose.$(OBJEXT) \
         libhdr/libcfa_a-libdebug.$(OBJEXT) $(am__objects_6) \
-        $(am__objects_7)
+        libcfa_a-exception.$(OBJEXT) $(am__objects_7)
 am_libcfa_a_OBJECTS = $(am__objects_8)
 libcfa_a_OBJECTS = $(am_libcfa_a_OBJECTS)
@@ -328 +328 @@
 libobjs = ${headers:=.o}
 libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} \
-        $(am__append_4)
+        exception.c $(am__append_4)
 libcfa_a_SOURCES = ${libsrc}
 libcfa_a_CFLAGS = -nodebug -O2
@@ -514 +514 @@
 
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-assert.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-exception.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-fstream.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-interpose.Po@am__quote@
@@ -524 +525 @@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-stdlib.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-assert.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-exception.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-fstream.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-interpose.Po@am__quote@
@@ -850 +852 @@
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-monitor.obj `if test -f 'concurrency/monitor.c'; then $(CYGPATH_W) 'concurrency/monitor.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/monitor.c'; fi`
 
+libcfa_d_a-exception.obj: exception.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-exception.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-exception.Tpo -c -o libcfa_d_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-exception.Tpo $(DEPDIR)/libcfa_d_a-exception.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='exception.c' object='libcfa_d_a-exception.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi`
+
 concurrency/libcfa_d_a-alarm.o: concurrency/alarm.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-alarm.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-alarm.Tpo -c -o concurrency/libcfa_d_a-alarm.o `test -f 'concurrency/alarm.c' || echo '$(srcdir)/'`concurrency/alarm.c
@@ -1143 +1152 @@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-monitor.obj `if test -f 'concurrency/monitor.c'; then $(CYGPATH_W) 'concurrency/monitor.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/monitor.c'; fi`
+
+libcfa_a-exception.obj: exception.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-exception.obj -MD -MP -MF $(DEPDIR)/libcfa_a-exception.Tpo -c -o libcfa_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-exception.Tpo $(DEPDIR)/libcfa_a-exception.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='exception.c' object='libcfa_a-exception.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi`
 
 concurrency/libcfa_a-alarm.o: concurrency/alarm.c

src/libcfa/exception.c

@@ -44 +44 @@
 // RESUMPTION ================================================================
 
-void __cfaehm__throw_resume(exception except) {
-
-        // DEBUG
-        printf("Throwing resumption exception %d\n", except);
-
-        struct __try_resume_node * original_head = shared_stack.current_resume;
-        struct __try_resume_node * current =
+void __cfaehm__throw_resumption(exception * except) {
+
+        // DEBUG
+        printf("Throwing resumption exception %d\n", *except);
+
+        struct __cfaehm__try_resume_node * original_head = shared_stack.current_resume;
+        struct __cfaehm__try_resume_node * current =
                 (original_head) ? original_head->next : shared_stack.top_resume;
 
         for ( ; current ; current = current->next) {
                 shared_stack.current_resume = current;
-                if (current->try_to_handle(except)) {
+                if (current->handler(except)) {
                         shared_stack.current_resume = original_head;
                         return;
@@ -61 +61 @@
         }
 
-        printf("Unhandled exception %d\n", except);
+        printf("Unhandled exception %d\n", *except);
         shared_stack.current_resume = original_head;
 
         // Fall back to termination:
-        __cfaehm__throw_terminate(except);
+        __cfaehm__throw_termination(except);
         // TODO: Default handler for resumption.
 }
@@ -73 +73 @@
  * after the node is built but before it is made the top node.
  */
-void __try_resume_setup(struct __try_resume_node * node,
-                        bool (*handler)(exception except)) {
+void __cfaehm__try_resume_setup(struct __cfaehm__try_resume_node * node,
+                        int (*handler)(exception * except)) {
         node->next = shared_stack.top_resume;
-        node->try_to_handle = handler;
+        node->handler = handler;
         shared_stack.top_resume = node;
 }
 
-void __try_resume_cleanup(struct __try_resume_node * node) {
+void __cfaehm__try_resume_cleanup(struct __cfaehm__try_resume_node * node) {
         shared_stack.top_resume = node->next;
 }
@@ -111 +111 @@
 }
 
-void __cfaehm__throw_terminate( int val ) {
+void __cfaehm__throw_termination( exception * val ) {
         // Store the current exception
-        shared_stack.current_exception = val;
-
-        // DEBUG
-        printf("Throwing termination exception %d\n", val);
+        shared_stack.current_exception = *val;
+
+        // DEBUG
+        printf("Throwing termination exception %d\n", *val);
 
         // Call stdlibc to raise the exception
@@ -147 +147 @@
 
 // Nesting this the other way would probably be faster.
-void __cfaehm__rethrow_terminate(void) {
+void __cfaehm__rethrow_termination(void) {
         // DEBUG
         printf("Rethrowing termination exception\n");
 
-        __cfaehm__throw_terminate(shared_stack.current_exception);
+        __cfaehm__throw_termination(&shared_stack.current_exception);
 }
 
@@ -322 +322 @@
 // for details
 __attribute__((noinline))
-void __try_terminate(void (*try_block)(),
-                void (*catch_block)(int index, exception except),
-                __attribute__((unused)) int (*match_block)(exception except)) {
+void __cfaehm__try_terminate(void (*try_block)(),
+                void (*catch_block)(int index, exception * except),
+                __attribute__((unused)) int (*match_block)(exception * except)) {
         //! volatile int xy = 0;
         //! printf("%p %p %p %p\n", &try_block, &catch_block, &match_block, &xy);
@@ -364 +364 @@
         // Exception handler
         catch_block(shared_stack.current_handler_index,
-                    shared_stack.current_exception);
+                    &shared_stack.current_exception);
 }
 
@@ -384 +384 @@
         // Body uses language specific data and therefore could be modified arbitrarily
         ".LLSDACSBCFA2:\n"                                              // BODY start
-        "       .uleb128 .TRYSTART-__try_terminate\n"           // Handled area start  (relative to start of function)
+        "       .uleb128 .TRYSTART-__cfaehm__try_terminate\n"           // Handled area start  (relative to start of function)
         "       .uleb128 .TRYEND-.TRYSTART\n"                           // Handled area length
-        "       .uleb128 .CATCH-__try_terminate\n"                              // Hanlder landing pad adress  (relative to start of function)
+        "       .uleb128 .CATCH-__cfaehm__try_terminate\n"                              // Hanlder landing pad adress  (relative to start of function)
         "       .uleb128 1\n"                                           // Action code, gcc seems to use always 0
         ".LLSDACSECFA2:\n"                                              // BODY end
         "       .text\n"                                                        // TABLE footer
-        "       .size   __try_terminate, .-__try_terminate\n"
+        "       .size   __cfaehm__try_terminate, .-__cfaehm__try_terminate\n"
         "       .ident  \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n"
 //      "       .section        .note.GNU-stack,\"x\",@progbits\n"

src/libcfa/exception.h

@@ -38 +38 @@
 // Data structure creates a list of resume handlers.
 struct __cfaehm__try_resume_node {
-    __cfaehm__try_resume_node * next;
+    struct __cfaehm__try_resume_node * next;
     int (*handler)(exception * except);
 };
 
 void __cfaehm__try_resume_setup(
-    __cfaehm__try_resume_node * node,
+    struct __cfaehm__try_resume_node * node,
     int (*handler)(exception * except));
 void __cfaehm__try_resume_cleanup(
-    __cfaehm__try_resume_node * node);
+    struct __cfaehm__try_resume_node * node);
 
 // Check for a standard way to call fake deconstructors.

src/libcfa/fstream

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon May 15 18:11:09 2017
-// Update Count     : 104
+// Last Modified On : Sat Jul  1 16:37:53 2017
+// Update Count     : 112
 //
 
@@ -24 +24 @@
         _Bool sepDefault;
         _Bool sepOnOff;
+        _Bool lastSepOn;
         const char * sepCur;
         char separator[separateSize];
@@ -35 +36 @@
 const char * sepGetCur( ofstream * );
 void sepSetCur( ofstream *, const char * );
+_Bool lastSepOn( ofstream * );
 
 // public

src/libcfa/fstream.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon May 15 18:11:11 2017
-// Update Count     : 234
+// Last Modified On : Sat Jul  1 16:37:54 2017
+// Update Count     : 242
 //
 
@@ -33 +33 @@
         this->sepDefault = sepDefault;
         this->sepOnOff = sepOnOff;
+        this->lastSepOn = false;
         sepSet( this, separator );
         sepSetCur( this, sepGet( this ) );
@@ -39 +40 @@
 
 // private
-_Bool sepPrt( ofstream * os ) { return os->sepOnOff; }
+_Bool lastSepOn( ofstream * os ) { return os->lastSepOn; }
+_Bool sepPrt( ofstream * os ) { os->lastSepOn = false; return os->sepOnOff; }
 void sepReset( ofstream * os ) { os->sepOnOff = os->sepDefault; }
 void sepReset( ofstream * os, _Bool reset ) { os->sepDefault = reset; os->sepOnOff = os->sepDefault; }
@@ -46 +48 @@
 
 // public
-void sepOn( ofstream * os ) { os->sepOnOff = 1; }
-void sepOff( ofstream * os ) { os->sepOnOff = 0; }
+void sepOn( ofstream * os ) { os->lastSepOn = true; os->sepOnOff = true; }
+void sepOff( ofstream * os ) { os->lastSepOn = false; os->sepOnOff = 0; }
 
 _Bool sepDisable( ofstream *os ) {
         _Bool temp = os->sepDefault;
         os->sepDefault = false;
+        os->lastSepOn = false;
         sepReset( os );
         return temp;
@@ -92 +95 @@
                 exit( EXIT_FAILURE );
         } // if
-        ?{}( os, file, 1, 0, " ", ", " );
+        ?{}( os, file, true, false, " ", ", " );
 } // open
 
@@ -132 +135 @@
 } // fmt
 
-static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), 1, 0, " ", ", " };
+static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), true, false, " ", ", " };
 ofstream *sout = &soutFile;
-static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), 1, 0, " ", ", " };
+static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), true, false, " ", ", " };
 ofstream *serr = &serrFile;
 

src/libcfa/iostream

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon May 15 18:08:44 2017
-// Update Count     : 105
+// Last Modified On : Sun Jul  2 08:42:56 2017
+// Update Count     : 110
 //
 
@@ -26 +26 @@
         const char * sepGetCur( ostype * );                                     // get current separator string
         void sepSetCur( ostype *, const char * );                       // set current separator string
+        _Bool lastSepOn( ostype * );                                            // last manipulator is setOn (context sensitive)
         // public
         void sepOn( ostype * );                                                         // turn separator state on
@@ -43 +44 @@
         ostype * write( ostype *, const char *, unsigned long int );
         int fmt( ostype *, const char fmt[], ... );
-};
+}; // ostream
 
 trait writeable( otype T ) {
         forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, T );
-};
+}; // writeable
 
 // implement writable for intrinsic types
@@ -103 +104 @@
         istype * ungetc( istype *, char );
         int fmt( istype *, const char fmt[], ... );
-};
+}; // istream
 
 trait readable( otype T ) {
         forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, T );
-};
+}; // readable
 
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, char * );

src/libcfa/iostream.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon May  8 18:24:23 2017
-// Update Count     : 369
+// Last Modified On : Sun Jul  2 08:54:02 2017
+// Update Count     : 375
 //
 
@@ -201 +201 @@
 forall( dtype ostype, otype T, ttype Params | ostream( ostype ) | writeable( T ) | { ostype * ?|?( ostype *, Params ); } )
 ostype * ?|?( ostype * os, T arg, Params rest ) {
+        os | arg;                                                                                       // print first argument
         sepSetCur( os, sepGetTuple( os ) );                                     // switch to tuple separator
-        os | arg;                                                                                       // print first argument
         os | rest;                                                                                      // print remaining arguments
         sepSetCur( os, sepGet( os ) );                                          // switch to regular separator
@@ -217 +217 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * endl( ostype * os ) {
+        if ( lastSepOn( os ) ) fmt( os, "%s", sepGetCur( os ) );
         os | '\n';
         flush( os );

src/main.cc

@@ -11 +11 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun 28 21:56:47 2017
-// Update Count     : 440
+// Last Modified On : Thu Jun 29 12:46:50 2017
+// Update Count     : 441
 //
 
@@ -39 +39 @@
 #include "CodeTools/TrackLoc.h"
 #include "ControlStruct/Mutate.h"
+#include "ControlStruct/ExceptTranslate.h"
 #include "SymTab/Validate.h"
 #include "ResolvExpr/AlternativePrinter.h"
@@ -290 +291 @@
                 Tuples::expandUniqueExpr( translationUnit );
 
+                OPTPRINT( "translateEHM" );
+                ControlStruct::translateEHM( translationUnit );
+
                 OPTPRINT( "convertSpecializations" ) // needs to happen before tuple types are expanded
                 GenPoly::convertSpecializations( translationUnit );
@@ -481 +485 @@
                         break;
                   case '?':
-                        assertf( false, "Unknown option: '%c'\n", (char)optopt );
+                        if ( optopt ) {                                                         // short option ?
+                                assertf( false, "Unknown option: -%c\n", (char)optopt );
+                        } else {
+                                assertf( false, "Unknown option: %s\n", argv[optind - 1] );
+                        } // if
                   default:
                         abort();

src/prelude/Makefile.am

@@ -23 +23 @@
 noinst_DATA = ../libcfa/libcfa-prelude.c
 
+CC = ${abs_top_srcdir}/src/driver/cfa
+
 $(DEPDIR) :
         mkdir $(DEPDIR)
@@ -45 +47 @@
 
 # create forward declarations for cfa builtins
-builtins.cf : builtins.c
-        ${AM_V_GEN}@BACKEND_CC@ -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po
+builtins.cf : builtins.c ${CC}
+        ${AM_V_GEN}${CC} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po
         ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
 

src/prelude/Makefile.in

@@ -95 +95 @@
 AWK = @AWK@
 BACKEND_CC = @BACKEND_CC@
-CC = @CC@
+CC = ${abs_top_srcdir}/src/driver/cfa
 CCAS = @CCAS@
 CCASDEPMODE = @CCASDEPMODE@
@@ -444 +444 @@
 
 # create forward declarations for cfa builtins
-builtins.cf : builtins.c
-        ${AM_V_GEN}@BACKEND_CC@ -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po
+builtins.cf : builtins.c ${CC}
+        ${AM_V_GEN}${CC} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po
         ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
 

src/tests/.expect/io.txt

@@ -4 +4 @@
 123
 
+opening delimiters 
 x (1 x [2 x {3 x =4 x $5 x £6 x ¥7 x ¡8 x ¿9 x «10
-1, x 2. x 3; x 4! x 5? x 6% x 7¢ x 8» x 9) x 10] x 11} x
+
+closing delimiters 
+1, x 2. x 3; x 4! x 5? x 6% x 7¢ x 8» x 9) x 10] x 11} x 
+
+opening/closing delimiters 
 x`1`x'2'x"3"x:4:x 5 x   6       x
 7
@@ -14 +19 @@
 x
 10
-x
+x 
+
+override opening/closing delimiters 
 x ( 1 ) x 2 , x 3 :x: 4
+
+input bacis types 
+
+output basic types 
 A 
 1 2 3 4 5 6 7 8
@@ -21 +32 @@
 1.1+2.3i 1.1-2.3i 1.1-2.3i
 
+tuples 
+1, 2, 3 3, 4, 5
+
+toggle separator 
 1.11.21.3
 1.1+2.3i1.1-2.3i1.1-2.3i
- abcxyz
-abcxyz
+ abcxyz 
+abcxyz 
 
+change separator 
+from "  "to " , $"
 1.1, $1.2, $1.3
 1.1+2.3i, $1.1-2.3i, $1.1-2.3i
-abc, $xyz
+abc, $xyz, $
+1, 2, 3, $3, 4, 5
 
-1, 2, 3, 4
-1, $2, $3 ", $"
-1 2 3 " "
+from ", $"to " "
+1.1 1.2 1.3
+1.1+2.3i 1.1-2.3i 1.1-2.3i
+abc xyz 
+1, 2, 3 3, 4, 5
+
+ 1 2 3 
+12 3
  1 2 3
-12 3
+1 2 3
+ 1 2 3
+
 123
 1 23
 1 2 3
-1 2 3 4 " "
-1, 2, 3, 4 ", "
-1, 2, 3, 4
+123
+1 2 3
+123 
+1 2 3
+
+1 2 3 3 4 5 " "
+1, 2, 3 3, 4, 5 ", "
+1, 2, 3 3, 4, 5
+
 3, 4, a, 7.2
 3, 4, a, 7.2
 3 4 a 7.2
  3 4 a 7.234a7.23 4 a 7.2
-3-4-a-7.2^3^4-3-4-a-7.2
+3-4-a-7.2^3^4^3-4-a-7.2

src/tests/io.c

@@ -10 +10 @@
 // Created On       : Wed Mar  2 16:56:02 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jun  8 09:52:10 2017
-// Update Count     : 51
+// Last Modified On : Sun Jul  2 09:40:58 2017
+// Update Count     : 68
 // 
 
@@ -42 +42 @@
         sout | endl;
 
+        sout | "opening delimiters" | endl;
         sout
-                // opening delimiters
                 | "x (" | 1
                 | "x [" | 2
@@ -54 +54 @@
                 | "x ¿" | 9
                 | "x «" | 10
-                | endl;
+                | endl | endl;
+
+        sout | "closing delimiters" | endl;
         sout
-                // closing delimiters
                 | 1 | ", x"
                 | 2 | ". x"
@@ -68 +69 @@
                 | 10 | "] x"
                 | 11 | "} x"
-                | endl;
+                | endl | endl;
+
+        sout | "opening/closing delimiters" | endl;
         sout
-                // opening-closing delimiters
                 | "x`" | 1 | "`x'" | 2
                 | "'x\"" | 3 | "\"x:" | 4
@@ -76 +78 @@
                 | "\tx\f" | 7 | "\fx\v" | 8
                 | "\vx\n" | 9 | "\nx\r" | 10
-                | "\rx" |
-                endl;
+                | "\rx"
+                | endl | endl;
+
+        sout | "override opening/closing delimiters" | endl;
         sout | "x ( " | 1 | " ) x" | 2 | " , x" | 3 | " :x: " | 4 | endl;
+        sout | endl;
 
         ifstream in;                                                                            // create / open file
         open( &in, "io.data", "r" );
 
+        sout | "input bacis types" | endl;
         &in | &c                                                                                        // character
                 | &si | &usi | &i | &ui | &li | &uli | &lli | &ulli     // integral
@@ -88 +94 @@
                 | &fc | &dc | &ldc                                                              // floating-point complex
                 | cstr( s1 ) | cstr( s2, size );                                // C string, length unchecked and checked
+        sout | endl;
 
+        sout | "output basic types" | endl;
         sout | c | ' ' | endl                                                           // character
                 | si | usi | i | ui | li | uli | lli | ulli | endl // integral
@@ -94 +102 @@
                 | fc | dc | ldc | endl;                                                 // complex
         sout | endl;
+
+        sout | "tuples" | endl;
+        [int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 3, [ 4, 5 ] ];
+        sout | t1 | t2 | endl;                                                          // print tuple
+        sout | endl;
+
+        sout | "toggle separator" | endl;
         sout | f | "" | d | "" | ld | endl                                      // floating point without separator
                 | sepDisable | fc | dc | ldc | sepEnable | endl // complex without separator
@@ -100 +115 @@
         sout | endl;
 
+        sout | "change separator" | endl;
+        sout | "from \" " | sepGet( sout ) | "\"";
         sepSet( sout, ", $" );                                                          // change separator, maximum of 15 characters
+        sout | "to \" " | sepGet( sout ) | "\"" | endl;
         sout | f | d | ld | endl
                 | fc | dc | ldc | endl
-                | s1 | s2 | endl;
+                | s1 | s2 | endl
+                | t1 | t2 | endl;                                                               // print tuple
+        sout | endl;
+        sout | "from \"" | sepGet( sout ) | "\"";
+        sepSet( sout, " " );                                                            // restore separator
+        sout | "to \"" | sepGet( sout ) | "\"" | endl;
+        sout | f | d | ld | endl
+                | fc | dc | ldc | endl
+                | s1 | s2 | endl
+                | t1 | t2 | endl;                                                               // print tuple
         sout | endl;
 
-        [int, int] t1 = [1, 2], t2 = [3, 4];
-        sout | t1 | t2 | endl;                                                          // print tuple
-
-        sepSet( sout, " " );
-        sepSet( sout, ", $" );                                                          // set separator from " " to ", $"
-        sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl;
-        sepSet( sout, " " );                                                            // reset separator to " "
-        sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl;
-
-        sout | sepOn | 1 | 2 | 3 | sepOn | endl;                        // separator at start of line
+        sout | sepOn | 1 | 2 | 3 | sepOn | endl;                        // separator at start/end of line
         sout | 1 | sepOff | 2 | 3 | endl;                                       // locally turn off implicit separator
+        sout | sepOn | 1 | 2 | 3 | sepOn | sepOff | endl;       // separator at start of line
+        sout | 1 | 2 | 3 | endl | sepOn;                                        // separator at start of next line
+        sout | 1 | 2 | 3 | endl;
+        sout | endl;
 
         sout | sepDisable | 1 | 2 | 3 | endl;                           // globally turn off implicit separation
         sout | 1 | sepOn | 2 | 3 | endl;                                        // locally turn on implicit separator
-        sout | sepEnable | 1 | 2 | 3 | endl;                            // globally turn on implicit separation
+        sout | sepEnable | 1 | 2 | 3 | endl | sepDisable;       // globally turn on/off implicit separation
+        sout | 1 | 2 | 3 | endl | sepEnable;                            // globally turn on implicit separation
+        sout | 1 | 2 | 3 | sepOn | sepDisable | endl;           // ignore seperate at end of line
+        sout | 1 | 2 | 3 | sepOn | sepEnable | endl;            // separator at end of line
+        sout | 1 | 2 | 3 | endl;
+        sout | endl;
 
         sepSetTuple( sout, " " );                                                       // set tuple separator from ", " to " "
@@ -126 +153 @@
         sepSetTuple( sout, ", " );                                                      // reset tuple separator to ", "
         sout | t1 | t2 | " \"" | sepGetTuple( sout ) | "\"" | endl;
-
         sout | t1 | t2 | endl;                                                          // print tuple
+        sout | endl;
 
         [int, int, const char *, double] t3 = { 3, 4, "a", 7.2 };