Changeset cd7ef0b for src

Timestamp:

Aug 10, 2017, 3:39:11 PM (8 years ago)

Author:

Aaron Moss <a3moss@…>

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:

38d70ab

Parents:

275f4b4 (diff), e1780a2 (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:

• ControlStruct/ExceptTranslate.cc (modified) (21 diffs)
• GenPoly/Box.cc (modified) (3 diffs)
• GenPoly/Lvalue.cc (modified) (4 diffs)
• GenPoly/Lvalue.h (modified) (2 diffs)
• Makefile.am (modified) (1 diff)
• Makefile.in (modified) (2 diffs)
• Parser/ExpressionNode.cc (modified) (13 diffs)
• Parser/InitializerNode.cc (modified) (7 diffs)
• Parser/ParseNode.h (modified) (2 diffs)
• Parser/TypeData.cc (modified) (3 diffs)
• Parser/lex.ll (modified) (3 diffs)
• Parser/parser.yy (modified) (11 diffs)
• ResolvExpr/CurrentObject.cc (modified) (3 diffs)
• ResolvExpr/Resolver.cc (modified) (3 diffs)
• SymTab/Validate.cc (modified) (4 diffs)
• SynTree/AggregateDecl.cc (modified) (2 diffs)
• SynTree/Declaration.cc (modified) (2 diffs)
• SynTree/Declaration.h (modified) (16 diffs)
• SynTree/Expression.h (modified) (65 diffs)
• SynTree/Initializer.cc (modified) (2 diffs)
• SynTree/Initializer.h (modified) (9 diffs)
• SynTree/NamedTypeDecl.cc (modified) (2 diffs)
• SynTree/Statement.h (modified) (26 diffs)
• SynTree/Type.cc (modified) (2 diffs)
• SynTree/Type.h (modified) (22 diffs)
• SynTree/TypeDecl.cc (modified) (2 diffs)
• SynTree/TypeExpr.cc (modified) (1 diff)
• Tuples/TupleExpansion.cc (modified) (6 diffs)
• Virtual/ExpandCasts.cc (modified) (4 diffs)
• driver/cfa.cc (modified) (4 diffs)
• include/cassert (moved) (moved from src/include/assert.h ) (2 diffs)
• libcfa/Makefile.am (modified) (1 diff)
• libcfa/Makefile.in (modified) (1 diff)
• libcfa/concurrency/monitor.c (modified) (2 diffs)
• libcfa/exception.c (modified) (9 diffs)
• libcfa/exception.h (modified) (4 diffs)
• libcfa/iostream (modified) (4 diffs)
• libcfa/iostream.c (modified) (3 diffs)
• libcfa/math (modified) (3 diffs)
• libcfa/stdhdr/assert.h (modified) (2 diffs)
• libcfa/stdlib (modified) (2 diffs)
• libcfa/stdlib.c (modified) (2 diffs)
• tests/.expect/32/math.txt (modified) (2 diffs)
• tests/.expect/64/math.txt (modified) (2 diffs)
• tests/.expect/div.txt (added)
• tests/designations.c (modified) (4 diffs)
• tests/div.c (added)
• tests/except-0.c (modified) (3 diffs)
• tests/except-1.c (added)
• tests/except-2.c (added)
• tests/math.c (modified) (3 diffs)

src/ControlStruct/ExceptTranslate.cc

@@ -10 +10 @@
 // Created On       : Wed Jun 14 16:49:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Tus Jul 18 10:09:00 2017
-// Update Count     : 4
+// Last Modified On : Tus Aug  8 16:54:00 2017
+// Update Count     : 7
 //
 
@@ -21 +21 @@
 #include "SynTree/Type.h"
 #include "SynTree/Attribute.h"
+#include "SynTree/VarExprReplacer.h"
 
 namespace ControlStruct {
 
-        // This (large) section could probably be moved out of the class
-        // and be static helpers instead.
-
-        // Type(Qualifiers &, false, std::list<Attribute *> &)
-
-        // void (*function)();
-        static FunctionType try_func_t(Type::Qualifiers(), false);
-        // void (*function)(int, exception);
-        static FunctionType catch_func_t(Type::Qualifiers(), false);
-        // int (*function)(exception);
-        static FunctionType match_func_t(Type::Qualifiers(), false);
-        // 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 bool init_complete = false;
-                if (init_complete) {
-                        return;
-                }
+        // Buricratic Helpers (Not having to do with the paritular operation.)
+
+        typedef std::list<CatchStmt*> CatchList;
+
+        void split( CatchList& allHandlers, CatchList& terHandlers,
+                                CatchList& resHandlers ) {
+                while ( !allHandlers.empty() ) {
+                        CatchStmt * stmt = allHandlers.front();
+                        allHandlers.pop_front();
+                        if (CatchStmt::Terminate == stmt->get_kind()) {
+                                terHandlers.push_back(stmt);
+                        } else {
+                                resHandlers.push_back(stmt);
+                        }
+                }
+        }
+
+        void appendDeclStmt( CompoundStmt * block, Declaration * item ) {
+                block->push_back(new DeclStmt(noLabels, item));
+        }
+
+        Expression * nameOf( DeclarationWithType * decl ) {
+                return new VariableExpr( decl );
+        }
+
+        class ExceptionMutatorCore : public WithGuards {
+                enum Context { NoHandler, TerHandler, ResHandler };
+
+                // Also need to handle goto, break & continue.
+                // They need to be cut off in a ResHandler, until we enter another
+                // loop, switch or the goto stays within the function.
+
+                Context cur_context;
+
+                // The current (innermost) termination handler exception declaration.
+                ObjectDecl * handler_except_decl;
+
+                // The built in types used in translation.
+                StructDecl * except_decl;
+                StructDecl * node_decl;
+                StructDecl * hook_decl;
+
+                // The many helper functions for code/syntree generation.
+                Statement * create_given_throw(
+                        const char * throwFunc, ThrowStmt * throwStmt );
+                Statement * create_terminate_throw( ThrowStmt * throwStmt );
+                Statement * create_terminate_rethrow( ThrowStmt * throwStmt );
+                Statement * create_resume_throw( ThrowStmt * throwStmt );
+                Statement * create_resume_rethrow( ThrowStmt * throwStmt );
+                CompoundStmt * take_try_block( TryStmt * tryStmt );
+                FunctionDecl * create_try_wrapper( CompoundStmt * body );
+                FunctionDecl * create_terminate_catch( CatchList &handlers );
+                CompoundStmt * create_single_matcher(
+                        DeclarationWithType * except_obj, CatchStmt * modded_handler );
+                FunctionDecl * create_terminate_match( CatchList &handlers );
+                CompoundStmt * create_terminate_caller( FunctionDecl * try_wrapper,
+                        FunctionDecl * terminate_catch, FunctionDecl * terminate_match );
+                FunctionDecl * create_resume_handler( CatchList &handlers );
+                CompoundStmt * create_resume_wrapper(
+                        Statement * wraps, FunctionDecl * resume_handler );
+                FunctionDecl * create_finally_wrapper( TryStmt * tryStmt );
+                ObjectDecl * create_finally_hook( FunctionDecl * finally_wrapper );
+
+                // Types used in translation, make sure to use clone.
+                // void (*function)();
+                FunctionType try_func_t;
+                // void (*function)(int, exception);
+                FunctionType catch_func_t;
+                // int (*function)(exception);
+                FunctionType match_func_t;
+                // bool (*function)(exception);
+                FunctionType handle_func_t;
+                // void (*function)(__attribute__((unused)) void *);
+                FunctionType finally_func_t;
+
+                StructInstType * create_except_type() {
+                        assert( except_decl );
+                        return new StructInstType( noQualifiers, except_decl );
+                }
+                void init_func_types();
+
+        public:
+                ExceptionMutatorCore() :
+                        cur_context( NoHandler ),
+                        handler_except_decl( nullptr ),
+                        except_decl( nullptr ), node_decl( nullptr ), hook_decl( nullptr ),
+                        try_func_t( noQualifiers, false ),
+                        catch_func_t( noQualifiers, false ),
+                        match_func_t( noQualifiers, false ),
+                        handle_func_t( noQualifiers, false ),
+                        finally_func_t( noQualifiers, false )
+                {}
+
+                void premutate( CatchStmt *catchStmt );
+                void premutate( StructDecl *structDecl );
+                Statement * postmutate( ThrowStmt *throwStmt );
+                Statement * postmutate( TryStmt *tryStmt );
+        };
+
+        void ExceptionMutatorCore::init_func_types() {
+                assert( except_decl );
+
                 ObjectDecl index_obj(
                         "__handler_index",
@@ -60 +142 @@
                         new PointerType(
                                 noQualifiers,
-                                new BasicType( noQualifiers, BasicType::SignedInt )
+                                new StructInstType( noQualifiers, except_decl )
                                 ),
                         /*init*/ NULL
@@ -69 +151 @@
                         LinkageSpec::Cforall,
                         /*bitfieldWidth*/ NULL,
-                        new BasicType(noQualifiers, BasicType::Bool),
+                        new BasicType( noQualifiers, BasicType::Bool ),
                         /*init*/ NULL
                         );
@@ -82 +164 @@
                                         noQualifiers
                                         ),
-                                std::list<Attribute *>{new Attribute("unused")}
+                                std::list<Attribute *>{ new Attribute( "unused" ) }
                                 ),
                         NULL
@@ -94 +176 @@
                 handle_func_t.get_parameters().push_back( exception_obj.clone() );
                 finally_func_t.get_parameters().push_back( voidptr_obj.clone() );
-
-                init_complete = true;
-        }
-
-        // Buricratic Helpers (Not having to do with the paritular operation.)
-
-        typedef std::list<CatchStmt*> CatchList;
-
-        void split( CatchList& allHandlers, CatchList& terHandlers,
-                                CatchList& resHandlers ) {
-                while ( !allHandlers.empty() ) {
-                        CatchStmt * stmt = allHandlers.front();
-                        allHandlers.pop_front();
-                        if (CatchStmt::Terminate == stmt->get_kind()) {
-                                terHandlers.push_back(stmt);
-                        } else {
-                                resHandlers.push_back(stmt);
-                        }
-                }
-        }
-
-        template<typename T>
-        void free_all( std::list<T *> &list ) {
-                typename std::list<T *>::iterator it;
-                for ( it = list.begin() ; it != list.end() ; ++it ) {
-                        delete *it;
-                }
-                list.clear();
-        }
-
-        void appendDeclStmt( CompoundStmt * block, Declaration * item ) {
-                block->push_back(new DeclStmt(noLabels, item));
-        }
-
-        Expression * nameOf( DeclarationWithType * decl ) {
-                return new VariableExpr( decl );
         }
 
         // ThrowStmt Mutation Helpers
 
-        Statement * create_given_throw(
+        Statement * ExceptionMutatorCore::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( noQualifiers, BasicType::SignedInt ),
-                        new SingleInit( throwStmt->get_expr() )
-                        );
-                appendDeclStmt( result, local );
+                // `throwFunc`( `throwStmt->get_name` );
                 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 ) );
+                call->get_args().push_back( throwStmt->get_expr() );
                 throwStmt->set_expr( nullptr );
                 delete throwStmt;
-                return result;
-        }
-
-        Statement * create_terminate_throw( ThrowStmt *throwStmt ) {
-                // { int NAME = EXPR; __throw_terminate( &NAME ); }
+                return new ExprStmt( noLabels, call );
+        }
+
+        Statement * ExceptionMutatorCore::create_terminate_throw(
+                        ThrowStmt *throwStmt ) {
+                // __throw_terminate( `throwStmt->get_name()` ); }
                 return create_given_throw( "__cfaehm__throw_terminate", throwStmt );
         }
-        Statement * create_terminate_rethrow( ThrowStmt *throwStmt ) {
-                // __rethrow_terminate();
+
+        Statement * ExceptionMutatorCore::create_terminate_rethrow(
+                        ThrowStmt *throwStmt ) {
+                // { `handler_except_decl` = NULL; __rethrow_terminate(); }
                 assert( nullptr == throwStmt->get_expr() );
-                Statement * result = new ExprStmt(
-                        throwStmt->get_labels(),
+                assert( handler_except_decl );
+
+                CompoundStmt * result = new CompoundStmt( throwStmt->get_labels() );
+                result->push_back( new ExprStmt( noLabels, UntypedExpr::createAssign(
+                        nameOf( handler_except_decl ),
+                        new ConstantExpr( Constant::null(
+                                new PointerType(
+                                        noQualifiers,
+                                        handler_except_decl->get_type()->clone()
+                                        )
+                                ) )
+                        ) ) );
+                result->push_back( new ExprStmt(
+                        noLabels,
                         new UntypedExpr( new NameExpr( "__cfaehm__rethrow_terminate" ) )
-                        );
+                        ) );
                 delete throwStmt;
                 return result;
         }
-        Statement * create_resume_throw( ThrowStmt *throwStmt ) {
-                // __throw_resume( EXPR );
+
+        Statement * ExceptionMutatorCore::create_resume_throw(
+                        ThrowStmt *throwStmt ) {
+                // __throw_resume( `throwStmt->get_name` );
                 return create_given_throw( "__cfaehm__throw_resume", throwStmt );
         }
-        Statement * create_resume_rethrow( ThrowStmt *throwStmt ) {
+
+        Statement * ExceptionMutatorCore::create_resume_rethrow(
+                        ThrowStmt *throwStmt ) {
                 // return false;
                 Statement * result = new ReturnStmt(
@@ -185 +239 @@
         // TryStmt Mutation Helpers
 
-        CompoundStmt * take_try_block( TryStmt *tryStmt ) {
+        CompoundStmt * ExceptionMutatorCore::take_try_block( TryStmt *tryStmt ) {
                 CompoundStmt * block = tryStmt->get_block();
                 tryStmt->set_block( nullptr );
                 return block;
         }
-        FunctionDecl * create_try_wrapper( CompoundStmt *body ) {
+
+        FunctionDecl * ExceptionMutatorCore::create_try_wrapper(
+                        CompoundStmt *body ) {
 
                 return new FunctionDecl( "try", Type::StorageClasses(),
@@ -196 +252 @@
         }
 
-        FunctionDecl * create_terminate_catch( CatchList &handlers ) {
+        FunctionDecl * ExceptionMutatorCore::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();
+                DeclarationWithType * except_obj = func_type->get_parameters().back();
 
                 // Index 1..{number of handlers}
@@ -210 +267 @@
                         CatchStmt * handler = *it;
 
-                        // INTEGERconstant Version
                         // case `index`:
                         // {
-                        //     `handler.body`
+                        //     `handler.decl` = { (virtual `decl.type`)`except` };
+                        //     `handler.body`;
                         // }
                         // return;
-                        std::list<Statement *> caseBody;
-                        caseBody.push_back( handler->get_body() );
+                        CompoundStmt * block = new CompoundStmt( noLabels );
+
+                        // Just copy the exception value. (Post Validation)
+                        ObjectDecl * handler_decl =
+                                static_cast<ObjectDecl *>( handler->get_decl() );
+                        ObjectDecl * local_except = handler_decl->clone();
+                        local_except->set_init(
+                                new ListInit({ new SingleInit(
+                                        new VirtualCastExpr( nameOf( except_obj ),
+                                                local_except->get_type()
+                                                )
+                                        ) })
+                                );
+                        block->push_back( new DeclStmt( noLabels, local_except ) );
+
+                        // Add the cleanup attribute.
+                        local_except->get_attributes().push_back( new Attribute(
+                                "cleanup",
+                                { new NameExpr( "__cfaehm__cleanup_terminate" ) }
+                                ) );
+
+                        // Update variables in the body to point to this local copy.
+                        {
+                                VarExprReplacer::DeclMap mapping;
+                                mapping[ handler_decl ] = local_except;
+                                VarExprReplacer mapper( mapping );
+                                handler->get_body()->accept( mapper );
+                        }
+
+                        block->push_back( handler->get_body() );
                         handler->set_body( nullptr );
-                        caseBody.push_back( new ReturnStmt( noLabels, nullptr ) );
-
+
+                        std::list<Statement *> caseBody
+                                        { block, new ReturnStmt( noLabels, nullptr ) };
                         handler_wrappers.push_back( new CaseStmt(
                                 noLabels,
@@ -249 +335 @@
         // Create a single check from a moddified handler.
         // except_obj is referenced, modded_handler will be freed.
-        CompoundStmt *create_single_matcher(
+        CompoundStmt * ExceptionMutatorCore::create_single_matcher(
                         DeclarationWithType * except_obj, CatchStmt * modded_handler ) {
+                // {
+                //     `modded_handler.decl`
+                //     if ( `decl.name = (virtual `decl.type`)`except`
+                //             [&& `modded_handler.cond`] ) {
+                //         `modded_handler.body`
+                //     }
+                // }
+
                 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 );
-                }
-
+                // Local Declaration
+                ObjectDecl * local_except =
+                        dynamic_cast<ObjectDecl *>( modded_handler->get_decl() );
+                assert( local_except );
+                block->push_back( new DeclStmt( noLabels, local_except ) );
+
+                // Check for type match.
+                Expression * cond = UntypedExpr::createAssign( nameOf( local_except ),
+                        new VirtualCastExpr( nameOf( except_obj ),
+                                local_except->get_type()->clone() ) );
+
+                // Add the check on the conditional if it is provided.
                 if ( modded_handler->get_cond() ) {
                         cond = new LogicalExpr( cond, modded_handler->get_cond() );
                 }
+                // Construct the match condition.
                 block->push_back( new IfStmt( noLabels,
                         cond, modded_handler->get_body(), nullptr ) );
@@ -287 +373 @@
         }
 
-        FunctionDecl * create_terminate_match( CatchList &handlers ) {
+        FunctionDecl * ExceptionMutatorCore::create_terminate_match(
+                        CatchList &handlers ) {
+                // int match(exception * except) {
+                //     HANDLER WRAPPERS { return `index`; }
+                // }
+
                 CompoundStmt * body = new CompoundStmt( noLabels );
 
@@ -319 +410 @@
         }
 
-        CompoundStmt * create_terminate_caller(
+        CompoundStmt * ExceptionMutatorCore::create_terminate_caller(
                         FunctionDecl * try_wrapper,
                         FunctionDecl * terminate_catch,
-                        FunctionDecl * terminate_match) {
+                        FunctionDecl * terminate_match ) {
+                // { __cfaehm__try_terminate(`try`, `catch`, `match`); }
 
                 UntypedExpr * caller = new UntypedExpr( new NameExpr(
@@ -336 +428 @@
         }
 
-        FunctionDecl * create_resume_handler( CatchList &handlers ) {
+        FunctionDecl * ExceptionMutatorCore::create_resume_handler(
+                        CatchList &handlers ) {
+                // bool handle(exception * except) {
+                //     HANDLER WRAPPERS { `hander->body`; return true; }
+                // }
                 CompoundStmt * body = new CompoundStmt( noLabels );
 
@@ -369 +465 @@
         }
 
-        CompoundStmt * create_resume_wrapper(
-                        StructDecl * node_decl,
+        CompoundStmt * ExceptionMutatorCore::create_resume_wrapper(
                         Statement * wraps,
                         FunctionDecl * resume_handler ) {
@@ -414 +509 @@
         }
 
-        FunctionDecl * create_finally_wrapper( TryStmt * tryStmt ) {
+        FunctionDecl * ExceptionMutatorCore::create_finally_wrapper(
+                        TryStmt * tryStmt ) {
+                // void finally() { <finally code> }
                 FinallyStmt * finally = tryStmt->get_finally();
                 CompoundStmt * body = finally->get_block();
@@ -425 +522 @@
         }
 
-        ObjectDecl * create_finally_hook(
-                        StructDecl * hook_decl, FunctionDecl * finally_wrapper ) {
+        ObjectDecl * ExceptionMutatorCore::create_finally_hook(
+                        FunctionDecl * finally_wrapper ) {
                 // struct __cfaehm__cleanup_hook __finally_hook
                 //      __attribute__((cleanup( finally_wrapper )));
@@ -452 +549 @@
         }
 
-
-        class ExceptionMutatorCore : public WithGuards {
-                enum Context { NoHandler, TerHandler, ResHandler };
-
-                // Also need to handle goto, break & continue.
-                // They need to be cut off in a ResHandler, until we enter another
-                // loop, switch or the goto stays within the function.
-
-                Context cur_context;
-
-                // We might not need this, but a unique base for each try block's
-                // generated functions might be nice.
-                //std::string curFunctionName;
-                //unsigned int try_count = 0;
-
-                StructDecl *node_decl;
-                StructDecl *hook_decl;
-
-        public:
-                ExceptionMutatorCore() :
-                        cur_context(NoHandler),
-                        node_decl(nullptr), hook_decl(nullptr)
-                {}
-
-                void premutate( CatchStmt *catchStmt );
-                void premutate( StructDecl *structDecl );
-                Statement * postmutate( ThrowStmt *throwStmt );
-                Statement * postmutate( TryStmt *tryStmt );
-        };
+        // Visiting/Mutating Functions
+        void ExceptionMutatorCore::premutate( CatchStmt *catchStmt ) {
+                // Validate the Statement's form.
+                ObjectDecl * decl =
+                        dynamic_cast<ObjectDecl *>( catchStmt->get_decl() );
+                if ( decl && true /* check decl->get_type() */ ) {
+                        // Pass.
+                } else if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
+                        throw SemanticError("catch must have exception type");
+                } else {
+                        throw SemanticError("catchResume must have exception type");
+                }
+
+                // Track the handler context.
+                GuardValue( cur_context );
+                if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
+                        cur_context = TerHandler;
+
+                        GuardValue( handler_except_decl );
+                        handler_except_decl = decl;
+                } else {
+                        cur_context = ResHandler;
+                }
+        }
+
+        void ExceptionMutatorCore::premutate( StructDecl *structDecl ) {
+                if ( !structDecl->has_body() ) {
+                        // Skip children?
+                        return;
+                } else if ( structDecl->get_name() == "__cfaehm__base_exception_t" ) {
+                        assert( nullptr == except_decl );
+                        except_decl = structDecl;
+                        init_func_types();
+                } 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.
+        }
 
         Statement * ExceptionMutatorCore::postmutate( ThrowStmt *throwStmt ) {
+                assert( except_decl );
+
                 // Ignoring throwStmt->get_target() for now.
                 if ( ThrowStmt::Terminate == throwStmt->get_kind() ) {
@@ -510 +622 @@
 
         Statement * ExceptionMutatorCore::postmutate( TryStmt *tryStmt ) {
+                assert( except_decl );
                 assert( node_decl );
                 assert( hook_decl );
@@ -524 +637 @@
                         appendDeclStmt( block, finally_block );
                         // Create and add the finally cleanup hook.
-                        appendDeclStmt( block,
-                                create_finally_hook( hook_decl, finally_block ) );
+                        appendDeclStmt( block, create_finally_hook( finally_block ) );
                 }
 
@@ -539 +651 @@
                         appendDeclStmt( block, resume_handler );
                         // Prepare hooks
-                        inner = create_resume_wrapper( node_decl, inner, resume_handler );
+                        inner = create_resume_wrapper( inner, resume_handler );
                 }
 
@@ -560 +672 @@
                 block->push_back( inner );
 
-                //free_all( termination_handlers );
-                //free_all( resumption_handlers );
-
                 return block;
         }
 
-        void ExceptionMutatorCore::premutate( CatchStmt *catchStmt ) {
-                GuardValue( cur_context );
-                if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
-                        cur_context = TerHandler;
-                } else {
-                        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;
                 mutateAll( translationUnit, translator );

src/GenPoly/Box.cc

@@ -27 +27 @@
 #include "Box.h"
 #include "DeclMutator.h"
+#include "Lvalue.h"
+#include "FindFunction.h"
 #include "PolyMutator.h"
-#include "FindFunction.h"
 #include "ScopedSet.h"
 #include "ScrubTyVars.h"
@@ -755 +756 @@
 
                 void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
-                        assert( arg->has_result() );
+                        assertf( arg->has_result(), "arg does not have result: %s", toString( arg ).c_str() );
                         if ( isPolyType( param, exprTyVars ) ) {
-                                if ( isPolyType( arg->get_result() ) ) {
+                                Type * newType = arg->get_result()->clone();
+                                if ( env ) env->apply( newType );
+                                std::auto_ptr<Type> manager( newType );
+                                if ( isPolyType( newType ) ) {
                                         // if the argument's type is polymorphic, we don't need to box again!
                                         return;
                                 } else if ( arg->get_result()->get_lvalue() ) {
-                                        // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
-                                        // xxx - need to test that this code is still reachable
-                                        if ( CommaExpr *commaArg = dynamic_cast< CommaExpr* >( arg ) ) {
-                                                commaArg->set_arg2( new AddressExpr( commaArg->get_arg2() ) );
-                                        } else {
-                                                arg = new AddressExpr( arg );
-                                        }
+                                        // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
+                                        arg =  generalizedLvalue( new AddressExpr( arg ) );
                                         if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
                                                 // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
@@ -1879 +1878 @@
                         return structDecl;
                 }
-                
+
                 Declaration *Pass3::mutate( UnionDecl *unionDecl ) {
                         stripGenericMembers( unionDecl );

src/GenPoly/Lvalue.cc

@@ -27 +27 @@
 #include "SynTree/Mutator.h"
 #include "SymTab/Indexer.h"
+
 #include "ResolvExpr/Resolver.h"
+#include "ResolvExpr/TypeEnvironment.h"
 #include "ResolvExpr/typeops.h"
+#include "ResolvExpr/Unify.h"
 
 #include "Common/UniqueName.h"
@@ -60 +63 @@
                         typedef Mutator Parent;
 
+                        virtual Expression * mutate( MemberExpr * memExpr );
                         virtual Expression * mutate( AddressExpr * addressExpr );
+
+                        template<typename Func>
+                        Expression * applyTransformation( Expression * expr, Expression * arg, Func mkExpr );
                 };
         } // namespace
@@ -71 +78 @@
                 acceptAll( translationUnit, p2 );
                 mutateAll( translationUnit, genLval );
+        }
+
+        Expression * generalizedLvalue( Expression * expr ) {
+                GeneralizedLvalue genLval;
+                return expr->acceptMutator( genLval );
         }
 
@@ -163 +175 @@
                 }
 
-                Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
-                        addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
-                        if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( addrExpr->get_arg() ) ) {
+                template<typename Func>
+                Expression * GeneralizedLvalue::applyTransformation( Expression * expr, Expression * arg, Func mkExpr ) {
+                        if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( arg ) ) {
                                 Expression * arg1 = commaExpr->get_arg1()->clone();
                                 Expression * arg2 = commaExpr->get_arg2()->clone();
-                                delete addrExpr;
-                                return new CommaExpr( arg1, new AddressExpr( arg2 ) );
-                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( addrExpr->get_arg() ) ) {
+                                Expression * ret = new CommaExpr( arg1, mkExpr( arg2 ) );
+                                ret->set_env( expr->get_env() );
+                                expr->set_env( nullptr );
+                                delete expr;
+                                return ret->acceptMutator( *this );
+                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( arg ) ) {
                                 Expression * arg1 = condExpr->get_arg1()->clone();
                                 Expression * arg2 = condExpr->get_arg2()->clone();
                                 Expression * arg3 = condExpr->get_arg3()->clone();
-                                delete addrExpr;
-                                return new ConditionalExpr( arg1, new AddressExpr( arg2 ), new AddressExpr( arg3 ) );
+                                ConditionalExpr * ret = new ConditionalExpr( arg1, mkExpr( arg2 ), mkExpr( arg3 ) );
+                                ret->set_env( expr->get_env() );
+                                expr->set_env( nullptr );
+                                delete expr;
+
+                                // conditional expr type may not be either of the argument types, need to unify
+                                using namespace ResolvExpr;
+                                Type* commonType = nullptr;
+                                TypeEnvironment newEnv;
+                                AssertionSet needAssertions, haveAssertions;
+                                OpenVarSet openVars;
+                                unify( ret->get_arg2()->get_result(), ret->get_arg3()->get_result(), newEnv, needAssertions, haveAssertions, openVars, SymTab::Indexer(), commonType );
+                                ret->set_result( commonType ? commonType : ret->get_arg2()->get_result()->clone() );
+                                return ret->acceptMutator( *this );
                         }
-                        return addrExpr;
+                        return expr;
+                }
+
+                Expression * GeneralizedLvalue::mutate( MemberExpr * memExpr ) {
+                        Parent::mutate( memExpr );
+                        return applyTransformation( memExpr, memExpr->get_aggregate(), [=]( Expression * aggr ) { return new MemberExpr( memExpr->get_member(), aggr ); } );
+                }
+
+                Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
+                        addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
+                        return applyTransformation( addrExpr, addrExpr->get_arg(), []( Expression * arg ) { return new AddressExpr( arg ); } );
                 }
         } // namespace

src/GenPoly/Lvalue.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Lvalue.h -- 
+// Lvalue.h --
 //
 // Author           : Richard C. Bilson
@@ -23 +23 @@
         /// replaces return type of `lvalue T` with `T*`, along with appropriate address-of and dereference operators
         void convertLvalue( std::list< Declaration* >& translationUnit );
+
+        /// applies transformations that allow GCC to accept more complicated lvalue expressions, e.g. &(a, b)
+        Expression * generalizedLvalue( Expression * expr );
 } // namespace GenPoly
 

src/Makefile.am

@@ -43 +43 @@
 cfa_cpplib_PROGRAMS = driver/cfa-cpp
 driver_cfa_cpp_SOURCES = ${SRC}
-driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
+driver_cfa_cpp_LDADD = -ldl                     # yywrap
 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14
 driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic

src/Makefile.in

@@ -262 +262 @@
 am_driver_cfa_cpp_OBJECTS = $(am__objects_1)
 driver_cfa_cpp_OBJECTS = $(am_driver_cfa_cpp_OBJECTS)
-am__DEPENDENCIES_1 =
-driver_cfa_cpp_DEPENDENCIES = $(am__DEPENDENCIES_1)
+driver_cfa_cpp_DEPENDENCIES =
 driver_cfa_cpp_LINK = $(CXXLD) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) \
         $(driver_cfa_cpp_LDFLAGS) $(LDFLAGS) -o $@
@@ -548 +547 @@
 cfa_cpplibdir = ${CFA_LIBDIR}
 driver_cfa_cpp_SOURCES = ${SRC}
-driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
+driver_cfa_cpp_LDADD = -ldl                     # yywrap
 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14
 driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic

src/Parser/ExpressionNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Tus Jul 25 10:11:00 2017
-// Update Count     : 551
-//
-
-#include <cassert>
-#include <cctype>
-#include <climits>
-#include <cstdio>
-#include <algorithm>
+// Last Modified On : Wed Aug  2 11:12:00 2017
+// Update Count     : 568
+//
+
+#include <climits>                                                                              // access INT_MAX, UINT_MAX, LONG_MAX, ULONG_MAX, LLONG_MAX
 #include <sstream>
 
@@ -26 +22 @@
 #include "SynTree/Expression.h"
 #include "SynTree/Declaration.h"
-#include "Common/UnimplementedError.h"
 #include "parserutility.h"
-#include "Common/utility.h"
 
 using namespace std;
@@ -46 +40 @@
 // type.
 
-Type::Qualifiers noQualifiers;                          // no qualifiers on constants
+extern const Type::Qualifiers noQualifiers;             // no qualifiers on constants
 
 static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
@@ -55 +49 @@
 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
 
-Expression *build_constantInteger( const std::string & str ) {
+Expression * build_constantInteger( const std::string & str ) {
         static const BasicType::Kind kind[2][3] = {
                 { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
@@ -62 +56 @@
         bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
         int size;                                                                                       // 0 => int, 1 => long, 2 => long long
-        unsigned long long int v;                                                               // converted integral value
+        unsigned long long int v;                                                       // converted integral value
         size_t last = str.length() - 1;                                         // last character of constant
-
+        Expression * ret;
+
+        // special constants
+        if ( str == "0" ) {
+                ret = new ConstantExpr( Constant( (Type *)new ZeroType( noQualifiers ), str, (unsigned long long int)0 ) );
+                goto CLEANUP;
+        } // if
+        if ( str == "1" ) {
+                ret = new ConstantExpr( Constant( (Type *)new OneType( noQualifiers ), str, (unsigned long long int)1 ) );
+                goto CLEANUP;
+        } // if
+        
         if ( str[0] == '0' ) {                                                          // octal/hex constant ?
                 dec = false;
@@ -118 +123 @@
         } // if
 
-        Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) );
+        ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) );
+  CLEANUP:
         delete &str;                                                                            // created by lex
         return ret;
 } // build_constantInteger
 
-Expression *build_constantFloat( const std::string & str ) {
+Expression * build_constantFloat( const std::string & str ) {
         static const BasicType::Kind kind[2][3] = {
                 { BasicType::Float, BasicType::Double, BasicType::LongDouble },
@@ -158 +164 @@
 } // build_constantFloat
 
-Expression *build_constantChar( const std::string & str ) {
+Expression * build_constantChar( const std::string & str ) {
         Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::Char ), str, (unsigned long long int)(unsigned char)str[1] ) );
         delete &str;                                                                            // created by lex
@@ -164 +170 @@
 } // build_constantChar
 
-ConstantExpr *build_constantStr( const std::string & str ) {
+ConstantExpr * build_constantStr( const std::string & str ) {
         // string should probably be a primitive type
-        ArrayType *at = new ArrayType( noQualifiers, new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ),
-                                                                   new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ),  // +1 for '\0' and -2 for '"'
+        ArrayType * at = new ArrayType( noQualifiers, new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ),
+                                                                   new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ), // +1 for '\0' and -2 for '"'
                                                                    false, false );
-        // constant 0 is ignored for pure string value
-        ConstantExpr * ret = new ConstantExpr( Constant( at, str, (unsigned long long int)0 ) );
+        ConstantExpr * ret = new ConstantExpr( Constant( at, str, (unsigned long long int)0 ) ); // constant 0 is ignored for pure string value
         delete &str;                                                                            // created by lex
         return ret;
 } // build_constantStr
-
-Expression *build_constantZeroOne( const std::string & str ) {
-        Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type *)new ZeroType( noQualifiers ) : (Type*)new OneType( noQualifiers ), str,
-                                                                                                   str == "0" ? (unsigned long long int)0 : (unsigned long long int)1 ) );
-        delete &str;                                                                            // created by lex
-        return ret;
-} // build_constantChar
 
 Expression * build_field_name_FLOATINGconstant( const std::string & str ) {
@@ -209 +207 @@
 } // build_field_name_fraction_constants
 
-
-
 Expression * build_field_name_REALFRACTIONconstant( const std::string & str ) {
         if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str );
@@ -225 +221 @@
 } // build_field_name_REALDECIMALconstant
 
-NameExpr * build_varref( const string *name ) {
-        NameExpr *expr = new NameExpr( *name, nullptr );
+NameExpr * build_varref( const string * name ) {
+        NameExpr * expr = new NameExpr( *name, nullptr );
         delete name;
         return expr;
-}
-
-// Must harmonize with OperKinds.
-static const char *OperName[] = {
+} // build_varref
+
+
+static const char * OperName[] = {                                              // must harmonize with OperKinds
         // diadic
         "SizeOf", "AlignOf", "OffsetOf", "?+?", "?-?", "?\\?", "?*?", "?/?", "?%?", "||", "&&",
@@ -240 +236 @@
         // monadic
         "+?", "-?", "AddressOf", "*?", "!?", "~?", "++?", "?++", "--?", "?--", "&&"
-};
-
-Expression *build_cast( DeclarationNode *decl_node, ExpressionNode *expr_node ) {
-        Type *targetType = maybeMoveBuildType( decl_node );
+}; // OperName
+
+Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {
+        Type * targetType = maybeMoveBuildType( decl_node );
         if ( dynamic_cast< VoidType * >( targetType ) ) {
                 delete targetType;
@@ -250 +246 @@
                 return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType );
         } // if
-}
-
-
-Expression *build_virtual_cast( DeclarationNode *decl_node, ExpressionNode *expr_node ) {
-        Type *targetType = maybeMoveBuildType( decl_node );
-        Expression *castArg = maybeMoveBuild< Expression >( expr_node );
+} // build_cast
+
+Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {
+        Type * targetType = maybeMoveBuildType( decl_node );
+        Expression * castArg = maybeMoveBuild< Expression >( expr_node );
         return new VirtualCastExpr( castArg, targetType );
-}
-
-Expression *build_fieldSel( ExpressionNode *expr_node, Expression *member ) {
-        UntypedMemberExpr *ret = new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) );
-        return ret;
-}
-
-Expression *build_pfieldSel( ExpressionNode *expr_node, Expression *member ) {
-        UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+} // build_virtual_cast
+
+Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member ) {
+        UntypedMemberExpr * ret = new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) );
+        return ret;
+} // build_fieldSel
+
+Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member ) {
+        UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
         deref->location = expr_node->location;
         deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) );
-        UntypedMemberExpr *ret = new UntypedMemberExpr( member, deref );
-        return ret;
-}
-
-Expression *build_addressOf( ExpressionNode *expr_node ) {
+        UntypedMemberExpr * ret = new UntypedMemberExpr( member, deref );
+        return ret;
+} // build_pfieldSel
+
+Expression * build_addressOf( ExpressionNode * expr_node ) {
                 return new AddressExpr( maybeMoveBuild< Expression >(expr_node) );
-}
-Expression *build_sizeOfexpr( ExpressionNode *expr_node ) {
+} // build_addressOf
+
+Expression * build_sizeOfexpr( ExpressionNode * expr_node ) {
         return new SizeofExpr( maybeMoveBuild< Expression >(expr_node) );
-}
-Expression *build_sizeOftype( DeclarationNode *decl_node ) {
+} // build_sizeOfexpr
+
+Expression * build_sizeOftype( DeclarationNode * decl_node ) {
         return new SizeofExpr( maybeMoveBuildType( decl_node ) );
-}
-Expression *build_alignOfexpr( ExpressionNode *expr_node ) {
+} // build_sizeOftype
+
+Expression * build_alignOfexpr( ExpressionNode * expr_node ) {
         return new AlignofExpr( maybeMoveBuild< Expression >(expr_node) );
-}
-Expression *build_alignOftype( DeclarationNode *decl_node ) {
+} // build_alignOfexpr
+
+Expression * build_alignOftype( DeclarationNode * decl_node ) {
         return new AlignofExpr( maybeMoveBuildType( decl_node) );
-}
-Expression *build_offsetOf( DeclarationNode *decl_node, NameExpr *member ) {
+} // build_alignOftype
+
+Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member ) {
         Expression * ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
         delete member;
         return ret;
-}
-
-Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind ) {
+} // build_offsetOf
+
+Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind ) {
         return new LogicalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), notZeroExpr( maybeMoveBuild< Expression >(expr_node2) ), kind );
-}
-
-Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node ) {
+} // build_and_or
+
+Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node ) {
         std::list< Expression * > args;
         args.push_back( maybeMoveBuild< Expression >(expr_node) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
-}
-Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node ) {
+} // build_unary_val
+
+Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node ) {
         std::list< Expression * > args;
         args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node) ) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
-}
-Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
+} // build_unary_ptr
+
+Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
         std::list< Expression * > args;
         args.push_back( maybeMoveBuild< Expression >(expr_node1) );
         args.push_back( maybeMoveBuild< Expression >(expr_node2) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
-}
-Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
+} // build_binary_val
+
+Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
         std::list< Expression * > args;
         args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node1) ) );
         args.push_back( maybeMoveBuild< Expression >(expr_node2) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
-}
-
-Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 ) {
+} // build_binary_ptr
+
+Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 ) {
         return new ConditionalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), maybeMoveBuild< Expression >(expr_node2), maybeMoveBuild< Expression >(expr_node3) );
-}
-
-Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
+} // build_cond
+
+Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
         return new CommaExpr( maybeMoveBuild< Expression >(expr_node1), maybeMoveBuild< Expression >(expr_node2) );
-}
-
-Expression *build_attrexpr( NameExpr *var, ExpressionNode * expr_node ) {
+} // build_comma
+
+Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node ) {
         return new AttrExpr( var, maybeMoveBuild< Expression >(expr_node) );
-}
-Expression *build_attrtype( NameExpr *var, DeclarationNode * decl_node ) {
+} // build_attrexpr
+
+Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node ) {
         return new AttrExpr( var, maybeMoveBuildType( decl_node ) );
-}
-
-Expression *build_tuple( ExpressionNode * expr_node ) {
+} // build_attrtype
+
+Expression * build_tuple( ExpressionNode * expr_node ) {
         std::list< Expression * > exprs;
         buildMoveList( expr_node, exprs );
         return new UntypedTupleExpr( exprs );;
-}
-
-Expression *build_func( ExpressionNode * function, ExpressionNode * expr_node ) {
+} // build_tuple
+
+Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node ) {
         std::list< Expression * > args;
         buildMoveList( expr_node, args );
         return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr );
-}
-
-Expression *build_range( ExpressionNode * low, ExpressionNode *high ) {
+} // build_func
+
+Expression * build_range( ExpressionNode * low, ExpressionNode * high ) {
         return new RangeExpr( maybeMoveBuild< Expression >( low ), maybeMoveBuild< Expression >( high ) );
-}
-
-Expression *build_asmexpr( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand ) {
+} // build_range
+
+Expression * build_asmexpr( ExpressionNode * inout, ConstantExpr * constraint, ExpressionNode * operand ) {
         return new AsmExpr( maybeMoveBuild< Expression >( inout ), constraint, maybeMoveBuild< Expression >(operand) );
-}
-
-Expression *build_valexpr( StatementNode *s ) {
+} // build_asmexpr
+
+Expression * build_valexpr( StatementNode * s ) {
         return new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(s) ) );
-}
-Expression *build_typevalue( DeclarationNode *decl ) {
+} // build_valexpr
+
+Expression * build_typevalue( DeclarationNode * decl ) {
         return new TypeExpr( maybeMoveBuildType( decl ) );
-}
-
-Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids ) {
+} // build_typevalue
+
+Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids ) {
         Declaration * newDecl = maybeBuild< Declaration >(decl_node); // compound literal type
         if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
@@ -388 +393 @@
                 assert( false );
         } // if
-}
+} // build_compoundLiteral
 
 // Local Variables: //

src/Parser/InitializerNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:20:24 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Oct  1 23:09:51 2016
-// Update Count     : 21
+// Last Modified On : Fri Jul 28 23:27:20 2017
+// Update Count     : 26
 //
 
@@ -22 +22 @@
 #include "SynTree/Initializer.h"
 
-InitializerNode::InitializerNode( ExpressionNode *_expr, bool aggrp, ExpressionNode *des )
-                : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
+InitializerNode::InitializerNode( ExpressionNode * _expr, bool aggrp, ExpressionNode * des )
+                : expr( _expr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ) {
         if ( aggrp )
                 kids = dynamic_cast< InitializerNode * >( get_next() );
 
-        if ( kids != 0 )
-                set_last( 0 );
-}
+        if ( kids )
+                set_last( nullptr );
+} // InitializerNode::InitializerNode
 
-InitializerNode::InitializerNode( InitializerNode *init, bool aggrp, ExpressionNode *des )
-                : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
-        if ( init != 0 )
+InitializerNode::InitializerNode( InitializerNode * init, bool aggrp, ExpressionNode * des )
+                : expr( nullptr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ) {
+        if ( init )
                 set_last( init );
 
@@ -39 +39 @@
                 kids = dynamic_cast< InitializerNode * >( get_next() );
 
-        if ( kids != 0 )
-                set_next( 0 );
-}
+        if ( kids )
+                set_next( nullptr );
+} // InitializerNode::InitializerNode
 
 InitializerNode::~InitializerNode() {
@@ -47 +47 @@
         delete designator;
         delete kids;
-}
+} // InitializerNode::~InitializerNode
 
 void InitializerNode::print( std::ostream &os, int indent ) const {
         os << std::string( indent, ' ' ) << "Initializer expression" << std::endl;
-}
+} // InitializerNode::print
 
 void InitializerNode::printOneLine( std::ostream &os ) const {
         if ( ! aggregate ) {
-                if ( designator != 0 ) {
+                if ( designator ) {
                         os << "designated by: (";
                         ExpressionNode *curdes = designator;
-                        while ( curdes != 0) {
+                        while ( curdes != nullptr) {
                                 curdes->printOneLine(os);
                                 curdes = (ExpressionNode *)(curdes->get_next());
@@ -65 +65 @@
                         os << ")";
                 } // if
-                if ( expr ) expr->printOneLine(os);
+                if ( expr ) expr->printOneLine( os );
         } else {  // It's an aggregate
                 os << "[--";
-                if ( next_init() != 0 )
-                        next_init()->printOneLine(os);
+                if ( next_init() != nullptr )
+                        next_init()->printOneLine( os );
                 if (aggregate) os << "--]";
         } // if
@@ -76 +76 @@
         if ( (moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) ) {
                 moreInit->printOneLine( os );
-        }
-}
+        } // if
+} // InitializerNode::printOneLine
 
-Initializer *InitializerNode::build() const {
+Initializer * InitializerNode::build() const {
         if ( aggregate ) {
                 // steal designators from children
@@ -93 +93 @@
                 return new ListInit( initlist, designlist, maybeConstructed );
         } else {
-                if ( get_expression() != 0) {
+                if ( get_expression() ) {
                         return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed );
-                }
+                } // if
         } // if
-        return 0;
-}
+        return nullptr;
+} // InitializerNode::build
 
 // Local Variables: //

src/Parser/ParseNode.h

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:28:16 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Tus Jul 25 10:09:00 2017
-// Update Count     : 787
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Jul 27 12:08:08 2017
+// Update Count     : 788
 //
 
@@ -159 +159 @@
 Expression * build_constantFloat( const std::string &str );
 Expression * build_constantChar( const std::string &str );
-Expression * build_constantZeroOne( const std::string &str );
 ConstantExpr * build_constantStr( const std::string &str );
 Expression * build_field_name_FLOATINGconstant( const std::string & str );

src/Parser/TypeData.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Tus Jul 18 10:10:00 2017
-// Update Count     : 566
+// Last Modified On : Wed Aug  9 13:50:00 2017
+// Update Count     : 567
 //
 
@@ -748 +748 @@
 } // buildAggInst
 
-NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, Type::StorageClasses scs ) {
+NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ) {
         assert( td->kind == TypeData::Symbolic );
         NamedTypeDecl * ret;
         assert( td->base );
         if ( td->symbolic.isTypedef ) {
-                ret = new TypedefDecl( name, scs, typebuild( td->base ) );
+                ret = new TypedefDecl( name, scs, typebuild( td->base ), linkage );
         } else {
                 ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Any );
@@ -817 +817 @@
                 return buildEnum( td, attributes );
         } else if ( td->kind == TypeData::Symbolic ) {
-                return buildSymbolic( td, name, scs );
+                return buildSymbolic( td, name, scs, linkage );
         } else {
                 return (new ObjectDecl( name, scs, linkage, bitfieldWidth, typebuild( td ), init, attributes ))->set_asmName( asmName );

src/Parser/lex.ll

@@ -10 +10 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Mon Jul 24 08:27:23 2017
- * Update Count     : 545
+ * Last Modified On : Thu Jul 27 21:46:06 2017
+ * Update Count     : 550
  */
 
 %option yylineno
+%option noyywrap
 %option nounput
 
@@ -288 +289 @@
 
                                 /* numeric constants */
-"0"                             { NUMERIC_RETURN(ZERO); }                               // CFA
-"1"                             { NUMERIC_RETURN(ONE); }                                // CFA
 {decimal_constant} { NUMERIC_RETURN(INTEGERconstant); }
 {octal_constant} { NUMERIC_RETURN(INTEGERconstant); }
@@ -420 +419 @@
 
                                 /* unknown characters */
-.                       { printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
+.                               { printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
 
 %%

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Andrew Beach
-// Last Modified On : Tus Jul 25 10:07:00 2017
-// Update Count     : 2464
+// Last Modified On : Wed Aug  4 13:33:00 2017
+// Update Count     : 2475
 //
 
@@ -142 +142 @@
 // converted into the tuple index (.)(1). e.g., 3.x
 %token<tok>     REALDECIMALconstant     REALFRACTIONconstant    FLOATINGconstant
-%token<tok> ZERO                                ONE                                             // CFA
 
 // multi-character operators
@@ -159 +158 @@
 %token ATassign                                                                                 // @=
 
-%type<tok> identifier  no_attr_identifier  zero_one
+%type<tok> identifier  no_attr_identifier
 %type<tok> identifier_or_type_name  no_attr_identifier_or_type_name  attr_name
 %type<constant> string_literal
@@ -183 +182 @@
 %type<en> asm_clobbers_list_opt
 %type<flag> asm_volatile_opt
+%type<en> handler_predicate_opt
 
 // statements
@@ -360 +360 @@
         ;
 
-zero_one:                                                                                               // CFA
-        ZERO
-        | ONE
-        ;
-
 string_literal:
         string_literal_list                                                     { $$ = build_constantStr( *$1 ); }
@@ -384 +379 @@
         IDENTIFIER                                                                                      // typedef name cannot be used as a variable name
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
-        | zero_one
-                { $$ = new ExpressionNode( build_constantZeroOne( *$1 ) ); }
         | tuple
         | '(' comma_expression ')'
@@ -485 +478 @@
                         $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
                 }
-        | zero_one fraction_constants
-                {
-                        $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantZeroOne( *$1 ), $2 ) );
-                }
         ;
 
@@ -539 +528 @@
         | ALIGNOF unary_expression                                                      // GCC, variable alignment
                 { $$ = new ExpressionNode( build_alignOfexpr( $2 ) ); }
-        | ALIGNOF '(' type_no_function ')'                              // GCC, type alignment
+        | ALIGNOF '(' type_no_function ')'                                      // GCC, type alignment
                 { $$ = new ExpressionNode( build_alignOftype( $3 ) ); }
         | OFFSETOF '(' type_no_function ',' no_attr_identifier ')'
@@ -980 +969 @@
 
 handler_clause:
-        // TEMPORARY, TEST EXCEPTIONS
-        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 handler_predicate_opt ')' compound_statement pop
-                { $$ = new StatementNode( build_catch( $1, $5, nullptr, $9 ) ); }
+        handler_key '(' push push exception_declaration pop handler_predicate_opt ')' compound_statement pop
+                { $$ = new StatementNode( build_catch( $1, $5, $7, $9 ) ); }
         | handler_clause handler_key '(' push push exception_declaration pop handler_predicate_opt ')' compound_statement pop
-                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $6, nullptr, $10 ) ) ); }
+                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $6, $8, $10 ) ) ); }
         ;
 
 handler_predicate_opt:
         //empty
+                { $$ = nullptr; }
         | ';' conditional_expression
+                { $$ = $2; }
         ;
 
@@ -1686 +1671 @@
         | aggregate_key attribute_list_opt typegen_name         // CFA
                 { $$ = $3->addQualifiers( $2 ); }
-
-// Temp, testing TreeStruct
-    | STRUCT TRY attribute_list_opt no_attr_identifier_or_type_name
-        {
-            typedefTable.makeTypedef( *$4 );            // create typedef
-            if ( forall ) typedefTable.changeKind( *$4, TypedefTable::TG ); // $
-            forall = false;                             // reset
-        }
-      '{' field_declaration_list '}'
-        {
-            $$ = DeclarationNode::newTreeStruct( DeclarationNode::Struct,
-                $4, nullptr, nullptr, $7, true )->addQualifiers( $3 );
-        }
-    | STRUCT TRY attribute_list_opt no_attr_identifier_or_type_name TYPEDEFname
-        {
-            typedefTable.makeTypedef( *$4 );            // create typedef
-            if ( forall ) typedefTable.changeKind( *$4, TypedefTable::TG ); // $
-            forall = false;                             // reset
-        }
-      '{' field_declaration_list '}'
-        {
-            $$ = DeclarationNode::newTreeStruct( DeclarationNode::Struct,
-                $4, $5, nullptr, $8, true )->addQualifiers( $3 );
-        }
         ;
 
@@ -1969 +1930 @@
         | '=' initializer
                 { $$ = $2; }
+        | '=' VOID
+                { $$ = nullptr; }
         | ATassign initializer
                 { $$ = $2->set_maybeConstructed( false ); }

src/ResolvExpr/CurrentObject.cc

@@ -36 +36 @@
                                 return constExpr->get_constant()->get_ival();
                         } else {
-                                assertf( false, "Non-integer constant expression in getConstValue", toString( constExpr ).c_str() ); // xxx - might be semantic error
+                                assertf( false, "Non-integer constant expression in getConstValue %s", toString( constExpr ).c_str() ); // xxx - might be semantic error
                         }
                 } else if ( dynamic_cast< OneType * >( constExpr->get_result() ) ) {
@@ -176 +176 @@
                                 setPosition( castExpr->get_arg() );
                         } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
-                                assertf( dynamic_cast<EnumInstType *> ( varExpr->get_result() ), "ArrayIterator given variable that isn't an enum constant", toString( expr ).c_str() );
+                                assertf( dynamic_cast<EnumInstType *> ( varExpr->get_result() ), "ArrayIterator given variable that isn't an enum constant : %s", toString( expr ).c_str() );
                                 index = 0; // xxx - get actual value of enum constant
                         } else if ( dynamic_cast< SizeofExpr * >( expr ) || dynamic_cast< AlignofExpr * >( expr ) ) {
@@ -518 +518 @@
                         curTypes = newTypes;
                         newTypes.clear();
-                        assertf( desigAlts.size() == curTypes.size(), "Designator alternatives (%d) and current types (%d) out of sync", desigAlts.size(), curTypes.size() );
+                        assertf( desigAlts.size() == curTypes.size(), "Designator alternatives (%zu) and current types (%zu) out of sync", desigAlts.size(), curTypes.size() );
                 } // for
                 if ( desigAlts.size() > 1 ) {

src/ResolvExpr/Resolver.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:17:01 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 23 17:23:14 2017
-// Update Count     : 211
+// Last Modified By : Andrew Beach
+// Last Modified On : Tus Aug  8 16:06:00 2017
+// Update Count     : 212
 //
 
@@ -71 +71 @@
                 virtual void visit( ReturnStmt *returnStmt ) override;
                 virtual void visit( ThrowStmt *throwStmt ) override;
+                virtual void visit( CatchStmt *catchStmt ) override;
 
                 virtual void visit( SingleInit *singleInit ) override;
@@ -368 +369 @@
 
         void Resolver::visit( ThrowStmt *throwStmt ) {
+                // TODO: Replace *exception type with &exception type.
                 if ( throwStmt->get_expr() ) {
-                        Expression * wrapped = new CastExpr( throwStmt->get_expr(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+                        StructDecl * exception_decl =
+                                lookupStruct( "__cfaehm__base_exception_t" );
+                        assert( exception_decl );
+                        Expression * wrapped = new CastExpr(
+                                throwStmt->get_expr(),
+                                new PointerType(
+                                        noQualifiers,
+                                        new StructInstType(
+                                                noQualifiers,
+                                                exception_decl
+                                                )
+                                        )
+                                );
                         Expression * newExpr = findSingleExpression( wrapped, *this );
                         throwStmt->set_expr( newExpr );
+                }
+        }
+
+        void Resolver::visit( CatchStmt *catchStmt ) {
+                if ( catchStmt->get_cond() ) {
+                        Expression * wrapped = new CastExpr(
+                                catchStmt->get_cond(),
+                                new BasicType( noQualifiers, BasicType::Bool )
+                                );
+                        catchStmt->set_cond( findSingleExpression( wrapped, *this ) );
                 }
         }

src/SymTab/Validate.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:50:04 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 30 16:50:13 2017
-// Update Count     : 357
+// Last Modified By : Andrew Beach
+// Last Modified On : Tus Aug  8 13:27:00 2017
+// Update Count     : 358
 //
 
@@ -686 +686 @@
                 Type *designatorType = tyDecl->get_base()->stripDeclarator();
                 if ( StructInstType *aggDecl = dynamic_cast< StructInstType * >( designatorType ) ) {
-                        return new StructDecl( aggDecl->get_name() );
+                        return new StructDecl( aggDecl->get_name(), DeclarationNode::Struct, noAttributes, tyDecl->get_linkage() );
                 } else if ( UnionInstType *aggDecl = dynamic_cast< UnionInstType * >( designatorType ) ) {
-                        return new UnionDecl( aggDecl->get_name() );
+                        return new UnionDecl( aggDecl->get_name(), noAttributes, tyDecl->get_linkage() );
                 } else if ( EnumInstType *enumDecl = dynamic_cast< EnumInstType * >( designatorType ) ) {
-                        return new EnumDecl( enumDecl->get_name() );
+                        return new EnumDecl( enumDecl->get_name(), noAttributes, tyDecl->get_linkage() );
                 } else {
                         return ret->clone();
@@ -783 +783 @@
                                 type = new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() );
                         } // if
-                        TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), Type::StorageClasses(), type ) );
+                        TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), Type::StorageClasses(), type, aggDecl->get_linkage() ) );
                         typedefNames[ aggDecl->get_name() ] = std::make_pair( std::move( tyDecl ), scopeLevel );
                 } // if
@@ -903 +903 @@
                 FunctionType * ftype = functionDecl->get_functionType();
                 std::list< DeclarationWithType * > & retVals = ftype->get_returnVals();
-                assertf( retVals.size() == 0 || retVals.size() == 1, "Function %s has too many return values: %d", functionDecl->get_name().c_str(), retVals.size() );
+                assertf( retVals.size() == 0 || retVals.size() == 1, "Function %s has too many return values: %zu", functionDecl->get_name().c_str(), retVals.size() );
                 if ( retVals.size() == 1 ) {
                         // ensure all function return values have a name - use the name of the function to disambiguate (this also provides a nice bit of help for debugging).

src/SynTree/AggregateDecl.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 23:56:39 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Tus Jun 27 15:30:00 2017
-// Update Count     : 21
+// Last Modified On : Fri Aug  4 14:22:00 2017
+// Update Count     : 22
 //
 
@@ -40 +40 @@
         using std::endl;
 
-        os << typeString() << " " << get_name();
-        os << string( indent+2, ' ' ) << "with body " << has_body() << endl;
+        os << typeString() << " " << get_name() << ":";
+        if ( get_linkage() != LinkageSpec::Cforall ) {
+                os << " " << LinkageSpec::linkageName( get_linkage() );
+        } // if
+        os << " with body " << has_body() << endl;
 
         if ( ! parameters.empty() ) {

src/SynTree/Declaration.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 07:49:18 2017
-// Update Count     : 24
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  9 14:38:00 2017
+// Update Count     : 25
 //
 
@@ -28 +28 @@
 
 Declaration::Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage )
-                : name( name ), storageClasses( scs ), linkage( linkage ), uniqueId( 0 ) {
+                : name( name ), linkage( linkage ), storageClasses( scs ), uniqueId( 0 ) {
 }
 
 Declaration::Declaration( const Declaration &other )
-        : BaseSyntaxNode( other ), name( other.name ), storageClasses( other.storageClasses ), linkage( other.linkage ), uniqueId( other.uniqueId ) {
+        : BaseSyntaxNode( other ), name( other.name ), linkage( other.linkage ), extension( other.extension ), storageClasses( other.storageClasses ), uniqueId( other.uniqueId ) {
 }
 

src/SynTree/Declaration.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:52:59 2017
-// Update Count     : 124
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  9 14:45:00 2017
+// Update Count     : 126
 //
 
@@ -27 +27 @@
 class Declaration : public BaseSyntaxNode {
   public:
+        std::string name;
+        LinkageSpec::Spec linkage;
+        bool extension = false;
+
         Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage );
         Declaration( const Declaration &other );
@@ -53 +57 @@
         static void dumpIds( std::ostream &os );
         static Declaration *declFromId( UniqueId id );
-  private:
-        std::string name;
+
+  private:
         Type::StorageClasses storageClasses;
-        LinkageSpec::Spec linkage;
         UniqueId uniqueId;
-        bool extension = false;
 };
 
 class DeclarationWithType : public Declaration {
   public:
-        DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
-        DeclarationWithType( const DeclarationWithType &other );
-        virtual ~DeclarationWithType();
-
-        std::string get_mangleName() const { return mangleName; }
-        DeclarationWithType * set_mangleName( std::string newValue ) { mangleName = newValue; return this; }
-
-        std::string get_scopedMangleName() const { return mangleName + "_" + std::to_string(scopeLevel); }
-
-        int get_scopeLevel() const { return scopeLevel; }
-        DeclarationWithType * set_scopeLevel( int newValue ) { scopeLevel = newValue; return this; }
-
-        ConstantExpr *get_asmName() const { return asmName; }
-        DeclarationWithType * set_asmName( ConstantExpr *newValue ) { asmName = newValue; return this; }
-
-        std::list< Attribute * >& get_attributes() { return attributes; }
-        const std::list< Attribute * >& get_attributes() const { return attributes; }
-
-        Type::FuncSpecifiers get_funcSpec() const { return fs; }
-        //void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
-
-        virtual DeclarationWithType *clone() const = 0;
-        virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
-
-        virtual Type *get_type() const = 0;
-        virtual void set_type(Type *) = 0;
-  private:
         // this represents the type with all types and typedefs expanded it is generated by SymTab::Validate::Pass2
         std::string mangleName;
@@ -97 +72 @@
         ConstantExpr *asmName;
         std::list< Attribute * > attributes;
+
+        DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
+        DeclarationWithType( const DeclarationWithType &other );
+        virtual ~DeclarationWithType();
+
+        std::string get_mangleName() const { return mangleName; }
+        DeclarationWithType * set_mangleName( std::string newValue ) { mangleName = newValue; return this; }
+
+        std::string get_scopedMangleName() const { return mangleName + "_" + std::to_string(scopeLevel); }
+
+        int get_scopeLevel() const { return scopeLevel; }
+        DeclarationWithType * set_scopeLevel( int newValue ) { scopeLevel = newValue; return this; }
+
+        ConstantExpr *get_asmName() const { return asmName; }
+        DeclarationWithType * set_asmName( ConstantExpr *newValue ) { asmName = newValue; return this; }
+
+        std::list< Attribute * >& get_attributes() { return attributes; }
+        const std::list< Attribute * >& get_attributes() const { return attributes; }
+
+        Type::FuncSpecifiers get_funcSpec() const { return fs; }
+        //void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
+
+        virtual DeclarationWithType *clone() const = 0;
+        virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
+
+        virtual Type *get_type() const = 0;
+        virtual void set_type(Type *) = 0;
+
+  private:
         Type::FuncSpecifiers fs;
 };
@@ -103 +107 @@
         typedef DeclarationWithType Parent;
   public:
+        Type *type;
+        Initializer *init;
+        Expression *bitfieldWidth;
+
         ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init,
                                 const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
@@ -122 +130 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
-  private:
-        Type *type;
-        Initializer *init;
-        Expression *bitfieldWidth;
 };
 
@@ -131 +135 @@
         typedef DeclarationWithType Parent;
   public:
+        FunctionType *type;
+        CompoundStmt *statements;
+
         FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements,
                                   const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
@@ -149 +156 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
-  private:
-        FunctionType *type;
-        CompoundStmt *statements;
 };
 
@@ -157 +161 @@
         typedef Declaration Parent;
   public:
+        Type *base;
+        std::list< TypeDecl* > parameters;
+        std::list< DeclarationWithType* > assertions;
+
         NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *type );
         NamedTypeDecl( const NamedTypeDecl &other );
@@ -171 +179 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
-  protected:
-  private:
-        Type *base;
-        std::list< TypeDecl* > parameters;
-        std::list< DeclarationWithType* > assertions;
 };
 
@@ -182 +185 @@
   public:
         enum Kind { Any, Dtype, Ftype, Ttype };
+
+        Type * init;
+        bool sized;
+
         /// Data extracted from a type decl
         struct Data {
@@ -216 +223 @@
   private:
         Kind kind;
-        Type * init;
-        bool sized;
 };
 
@@ -223 +228 @@
         typedef NamedTypeDecl Parent;
   public:
-        TypedefDecl( const std::string &name, Type::StorageClasses scs, Type *type ) : Parent( name, scs, type ) {}
+        TypedefDecl( const std::string &name, Type::StorageClasses scs, Type *type, LinkageSpec::Spec spec = LinkageSpec::Cforall ) : Parent( name, scs, type ) { set_linkage( spec ); }
         TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
 
@@ -237 +242 @@
         typedef Declaration Parent;
   public:
-        AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
-        AggregateDecl( const AggregateDecl &other );
-        virtual ~AggregateDecl();
-
-        std::list<Declaration*>& get_members() { return members; }
-        std::list<TypeDecl*>& get_parameters() { return parameters; }
-
-        std::list< Attribute * >& get_attributes() { return attributes; }
-        const std::list< Attribute * >& get_attributes() const { return attributes; }
-
-        bool has_body() const { return body; }
-        AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
-
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-        virtual void printShort( std::ostream &os, int indent = 0 ) const;
-  protected:
-        virtual std::string typeString() const = 0;
-
-  private:
         std::list<Declaration*> members;
         std::list<TypeDecl*> parameters;
         bool body;
         std::list< Attribute * > attributes;
+
+        AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
+        AggregateDecl( const AggregateDecl &other );
+        virtual ~AggregateDecl();
+
+        std::list<Declaration*>& get_members() { return members; }
+        std::list<TypeDecl*>& get_parameters() { return parameters; }
+
+        std::list< Attribute * >& get_attributes() { return attributes; }
+        const std::list< Attribute * >& get_attributes() const { return attributes; }
+
+        bool has_body() const { return body; }
+        AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
+
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const;
+  protected:
+        virtual std::string typeString() const = 0;
 };
 
@@ -333 +337 @@
 class AsmDecl : public Declaration {
   public:
+        AsmStmt *stmt;
+
         AsmDecl( AsmStmt *stmt );
         AsmDecl( const AsmDecl &other );
@@ -345 +351 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
-  private:
-        AsmStmt *stmt;
 };
 

src/SynTree/Expression.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Mon Jul 24 16:27:00 2017
-// Update Count     : 43
+// Last Modified On : Fri Aug  8 11:54:00 2017
+// Update Count     : 44
 //
 
@@ -29 +29 @@
 class Expression : public BaseSyntaxNode{
   public:
+        Type * result;
+        TypeSubstitution * env;
+        Expression * argName; // if expression is used as an argument, it can be "designated" by this name
+        bool extension = false;
+
         Expression( Expression * _aname = nullptr );
         Expression( const Expression & other );
@@ -49 +54 @@
         virtual Expression * acceptMutator( Mutator & m ) = 0;
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  protected:
-        Type * result;
-        TypeSubstitution * env;
-        Expression * argName; // if expression is used as an argument, it can be "designated" by this name
-        bool extension = false;
 };
 
@@ -79 +79 @@
 class ApplicationExpr : public Expression {
   public:
+        Expression * function;
+
         ApplicationExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >() );
         ApplicationExpr( const ApplicationExpr & other );
@@ -92 +94 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+
   private:
-        Expression * function;
         std::list<Expression *> args;
         InferredParams inferParams;
@@ -103 +105 @@
 class UntypedExpr : public Expression {
   public:
+        Expression * function;
+        std::list<Expression*> args;
+
         UntypedExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >(), Expression *_aname = nullptr );
         UntypedExpr( const UntypedExpr & other );
@@ -123 +128 @@
         virtual void print( std::ostream & os, int indent = 0 ) const;
         virtual void printArgs(std::ostream & os, int indent = 0) const;
-  private:
-        Expression * function;
-        std::list<Expression*> args;
 };
 
@@ -131 +133 @@
 class NameExpr : public Expression {
   public:
+        std::string name;
+
         NameExpr( std::string name, Expression *_aname = nullptr );
         NameExpr( const NameExpr & other );
@@ -142 +146 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        std::string name;
 };
 
@@ -152 +154 @@
 class AddressExpr : public Expression {
   public:
+        Expression * arg;
+
         AddressExpr( Expression * arg, Expression *_aname = nullptr );
         AddressExpr( const AddressExpr & other );
@@ -163 +167 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * arg;
 };
 
@@ -170 +172 @@
 class LabelAddressExpr : public Expression {
   public:
+        Expression * arg;
+
         LabelAddressExpr( Expression * arg );
         LabelAddressExpr( const LabelAddressExpr & other );
@@ -181 +185 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * arg;
 };
 
@@ -188 +190 @@
 class CastExpr : public Expression {
   public:
+        Expression * arg;
+
         CastExpr( Expression * arg, Expression *_aname = nullptr );
         CastExpr( Expression * arg, Type * toType, Expression *_aname = nullptr );
@@ -200 +204 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * arg;
 };
 
@@ -207 +209 @@
 class VirtualCastExpr : public Expression {
   public:
+        Expression * arg;
+
         VirtualCastExpr( Expression * arg, Type * toType );
         VirtualCastExpr( const VirtualCastExpr & other );
@@ -218 +222 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * arg;
 };
 
@@ -225 +227 @@
 class UntypedMemberExpr : public Expression {
   public:
+        Expression * member;
+        Expression * aggregate;
+
         UntypedMemberExpr( Expression * member, Expression * aggregate, Expression *_aname = nullptr );
         UntypedMemberExpr( const UntypedMemberExpr & other );
@@ -238 +243 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * member;
-        Expression * aggregate;
 };
 
@@ -247 +249 @@
 class MemberExpr : public Expression {
   public:
+        DeclarationWithType * member;
+        Expression * aggregate;
+
         MemberExpr( DeclarationWithType * member, Expression * aggregate, Expression *_aname = nullptr );
         MemberExpr( const MemberExpr & other );
@@ -260 +265 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        DeclarationWithType * member;
-        Expression * aggregate;
 };
 
@@ -269 +271 @@
 class VariableExpr : public Expression {
   public:
+        DeclarationWithType * var;
+
         VariableExpr( DeclarationWithType * var, Expression *_aname = nullptr );
         VariableExpr( const VariableExpr & other );
@@ -280 +284 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        DeclarationWithType * var;
 };
 
@@ -287 +289 @@
 class ConstantExpr : public Expression {
   public:
+        Constant constant;
+
         ConstantExpr( Constant constant, Expression *_aname = nullptr );
         ConstantExpr( const ConstantExpr & other );
@@ -298 +302 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Constant constant;
 };
 
@@ -305 +307 @@
 class SizeofExpr : public Expression {
   public:
+        Expression * expr;
+        Type * type;
+        bool isType;
+
         SizeofExpr( Expression * expr, Expression *_aname = nullptr );
         SizeofExpr( const SizeofExpr & other );
@@ -321 +327 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
+};
+
+/// AlignofExpr represents an alignof expression
+class AlignofExpr : public Expression {
+  public:
         Expression * expr;
         Type * type;
         bool isType;
-};
-
-/// AlignofExpr represents an alignof expression
-class AlignofExpr : public Expression {
-  public:
+
         AlignofExpr( Expression * expr, Expression *_aname = nullptr );
         AlignofExpr( const AlignofExpr & other );
@@ -346 +352 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * expr;
-        Type * type;
-        bool isType;
 };
 
@@ -355 +357 @@
 class UntypedOffsetofExpr : public Expression {
   public:
+        Type * type;
+        std::string member;
+
         UntypedOffsetofExpr( Type * type, const std::string & member, Expression *_aname = nullptr );
         UntypedOffsetofExpr( const UntypedOffsetofExpr & other );
@@ -368 +373 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Type * type;
-        std::string member;
 };
 
@@ -376 +378 @@
 class OffsetofExpr : public Expression {
   public:
+        Type * type;
+        DeclarationWithType * member;
+
         OffsetofExpr( Type * type, DeclarationWithType * member, Expression *_aname = nullptr );
         OffsetofExpr( const OffsetofExpr & other );
@@ -389 +394 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Type * type;
-        DeclarationWithType * member;
 };
 
@@ -397 +399 @@
 class OffsetPackExpr : public Expression {
 public:
+        StructInstType * type;
+
         OffsetPackExpr( StructInstType * type_, Expression * aname_ = 0 );
         OffsetPackExpr( const OffsetPackExpr & other );
@@ -407 +411 @@
         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:
-        StructInstType * type;
+        virtual void print( std::ostream & os, int indent = 0 ) const;
 };
 
@@ -417 +417 @@
 class AttrExpr : public Expression {
   public:
+        Expression * attr;
+        Expression * expr;
+        Type * type;
+        bool isType;
+
         AttrExpr(Expression * attr, Expression * expr, Expression *_aname = nullptr );
         AttrExpr( const AttrExpr & other );
@@ -435 +440 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * attr;
-        Expression * expr;
-        Type * type;
-        bool isType;
 };
 
@@ -445 +445 @@
 class LogicalExpr : public Expression {
   public:
+        Expression * arg1;
+        Expression * arg2;
+
         LogicalExpr( Expression * arg1, Expression * arg2, bool andp = true, Expression *_aname = nullptr );
         LogicalExpr( const LogicalExpr & other );
@@ -459 +462 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+
   private:
+        bool isAnd;
+};
+
+/// ConditionalExpr represents the three-argument conditional ( p ? a : b )
+class ConditionalExpr : public Expression {
+  public:
         Expression * arg1;
         Expression * arg2;
-        bool isAnd;
-};
-
-/// ConditionalExpr represents the three-argument conditional ( p ? a : b )
-class ConditionalExpr : public Expression {
-  public:
+        Expression * arg3;
+
         ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3, Expression *_aname = nullptr );
         ConditionalExpr( const ConditionalExpr & other );
@@ -483 +489 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
+};
+
+/// CommaExpr represents the sequence operator ( a, b )
+class CommaExpr : public Expression {
+  public:
         Expression * arg1;
         Expression * arg2;
-        Expression * arg3;
-};
-
-/// CommaExpr represents the sequence operator ( a, b )
-class CommaExpr : public Expression {
-  public:
+
         CommaExpr( Expression * arg1, Expression * arg2, Expression *_aname = nullptr );
         CommaExpr( const CommaExpr & other );
@@ -505 +510 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * arg1;
-        Expression * arg2;
 };
 
@@ -513 +515 @@
 class TypeExpr : public Expression {
   public:
+        Type * type;
+
         TypeExpr( Type * type );
         TypeExpr( const TypeExpr & other );
@@ -524 +528 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Type * type;
 };
 
@@ -531 +533 @@
 class AsmExpr : public Expression {
   public:
+        Expression * inout;
+        ConstantExpr * constraint;
+        Expression * operand;
+
         AsmExpr( Expression * inout, ConstantExpr * constraint, Expression * operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
         AsmExpr( const AsmExpr & other );
@@ -548 +554 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
+
         // https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
-        Expression * inout;
-        ConstantExpr * constraint;
-        Expression * operand;
 };
 
@@ -559 +562 @@
 class ImplicitCopyCtorExpr : public Expression {
 public:
-        ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
-        ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other );
-        virtual ~ImplicitCopyCtorExpr();
-
-        ApplicationExpr * get_callExpr() const { return callExpr; }
-        void set_callExpr( ApplicationExpr * newValue ) { callExpr = newValue; }
-
-        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
-        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
-        std::list< Expression * > & get_dtors() { return dtors; }
-
-        virtual ImplicitCopyCtorExpr * clone() const { return new ImplicitCopyCtorExpr( * 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:
         ApplicationExpr * callExpr;
         std::list< ObjectDecl * > tempDecls;
         std::list< ObjectDecl * > returnDecls;
         std::list< Expression * > dtors;
+
+        ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
+        ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other );
+        virtual ~ImplicitCopyCtorExpr();
+
+        ApplicationExpr * get_callExpr() const { return callExpr; }
+        void set_callExpr( ApplicationExpr * newValue ) { callExpr = newValue; }
+
+        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
+        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
+        std::list< Expression * > & get_dtors() { return dtors; }
+
+        virtual ImplicitCopyCtorExpr * clone() const { return new ImplicitCopyCtorExpr( * 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;
 };
 
@@ -584 +587 @@
 class ConstructorExpr : public Expression {
 public:
+        Expression * callExpr;
+
         ConstructorExpr( Expression * callExpr );
         ConstructorExpr( const ConstructorExpr & other );
@@ -595 +600 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-private:
-        Expression * callExpr;
 };
 
@@ -602 +605 @@
 class CompoundLiteralExpr : public Expression {
   public:
+        Initializer * initializer;
+
         CompoundLiteralExpr( Type * type, Initializer * initializer );
         CompoundLiteralExpr( const CompoundLiteralExpr & other );
@@ -613 +618 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Initializer * initializer;
 };
 
@@ -620 +623 @@
 class RangeExpr : public Expression {
   public:
+        Expression * low, * high;
+
         RangeExpr( Expression * low, Expression * high );
         RangeExpr( const RangeExpr & other );
@@ -632 +637 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * low, * high;
 };
 
@@ -639 +642 @@
 class UntypedTupleExpr : public Expression {
   public:
+        std::list<Expression*> exprs;
+
         UntypedTupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
         UntypedTupleExpr( const UntypedTupleExpr & other );
@@ -649 +654 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        std::list<Expression*> exprs;
 };
 
@@ -656 +659 @@
 class TupleExpr : public Expression {
   public:
+        std::list<Expression*> exprs;
+
         TupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
         TupleExpr( const TupleExpr & other );
@@ -666 +671 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        std::list<Expression*> exprs;
 };
 
@@ -673 +676 @@
 class TupleIndexExpr : public Expression {
   public:
+        Expression * tuple;
+        unsigned int index;
+
         TupleIndexExpr( Expression * tuple, unsigned int index );
         TupleIndexExpr( const TupleIndexExpr & other );
@@ -686 +692 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * tuple;
-        unsigned int index;
 };
 
@@ -694 +697 @@
 class TupleAssignExpr : public Expression {
   public:
+        StmtExpr * stmtExpr = nullptr;
+
         TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname = nullptr );
         TupleAssignExpr( const TupleAssignExpr & other );
@@ -705 +710 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        StmtExpr * stmtExpr = nullptr;
 };
 
@@ -712 +715 @@
 class StmtExpr : public Expression {
 public:
+        CompoundStmt * statements;
+        std::list< ObjectDecl * > returnDecls; // return variable(s) for stmt expression
+        std::list< Expression * > dtors; // destructor(s) for return variable(s)
+
         StmtExpr( CompoundStmt * statements );
         StmtExpr( const StmtExpr & other );
@@ -726 +733 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-private:
-        CompoundStmt * statements;
-        std::list< ObjectDecl * > returnDecls; // return variable(s) for stmt expression
-        std::list< Expression * > dtors; // destructor(s) for return variable(s)
 };
 
 class UniqueExpr : public Expression {
 public:
+        Expression * expr;
+        ObjectDecl * object;
+        VariableExpr * var;
+
         UniqueExpr( Expression * expr, long long idVal = -1 );
         UniqueExpr( const UniqueExpr & other );
@@ -753 +760 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+
 private:
-        Expression * expr;
-        ObjectDecl * object;
-        VariableExpr * var;
         int id;
         static long long count;
@@ -773 +778 @@
 class UntypedInitExpr : public Expression {
 public:
+        Expression * expr;
+        std::list<InitAlternative> initAlts;
+
         UntypedInitExpr( Expression * expr, const std::list<InitAlternative> & initAlts );
         UntypedInitExpr( const UntypedInitExpr & other );
@@ -786 +794 @@
         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:
+        Expression * expr;
+        Designation * designation;
+
         InitExpr( Expression * expr, Designation * designation );
         InitExpr( const InitExpr & other );
@@ -807 +815 @@
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-private:
-        Expression * expr;
-        Designation * designation;
 };
 

src/SynTree/Initializer.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Fri May 13 13:23:03 2016
-// Update Count     : 28
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Aug  3 11:33:00 2016
+// Update Count     : 29
 //
 
@@ -74 +74 @@
                         }
                 }
-                assertf( initializers.size() == designations.size(), "Created ListInit with mismatching initializers (%d) and designations (%d)", initializers.size(), designations.size() );
+                assertf( initializers.size() == designations.size(), "Created ListInit with mismatching initializers (%lu) and designations (%lu)", initializers.size(), designations.size() );
 }
 

src/SynTree/Initializer.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:52:02 2017
-// Update Count     : 21
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  9 10:19:00 2017
+// Update Count     : 22
 //
 
@@ -27 +27 @@
 class Designation : public BaseSyntaxNode {
 public:
+        std::list< Expression * > designators;
+
         Designation( const std::list< Expression * > & designators );
         Designation( const Designation & other );
@@ -37 +39 @@
         virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-private:
-        std::list< Expression * > designators;
 };
 
@@ -63 +63 @@
 class SingleInit : public Initializer {
   public:
+        //Constant *value;
+        Expression *value;      // has to be a compile-time constant
+
         SingleInit( Expression *value, bool maybeConstructed = false );
         SingleInit( const SingleInit &other );
@@ -74 +77 @@
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        //Constant *value;
-        Expression *value;      // has to be a compile-time constant
 };
 
@@ -83 +83 @@
 class ListInit : public Initializer {
   public:
+        std::list<Initializer *> initializers;  // order *is* important
+        std::list<Designation *> designations;  // order/length is consistent with initializers
+
         ListInit( const std::list<Initializer*> &initializers,
                           const std::list<Designation *> &designators = {}, bool maybeConstructed = false );
@@ -102 +105 @@
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        std::list<Initializer *> initializers;  // order *is* important
-        std::list<Designation *> designations;  // order/length is consistent with initializers
 };
 
@@ -113 +113 @@
 class ConstructorInit : public Initializer {
   public:
+        Statement * ctor;
+        Statement * dtor;
+
         ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init );
         ConstructorInit( const ConstructorInit &other );
@@ -130 +133 @@
 
   private:
-        Statement * ctor;
-        Statement * dtor;
         // C-style initializer made up of SingleInit and ListInit nodes to use as a fallback
         // if an appropriate constructor definition is not found by the resolver

src/SynTree/NamedTypeDecl.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 07:49:44 2017
-// Update Count     : 13
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  9 13:28:00 2017
+// Update Count     : 14
 //
 
@@ -38 +38 @@
         if ( get_name() != "" ) {
                 os << get_name() << ": ";
+        } // if
+        if ( get_linkage() != LinkageSpec::Cforall ) {
+                os << LinkageSpec::linkageName( get_linkage() ) << " ";
         } // if
         get_storageClasses().print( os );

src/SynTree/Statement.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:54:32 2017
-// Update Count     : 68
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Aug  3 14:08:00 2017
+// Update Count     : 69
 //
 
@@ -26 +26 @@
 class Statement : public BaseSyntaxNode {
   public:
+        std::list<Label> labels;
+
         Statement( std::list<Label> labels );
         virtual ~Statement();
@@ -36 +38 @@
         virtual Statement *acceptMutator( Mutator &m ) = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  protected:
-        std::list<Label> labels;
 };
 
 class CompoundStmt : public Statement {
   public:
+        std::list<Statement*> kids;
+
         CompoundStmt( std::list<Label> labels );
         CompoundStmt( const CompoundStmt &other );
@@ -54 +56 @@
         virtual CompoundStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        std::list<Statement*> kids;
 };
 
@@ -67 +67 @@
         virtual NullStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-
-  private:
 };
 
 class ExprStmt : public Statement {
   public:
+        Expression *expr;
+
         ExprStmt( std::list<Label> labels, Expression *expr );
         ExprStmt( const ExprStmt &other );
@@ -84 +84 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Expression *expr;
 };
 
 class AsmStmt : public Statement {
   public:
+        bool voltile;
+        ConstantExpr *instruction;
+        std::list<Expression *> output, input;
+        std::list<ConstantExpr *> clobber;
+        std::list<Label> gotolabels;
+
         AsmStmt( std::list<Label> labels, bool voltile, ConstantExpr *instruction, std::list<Expression *> input, std::list<Expression *> output, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
         AsmStmt( const AsmStmt &other );
@@ -111 +115 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        bool voltile;
-        ConstantExpr *instruction;
-        std::list<Expression *> output, input;
-        std::list<ConstantExpr *> clobber;
-        std::list<Label> gotolabels;
 };
 
 class IfStmt : public Statement {
   public:
+        Expression *condition;
+        Statement *thenPart;
+        Statement *elsePart;
+
         IfStmt( std::list<Label> labels, Expression *condition, Statement *thenPart, Statement *elsePart );
         IfStmt( const IfStmt &other );
@@ -136 +138 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Expression *condition;
-        Statement *thenPart;
-        Statement *elsePart;
 };
 
 class SwitchStmt : public Statement {
   public:
+        Expression * condition;
+
         SwitchStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &statements );
         SwitchStmt( const SwitchStmt &other );
@@ -159 +159 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
+        std::list<Statement *> statements;
+};
+
+class CaseStmt : public Statement {
+  public:
         Expression * condition;
-        std::list<Statement *> statements;
-};
-
-class CaseStmt : public Statement {
-  public:
+        std::list<Statement *> stmts;
+
         CaseStmt( std::list<Label> labels, Expression *conditions, std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
         CaseStmt( const CaseStmt &other );
@@ -186 +188 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
-        Expression * condition;
-        std::list<Statement *> stmts;
         bool _isDefault;
 };
@@ -193 +193 @@
 class WhileStmt : public Statement {
   public:
+        Expression *condition;
+        Statement *body;
+        bool isDoWhile;
+
         WhileStmt( std::list<Label> labels, Expression *condition,
                Statement *body, bool isDoWhile = false );
@@ -209 +213 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
+};
+
+class ForStmt : public Statement {
+  public:
+        std::list<Statement *> initialization;
         Expression *condition;
+        Expression *increment;
         Statement *body;
-        bool isDoWhile;
-};
-
-class ForStmt : public Statement {
-  public:
+
         ForStmt( std::list<Label> labels, std::list<Statement *> initialization,
              Expression *condition = 0, Expression *increment = 0, Statement *body = 0 );
@@ -235 +240 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        std::list<Statement *> initialization;
-        Expression *condition;
-        Expression *increment;
-        Statement *body;
 };
 
@@ -245 +245 @@
   public:
         enum Type { Goto = 0, Break, Continue };
+
+        // originalTarget kept for error messages.
+        const Label originalTarget;
+        Label target;
+        Expression *computedTarget;
+        Type type;
 
         BranchStmt( std::list<Label> labels, Label target, Type ) throw (SemanticError);
@@ -265 +271 @@
   private:
         static const char *brType[];
-        Label originalTarget;  // can give better error messages if we remember the label name that the user entered
-        Label target;
-        Expression *computedTarget;
-        Type type;
 };
 
 class ReturnStmt : public Statement {
   public:
+        Expression *expr;
+
         ReturnStmt( std::list<Label> labels, Expression *expr );
         ReturnStmt( const ReturnStmt &other );
@@ -284 +288 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Expression *expr;
 };
 
@@ -291 +293 @@
   public:
         enum Kind { Terminate, Resume };
+
+        const Kind kind;
+        Expression * expr;
+        Expression * target;
 
         ThrowStmt( std::list<Label> labels, Kind kind, Expression * expr, Expression * target = nullptr );
@@ -306 +312 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Kind kind;
-        Expression * expr;
-        Expression * target;
 };
 
 class TryStmt : public Statement {
   public:
+        CompoundStmt *block;
+        std::list<CatchStmt *> handlers;
+        FinallyStmt *finallyBlock;
+
         TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
         TryStmt( const TryStmt &other );
@@ -329 +335 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-
-  private:
-        CompoundStmt *block;
-        std::list<CatchStmt *> handlers;
-        FinallyStmt *finallyBlock;
 };
 
@@ -339 +340 @@
   public:
         enum Kind { Terminate, Resume };
+
+        const Kind kind;
+        Declaration *decl;
+        Expression *cond;
+        Statement *body;
 
         CatchStmt( std::list<Label> labels, Kind kind, Declaration *decl,
@@ -357 +363 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-
-  private:
-        Kind kind;
-        Declaration *decl;
-        Expression *cond;
-        Statement *body;
 };
 
 class FinallyStmt : public Statement {
   public:
+        CompoundStmt *block;
+
         FinallyStmt( std::list<Label> labels, CompoundStmt *block );
         FinallyStmt( const FinallyStmt &other );
@@ -378 +380 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        CompoundStmt *block;
 };
 
@@ -386 +386 @@
 class DeclStmt : public Statement {
   public:
+        Declaration *decl;
+
         DeclStmt( std::list<Label> labels, Declaration *decl );
         DeclStmt( const DeclStmt &other );
@@ -397 +399 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Declaration *decl;
 };
 
@@ -407 +407 @@
 class ImplicitCtorDtorStmt : public Statement {
   public:
+        // Non-owned pointer to the constructor/destructor statement
+        Statement * callStmt;
+
         ImplicitCtorDtorStmt( Statement * callStmt );
         ImplicitCtorDtorStmt( const ImplicitCtorDtorStmt & other );
@@ -418 +421 @@
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
-
-  private:
-        // Non-owned pointer to the constructor/destructor statement
-        Statement * callStmt;
 };
 

src/SynTree/Type.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 17 08:42:47 2017
-// Update Count     : 28
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  2 11:11:00 2017
+// Update Count     : 29
 //
 
@@ -88 +88 @@
 }
 
+// Empty Variable declarations:
+const Type::FuncSpecifiers noFuncSpecifiers;
+const Type::StorageClasses noStorageClasses;
+const Type::Qualifiers noQualifiers;
+
 std::ostream & operator<<( std::ostream & out, const Type * type ) {
         if ( type ) {

src/SynTree/Type.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:53:29 2017
-// Update Count     : 151
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  9 14:25:00 2017
+// Update Count     : 152
 //
 
@@ -127 +127 @@
         }; // Qualifiers
 
+        typedef std::list<TypeDecl *> ForallList;
+
+        Qualifiers tq;
+        ForallList forall;
+        std::list< Attribute * > attributes;
+
         Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
         Type( const Type & other );
@@ -145 +151 @@
         void set_atomic( bool newValue ) { tq.is_atomic = newValue; }
 
-        typedef std::list<TypeDecl *> ForallList;
         ForallList& get_forall() { return forall; }
 
@@ -165 +170 @@
         virtual Type *acceptMutator( Mutator & m ) = 0;
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Qualifiers tq;
-        ForallList forall;
-        std::list< Attribute * > attributes;
-};
-
-extern Type::Qualifiers noQualifiers;                           // no qualifiers on constants
+};
+
+extern const Type::FuncSpecifiers noFuncSpecifiers;
+extern const Type::StorageClasses noStorageClasses;
+extern const Type::Qualifiers noQualifiers;                     // no qualifiers on constants
 
 class VoidType : public Type {
@@ -211 +214 @@
                 LongDoubleImaginary,
                 NUMBER_OF_BASIC_TYPES
-        };
+        } kind;
 
         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
@@ -226 +229 @@
 
         bool isInteger() const;
-  private:
-        Kind kind;
 };
 
 class PointerType : public Type {
   public:
+        Type *base;
+
+        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
+        Expression *dimension;
+        bool isVarLen;
+        bool isStatic;
+
         PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
@@ -252 +260 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
+};
+
+class ArrayType : public Type {
+  public:
         Type *base;
-
-        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
         Expression *dimension;
         bool isVarLen;
         bool isStatic;
-};
-
-class ArrayType : public Type {
-  public:
+
         ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         ArrayType( const ArrayType& );
@@ -282 +288 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Type *base;
-        Expression *dimension;
-        bool isVarLen;
-        bool isStatic;
 };
 
 class FunctionType : public Type {
   public:
+        std::list<DeclarationWithType*> returnVals;
+        std::list<DeclarationWithType*> parameters;
+
+        // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
+        // This could be because of
+        // - an ellipsis in a prototype declaration
+        // - an unprototyped declaration
+        bool isVarArgs;
+
         FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         FunctionType( const FunctionType& );
@@ -305 +315 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        std::list<DeclarationWithType*> returnVals;
-        std::list<DeclarationWithType*> parameters;
-
-        // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
-        // This could be because of
-        // - an ellipsis in a prototype declaration
-        // - an unprototyped declaration
-        bool isVarArgs;
 };
 
 class ReferenceToType : public Type {
   public:
+        std::list< Expression* > parameters;
+        std::string name;
+        bool hoistType;
+
         ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
         ReferenceToType( const ReferenceToType & other );
@@ -336 +341 @@
   protected:
         virtual std::string typeString() const = 0;
-        std::list< Expression* > parameters;
-        std::string name;
-  private:
-        bool hoistType;
 };
 
@@ -345 +346 @@
         typedef ReferenceToType Parent;
   public:
+        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
+        // where the structure used in this type is actually defined
+        StructDecl *baseStruct;
+
         StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
         StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
@@ -368 +373 @@
   private:
         virtual std::string typeString() const;
-
-        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
-        // where the structure used in this type is actually defined
-        StructDecl *baseStruct;
 };
 
@@ -377 +378 @@
         typedef ReferenceToType Parent;
   public:
+        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
+        // where the union used in this type is actually defined
+        UnionDecl *baseUnion;
+
         UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
         UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
@@ -400 +405 @@
   private:
         virtual std::string typeString() const;
-
+};
+
+class EnumInstType : public ReferenceToType {
+        typedef ReferenceToType Parent;
+  public:
         // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
         // where the union used in this type is actually defined
-        UnionDecl *baseUnion;
-};
-
-class EnumInstType : public ReferenceToType {
-        typedef ReferenceToType Parent;
-  public:
+        EnumDecl *baseEnum = nullptr;
+
         EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
         EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
@@ -423 +428 @@
   private:
         virtual std::string typeString() const;
-
-        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
-        // where the union used in this type is actually defined
-        EnumDecl *baseEnum = nullptr;
 };
 
@@ -432 +433 @@
         typedef ReferenceToType Parent;
   public:
+        // this member is filled in by the validate pass, which instantiates the members of the correponding
+        // aggregate with the actual type parameters specified for this use of the context
+        std::list< Declaration* > members;
+
         TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
         TraitInstType( const TraitInstType & other );
@@ -445 +450 @@
   private:
         virtual std::string typeString() const;
-
-        // this member is filled in by the validate pass, which instantiates the members of the correponding
-        // aggregate with the actual type parameters specified for this use of the context
-        std::list< Declaration* > members;
 };
 
@@ -454 +455 @@
         typedef ReferenceToType Parent;
   public:
+        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
+        // where the type used here is actually defined
+        TypeDecl *baseType;
+        bool isFtype;
+
         TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
@@ -472 +478 @@
   private:
         virtual std::string typeString() const;
-        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
-        // where the type used here is actually defined
-        TypeDecl *baseType;
-        bool isFtype;
 };
 
 class TupleType : public Type {
   public:
+        std::list<Type *> types;
+        std::list<Declaration *> members;
+
         TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TupleType( const TupleType& );
@@ -508 +513 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        std::list<Type *> types;
-        std::list<Declaration *> members;
 };
 
 class TypeofType : public Type {
   public:
+        Expression *expr;
+
         TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TypeofType( const TypeofType& );
@@ -528 +532 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
+};
+
+class AttrType : public Type {
+  public:
+        std::string name;
         Expression *expr;
-};
-
-class AttrType : public Type {
-  public:
+        Type *type;
+        bool isType;
+
         AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
@@ -554 +561 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        std::string name;
-        Expression *expr;
-        Type *type;
-        bool isType;
 };
 

src/SynTree/TypeDecl.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 07:49:58 2017
-// Update Count     : 5
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  9 14:35:00 2017
+// Update Count     : 6
 //
 
@@ -18 +18 @@
 #include "Common/utility.h"
 
-TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, Type * init ) : Parent( name, scs, type ), kind( kind ), init( init ), sized( kind == Any || kind == Ttype ) {
+TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, Type * init ) : Parent( name, scs, type ), init( init ), sized( kind == Any || kind == Ttype ), kind( kind ) {
 }
 
-TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), kind( other.kind ), init( maybeClone( other.init ) ), sized( other.sized ) {
+TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), init( maybeClone( other.init ) ), sized( other.sized ), kind( other.kind ) {
 }
 

src/SynTree/TypeExpr.cc

@@ -21 +21 @@
 }
 
-TypeExpr::TypeExpr( const TypeExpr &other ) : type( maybeClone( other.type ) ) {
+TypeExpr::TypeExpr( const TypeExpr &other ) : Expression( other ), type( maybeClone( other.type ) ) {
 }
 

src/Tuples/TupleExpansion.cc

@@ -66 +66 @@
                 };
 
-                class TupleTypeReplacer : public GenPoly::DeclMutator {
-                  public:
-                        typedef GenPoly::DeclMutator Parent;
-                        using Parent::mutate;
-
-                        virtual Type * mutate( TupleType * tupleType ) override;
-
-                        virtual CompoundStmt * mutate( CompoundStmt * stmt ) override {
-                                typeMap.beginScope();
-                                stmt = Parent::mutate( stmt );
-                                typeMap.endScope();
-                                return stmt;
+                struct TupleTypeReplacer : public WithDeclsToAdd, public WithGuards, public WithTypeSubstitution {
+                        Type * postmutate( TupleType * tupleType );
+
+                        void premutate( CompoundStmt * ) {
+                                GuardScope( typeMap );
                         }
                   private:
@@ -111 +104 @@
                 mutateAll( translationUnit, assnExpander );
 
-                TupleTypeReplacer replacer;
-                replacer.mutateDeclarationList( translationUnit );
+                PassVisitor<TupleTypeReplacer> replacer;
+                mutateAll( translationUnit, replacer );
 
                 PassVisitor<TupleIndexExpander> idxExpander;
@@ -218 +211 @@
         }
 
-        Type * TupleTypeReplacer::mutate( TupleType * tupleType ) {
-                tupleType = safe_dynamic_cast< TupleType * > ( Parent::mutate( tupleType ) );
+        Type * TupleTypeReplacer::postmutate( TupleType * tupleType ) {
                 unsigned tupleSize = tupleType->size();
                 if ( ! typeMap.count( tupleSize ) ) {
@@ -226 +218 @@
                         decl->set_body( true );
                         for ( size_t i = 0; i < tupleSize; ++i ) {
-                                TypeDecl * tyParam = new TypeDecl( toString( "tuple_param_", i ), Type::StorageClasses(), nullptr, TypeDecl::Any );
+                                TypeDecl * tyParam = new TypeDecl( toString( "tuple_param_", tupleSize, "_", i ), Type::StorageClasses(), nullptr, TypeDecl::Any );
                                 decl->get_members().push_back( new ObjectDecl( toString("field_", i ), Type::StorageClasses(), LinkageSpec::C, nullptr, new TypeInstType( Type::Qualifiers(), tyParam->get_name(), tyParam ), nullptr ) );
                                 decl->get_parameters().push_back( tyParam );
@@ -235 +227 @@
                         }
                         typeMap[tupleSize] = decl;
-                        addDeclaration( decl );
+                        declsToAddBefore.push_back( decl );
                 }
                 Type::Qualifiers qualifiers = tupleType->get_qualifiers();
@@ -241 +233 @@
                 StructDecl * decl = typeMap[tupleSize];
                 StructInstType * newType = new StructInstType( qualifiers, decl );
-                for ( Type * t : *tupleType ) {
+                for ( auto p : group_iterate( tupleType->get_types(), decl->get_parameters() ) ) {
+                        Type * t = std::get<0>(p);
+                        TypeDecl * td = std::get<1>(p);
                         newType->get_parameters().push_back( new TypeExpr( t->clone() ) );
+                        if ( env ) {
+                                // add bindings to the type environment.
+                                // xxx - This may not be sufficient, it may be necessary to rename type variables on StructInstType?
+                                env->add( td->get_name(), t->clone() );
+                        }
                 }
                 delete tupleType;

src/Virtual/ExpandCasts.cc

@@ -10 +10 @@
 // Created On       : Mon Jul 24 13:59:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Jul 26 14:16:00 2017
-// Update Count     : 0
+// Last Modified On : Tus Aug  2 14:59:00 2017
+// Update Count     : 1
 //
 
@@ -78 +78 @@
 
         void VirtualCastCore::premutate( FunctionDecl * functionDecl ) {
-                if ( (! vcast_decl) && functionDecl->get_statements() &&
+                if ( (! vcast_decl) &&
                      functionDecl->get_name() == "__cfa__virtual_cast" ) {
                         vcast_decl = functionDecl;
@@ -101 +101 @@
                 assertf( castExpr->get_result(), "Virtual Cast target not found before expansion." );
 
-                //assert( vcast_decl );
+                assert( vcast_decl );
                 assert( pvt_decl );
 
                 // May only cast to a pointer or reference type.
                 // A earlier validation should give a syntax error, this is
-                // just to make sure errors don't creep in.
+                // just to make sure errors don't creep during translation.
+                // Move to helper with more detailed error messages.
                 PointerType * target_type =
                         dynamic_cast<PointerType *>( castExpr->get_result() );
-        assert( target_type );
+                assert( target_type );
 
                 StructInstType * target_struct =
                         dynamic_cast<StructInstType *>( target_type->get_base() );
+                assert( target_struct );
+
                 StructDecl * target_decl = target_struct->get_baseStruct();
 
@@ -124 +127 @@
 
                 Expression * result = new CastExpr(
-                        //new ApplicationExpr( new VariableExpr( vcast_decl ), {
+                        //new ApplicationExpr(
+                                //new AddressExpr( new VariableExpr( vcast_decl ) ),
+                                //new CastExpr( new VariableExpr( vcast_decl ),
+                                //      new PointerType( noQualifiers,
+                                //              vcast_decl->get_type()->clone()
+                                //              )
+                                //      ),
                         new UntypedExpr( new NameExpr( "__cfa__virtual_cast" ), {
-                                new CastExpr(
-                                        new AddressExpr( new VariableExpr( table ) ),
-                                        pointer_to_pvt(1)
-                                        ),
-                                new CastExpr(
-                                        castExpr->get_arg(),
-                                        pointer_to_pvt(2)
-                                        ) }
-                                ),
-                        castExpr->get_result()
+                                        new CastExpr(
+                                                new AddressExpr( new VariableExpr( table ) ),
+                                                pointer_to_pvt(1)
+                                                ),
+                                        new CastExpr(
+                                                castExpr->get_arg(),
+                                                pointer_to_pvt(2)
+                                                )
+                                } ),
+                        castExpr->get_result()->clone()
                         );
 

src/driver/cfa.cc

@@ -10 +10 @@
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jul 20 15:54:45 2017
-// Update Count     : 156
+// Last Modified On : Fri Jan 20 14:38:45 2017
+// Update Count     : 155
 //
 
@@ -76 +76 @@
         bool cpp_flag = false;                                                          // -E or -M flag, preprocessor only
         bool std_flag = false;                                                          // -std= flag
+        bool noincstd_flag = false;                                                     // -no-include-stdhdr= flag
         bool debugging __attribute(( unused )) = false;         // -g flag
 
@@ -133 +134 @@
                         } else if ( arg == "-nohelp" ) {
                                 help = false;                                                   // strip the nohelp flag
+                        } else if ( arg == "-no-include-stdhdr" ) {
+                                noincstd_flag = true;                                   // strip the no-include-stdhdr flag
                         } else if ( arg == "-compiler" ) {
                                 // use the user specified compiler
@@ -231 +234 @@
         args[nargs] = "-I" CFA_INCDIR;
         nargs += 1;
-        args[nargs] = "-I" CFA_INCDIR "/stdhdr";
-        nargs += 1;
+        if ( ! noincstd_flag ) {                                                        // do not use during build
+                args[nargs] = "-I" CFA_INCDIR "/stdhdr";
+                nargs += 1;
+        } // if
         args[nargs] = "-I" CFA_INCDIR "/concurrency";
         nargs += 1;

src/include/cassert

@@ -10 +10 @@
 // Created On       : Thu Aug 18 13:19:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 18 13:25:55 2016
-// Update Count     : 4
+// Last Modified On : Tue Aug  1 11:56:01 2017
+// Update Count     : 16
 //
 
@@ -18 +18 @@
 // IWYU pragma: private, include <cassert>
 
-#include_next <assert.h>
+#include_next <cassert>
 
-#define __STRINGIFY__(str) #str
-#define __VSTRINGIFY__(str) __STRINGIFY__(str)
-#define assertf(expr, fmt, ...) ((expr) ? static_cast<void>(0) : __assert_fail_f(__VSTRINGIFY__(expr), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, ## __VA_ARGS__ ))
+#ifdef NDEBUG
 
-void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) __attribute__((noreturn));
+#define assertf(expr, fmt, ...) (__ASSERT_VOID_ASSERT (0))
+
+#else
+
+#define assertf(expr, fmt, ...) ((expr) \
+        ? (__ASSERT_VOID_CAST (0)) \
+        : __assert_fail_f( #expr, __FILE__, __LINE__, \
+        __ASSERT_FUNCTION, fmt, ## __VA_ARGS__ ))
+
+void __assert_fail_f(   const char *assertion, const char *file, 
+                                                unsigned int line, const char *function, 
+                                                const char *fmt, ... 
+        ) __attribute__((noreturn, format(printf, 5, 6)));
+
+#endif
 
 template<typename T, typename U>
-static inline T safe_dynamic_cast(const U& src) {
+static inline T safe_dynamic_cast( const U & src ) {
         T ret = dynamic_cast<T>(src);
         assert(ret);

src/libcfa/Makefile.am

@@ -39 +39 @@
 
 AM_CCASFLAGS = @CFA_FLAGS@
-CFLAGS = -quiet -I${abs_top_srcdir}/src/libcfa/stdhdr -XCFA -t -B${abs_top_srcdir}/src/driver ${EXTRA_FLAGS}
+
+#CFLAGS for most libcfa src
+#use -no-include-stdhdr to prevent rebuild cycles
+#The built sources must not depend on the installed headers
+CFLAGS = -quiet -no-include-stdhdr -I${abs_top_srcdir}/src/libcfa/stdhdr -XCFA -t -B${abs_top_srcdir}/src/driver ${EXTRA_FLAGS}
 CC = ${abs_top_srcdir}/src/driver/cfa
 

src/libcfa/Makefile.in

@@ -308 +308 @@
 CFA_NAME = @CFA_NAME@
 CFA_PREFIX = @CFA_PREFIX@
-CFLAGS = -quiet -I${abs_top_srcdir}/src/libcfa/stdhdr -XCFA -t -B${abs_top_srcdir}/src/driver ${EXTRA_FLAGS}
+
+#CFLAGS for most libcfa src
+#use -no-include-stdhdr to prevent rebuild cycles
+#The built sources must not depend on the installed headers
+CFLAGS = -quiet -no-include-stdhdr -I${abs_top_srcdir}/src/libcfa/stdhdr -XCFA -t -B${abs_top_srcdir}/src/driver ${EXTRA_FLAGS}
 CPP = @CPP@
 CPPFLAGS = @CPPFLAGS@

src/libcfa/concurrency/monitor.c

@@ -10 +10 @@
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 21 22:37:11 2017
-// Update Count     : 1
+// Last Modified On : Mon Jul 31 14:59:05 2017
+// Update Count     : 3
 //
 
@@ -484 +484 @@
         if( !this->monitors ) {
                 // LIB_DEBUG_PRINT_SAFE("Branding\n");
-                assertf( thrd->current_monitors != NULL, "No current monitor to brand condition", thrd->current_monitors );
+                assertf( thrd->current_monitors != NULL, "No current monitor to brand condition %p", thrd->current_monitors );
                 this->monitor_count = thrd->current_monitor_count;
 

src/libcfa/exception.c

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Jun 26 15:13:00 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jul 26 10:37:51 2017
-// Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Aug  4 15:20:00 2017
+// Update Count     : 6
 //
+
+#include <stddef.h> // for size_t
 
 #include "exception.h"
@@ -32 +34 @@
 #include "lsda.h"
 
+
+// Base exception vtable is abstract, you should not have base exceptions.
+struct __cfaehm__base_exception_t_vtable
+                ___cfaehm__base_exception_t_vtable_instance = {
+        .parent = NULL,
+        .size = 0,
+        .copy = NULL,
+        .free = NULL,
+        .msg = NULL
+};
+
+
 // Temperary global exception context. Does not work with concurency.
-struct shared_stack_t {
+struct exception_context_t {
     struct __cfaehm__try_resume_node * top_resume;
     struct __cfaehm__try_resume_node * current_resume;
 
-    exception current_exception;
+    exception * current_exception;
     int current_handler_index;
 } shared_stack = {NULL, NULL, 0, 0};
 
+// Get the current exception context.
+// There can be a single global until multithreading occurs, then each stack
+// needs its own. It will have to be updated to handle that.
+struct exception_context_t * this_exception_context() {
+        return &shared_stack;
+}
+//#define SAVE_EXCEPTION_CONTEXT(to_name)
+//struct exception_context_t * to_name = this_exception_context();
+//exception * this_exception() {
+//    return this_exception_context()->current_exception;
+//}
 
 
@@ -55 +80 @@
 
         // DEBUG
-        printf("Throwing resumption exception %d\n", *except);
+        printf("Throwing resumption exception\n");
 
         struct __cfaehm__try_resume_node * original_head = shared_stack.current_resume;
@@ -69 +94 @@
         }
 
-        printf("Unhandled exception %d\n", *except);
+        printf("Unhandled exception\n");
         shared_stack.current_resume = original_head;
 
@@ -94 +119 @@
 // TERMINATION ===============================================================
 
-// Requires -fexceptions to work.
-
-// Global which defines the current exception.  Currently an int just to make matching easier.
-//int this_exception; (became shared_stack.current_exception)
+// MEMORY MANAGEMENT (still for integers)
+// May have to move to cfa for constructors and destructors (references).
+
+struct __cfaehm__node {
+        struct __cfaehm__node * next;
+};
+
+#define NODE_TO_EXCEPT(node) ((exception *)(1 + (node)))
+#define EXCEPT_TO_NODE(except) ((struct __cfaehm__node *)(except) - 1)
+
+// Creates a copy of the indicated exception and sets current_exception to it.
+static void __cfaehm__allocate_exception( exception * except ) {
+        struct exception_context_t * context = this_exception_context();
+
+        // Allocate memory for the exception.
+        struct __cfaehm__node * store = malloc(
+                sizeof( struct __cfaehm__node ) + except->virtual_table->size );
+
+        if ( ! store ) {
+                // Failure: cannot allocate exception. Terminate thread.
+                abort(); // <- Although I think it might be the process.
+        }
+
+        // Add the node to the list:
+        store->next = EXCEPT_TO_NODE(context->current_exception);
+        context->current_exception = NODE_TO_EXCEPT(store);
+
+        // Copy the exception to storage.
+        except->virtual_table->copy( context->current_exception, except );
+}
+
+// Delete the provided exception, unsetting current_exception if relivant.
+static void __cfaehm__delete_exception( exception * except ) {
+        struct exception_context_t * context = this_exception_context();
+
+        // DEBUG
+        printf( "Deleting Exception\n");
+
+        // Remove the exception from the list.
+        struct __cfaehm__node * to_free = EXCEPT_TO_NODE(except);
+        struct __cfaehm__node * node;
+
+        if ( context->current_exception == except ) {
+                node = to_free->next;
+                context->current_exception = (node) ? NODE_TO_EXCEPT(node) : 0;
+        } else {
+                node = EXCEPT_TO_NODE(context->current_exception);
+                // It may always be in the first or second position.
+                while( to_free != node->next ) {
+                        node = node->next;
+                }
+                node->next = to_free->next;
+        }
+
+        // Free the old exception node.
+        except->virtual_table->free( except );
+        free( to_free );
+}
+
+// If this isn't a rethrow (*except==0), delete the provided exception.
+void __cfaehm__cleanup_terminate( void * except ) {
+        if ( *(void**)except ) __cfaehm__delete_exception( *(exception**)except );
+}
+
 
 // We need a piece of storage to raise the exception
@@ -117 +202 @@
 }
 
-void __cfaehm__throw_terminate( exception * val ) {
-        // Store the current exception
-        shared_stack.current_exception = *val;
-
-        // DEBUG
-        printf("Throwing termination exception %d\n", *val);
+// The exception that is being thrown must already be stored.
+__attribute__((noreturn)) void __cfaehm__begin_unwind(void) {
+        if ( ! this_exception_context()->current_exception ) {
+                printf("UNWIND ERROR missing exception in begin unwind\n");
+                abort();
+        }
+
 
         // Call stdlibc to raise the exception
@@ -148 +234 @@
 }
 
-// Nesting this the other way would probably be faster.
+void __cfaehm__throw_terminate( exception * val ) {
+        // DEBUG
+        printf("Throwing termination exception\n");
+
+        __cfaehm__allocate_exception( val );
+        __cfaehm__begin_unwind();
+}
+
 void __cfaehm__rethrow_terminate(void) {
         // DEBUG
         printf("Rethrowing termination exception\n");
 
-        __cfaehm__throw_terminate(&shared_stack.current_exception);
+        __cfaehm__begin_unwind();
 }
 
@@ -263 +356 @@
                                         _Unwind_Reason_Code (*matcher)(exception *) =
                                                 MATCHER_FROM_CONTEXT(context);
-                                        int index = matcher(&shared_stack.current_exception);
+                                        int index = matcher(shared_stack.current_exception);
                                         _Unwind_Reason_Code ret = (0 == index)
                                                 ? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND;
@@ -359 +452 @@
         // Exception handler
         catch_block( shared_stack.current_handler_index,
-                    &shared_stack.current_exception );
+                     shared_stack.current_exception );
 }
 

src/libcfa/exception.h

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Jun 26 15:11:00 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:57:02 2017
-// Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Aug  4 15:20:00 2017
+// Update Count     : 5
 //
 
 #pragma once
 
-// Later to be a special structure type.
-typedef int exception;
 
 #ifdef __CFORALL__
 extern "C" {
 #endif
+
+struct __cfaehm__base_exception_t;
+typedef struct __cfaehm__base_exception_t exception;
+struct __cfaehm__base_exception_t_vtable {
+        const struct __cfaehm__base_exception_t_vtable * parent;
+        size_t size;
+        void (*copy)(struct __cfaehm__base_exception_t *this,
+                     struct __cfaehm__base_exception_t * other);
+        void (*free)(struct __cfaehm__base_exception_t *this);
+        const char (*msg)(struct __cfaehm__base_exception_t *this);
+};
+struct __cfaehm__base_exception_t {
+        struct __cfaehm__base_exception_t_vtable const * virtual_table;
+};
+extern struct __cfaehm__base_exception_t_vtable
+        ___cfaehm__base_exception_t_vtable_instance;
+
 
 // Used in throw statement translation.
@@ -34 +49 @@
     int (*match_block)(exception * except));
 
+// Clean-up the exception in catch blocks.
+void __cfaehm__cleanup_terminate(void * except);
+
 // Data structure creates a list of resume handlers.
 struct __cfaehm__try_resume_node {
@@ -40 +58 @@
 };
 
+// These act as constructor and destructor for the resume node.
 void __cfaehm__try_resume_setup(
     struct __cfaehm__try_resume_node * node,
@@ -47 +66 @@
 
 // Check for a standard way to call fake deconstructors.
-struct __cfaehm__cleanup_hook {
-};
+struct __cfaehm__cleanup_hook {};
 
 #ifdef __CFORALL__

src/libcfa/iostream

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul  7 08:35:59 2017
-// Update Count     : 118
+// Last Modified On : Wed Aug  9 16:42:47 2017
+// Update Count     : 131
 //
 
@@ -46 +46 @@
 }; // ostream
 
-trait writeable( otype T ) {
-        forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, T );
+// trait writeable( otype T ) {
+//      forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, T );
+// }; // writeable
+
+trait writeable( otype T, dtype ostype | ostream( ostype ) ) {
+        ostype * ?|?( ostype *, T );
 }; // writeable
 
@@ -77 +81 @@
 
 // tuples
-forall( dtype ostype, otype T, ttype Params | ostream( ostype ) | writeable( T ) | { ostype * ?|?( ostype *, Params ); } ) ostype * ?|?( ostype * os, T arg, Params rest );
+forall( dtype ostype, otype T, ttype Params | writeable( T, ostype ) | { ostype * ?|?( ostype *, Params ); } )
+ostype * ?|?( ostype * os, T arg, Params rest );
 
 // manipulators
@@ -90 +95 @@
 
 // writes the range [begin, end) to the given stream
-forall( otype elt_type | writeable( elt_type ), otype iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
-void write( iterator_type begin, iterator_type end, os_type *os );
+forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) )
+void write( iterator_type begin, iterator_type end, ostype * os );
 
-forall( otype elt_type | writeable( elt_type ), otype iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
-void write_reverse( iterator_type begin, iterator_type end, os_type *os );
+forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) )
+void write_reverse( iterator_type begin, iterator_type end, ostype * os );
 
 //---------------------------------------

src/libcfa/iostream.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Jul 16 21:12:03 2017
-// Update Count     : 398
+// Last Modified On : Wed Aug  9 16:46:51 2017
+// Update Count     : 401
 //
 
@@ -193 +193 @@
 
 // tuples
-forall( dtype ostype, otype T, ttype Params | ostream( ostype ) | writeable( T ) | { ostype * ?|?( ostype *, Params ); } )
+forall( dtype ostype, otype T, ttype Params | writeable( T, ostype ) | { ostype * ?|?( ostype *, Params ); } )
 ostype * ?|?( ostype * os, T arg, Params rest ) {
         os | arg;                                                                                       // print first argument
@@ -256 +256 @@
 //---------------------------------------
 
-forall( otype elttype | writeable( elttype ), otype iteratortype | iterator( iteratortype, elttype ), dtype ostype | ostream( ostype ) )
-void write( iteratortype begin, iteratortype end, ostype * os ) {
-        void print( elttype i ) { os | i; }
+forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) )
+void write( iterator_type begin, iterator_type end, ostype * os ) {
+        void print( elt_type i ) { os | i; }
         for_each( begin, end, print );
 } // ?|?
 
-forall( otype elttype | writeable( elttype ), otype iteratortype | iterator( iteratortype, elttype ), dtype ostype | ostream( ostype ) )
-void write_reverse( iteratortype begin, iteratortype end, ostype * os ) {
-        void print( elttype i ) { os | i; }
+forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) )
+void write_reverse( iterator_type begin, iterator_type end, ostype * os ) {
+        void print( elt_type i ) { os | i; }
         for_each_reverse( begin, end, print );
 } // ?|?

src/libcfa/math

@@ -10 +10 @@
 // Created On       : Mon Apr 18 23:37:04 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 21 17:03:13 2017
-// Update Count     : 101
+// Last Modified On : Mon Aug  7 07:51:15 2017
+// Update Count     : 108
 //
 
@@ -18 +18 @@
 #include <math.h>
 #include <complex.h>
+
+//---------------------- General ----------------------
 
 static inline float ?%?( float x, float y ) { return fmodf( x, y ); }
@@ -37 +39 @@
 static inline [ int, long double ] remquo( long double x, long double y ) { int quo; x = remquol( x, y, &quo ); return [ quo, x ]; }
 
-// alternative name for remquo
-static inline float div( float x, float y, int * quo ) { return remquof( x, y, quo ); }
-static inline double div( double x, double y, int * quo ) { return remquo( x, y, quo ); }
-static inline long double div( long double x, long double y, int * quo ) { return remquol( x, y, quo ); }
-static inline [ int, float ] div( float x, float y ) { int quo; x = remquof( x, y, &quo ); return [ quo, x ]; }
-static inline [ int, double ] div( double x, double y ) { int quo; x = remquo( x, y, &quo ); return [ quo, x ]; }
-static inline [ int, long double ] div( long double x, long double y ) { int quo; x = remquol( x, y, &quo ); return [ quo, x ]; }
+static inline [ float, float ] div( float x, float y ) { y = modff( x / y, &x ); return [ x, y ]; }
+static inline [ double, double ] div( double x, double y ) { y = modf( x / y, &x ); return [ x, y ]; }
+static inline [ long double, long double ] div( long double x, long double y ) { y = modfl( x / y, &x ); return [ x, y ]; }
 
 static inline float fma( float x, float y, float z ) { return fmaf( x, y, z ); }

src/libcfa/stdhdr/assert.h

@@ -10 +10 @@
 // Created On       : Mon Jul  4 23:25:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jul 20 21:06:48 2017
-// Update Count     : 11
+// Last Modified On : Mon Jul 31 23:09:32 2017
+// Update Count     : 13
 // 
 
@@ -25 +25 @@
         #define __STRINGIFY__(str) #str
         #define __VSTRINGIFY__(str) __STRINGIFY__(str)
-        #define assertf(expr, fmt, ...) ((expr) ? ((void)0) : __assert_fail_f(__VSTRINGIFY__(expr), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, ## __VA_ARGS__ ))
-        void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) __attribute__((noreturn));
+        #define assertf( expr, fmt, ... ) ((expr) ? ((void)0) : __assert_fail_f(__VSTRINGIFY__(expr), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, ## __VA_ARGS__ ))
+
+        void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) __attribute__((noreturn, format( printf, 5, 6) ));
 #endif
 

src/libcfa/stdlib

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jul 20 14:32:37 2017
-// Update Count     : 220
+// Last Modified On : Mon Aug  7 11:19:07 2017
+// Update Count     : 223
 //
 
@@ -183 +183 @@
 //---------------------------------------
 
+[ int, int ] div( int num, int denom );
+[ long int, long int ] div( long int num, long int denom );
+[ long long int, long long int ] div( long long int num, long long int denom );
 forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
-[ T, T ] div( T t1, T t2 );
+[ T, T ] div( T num, T demon );
 
 //---------------------------------------

src/libcfa/stdlib.c

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jul 20 16:01:40 2017
-// Update Count     : 282
+// Last Modified On : Tue Aug  8 17:31:13 2017
+// Update Count     : 291
 //
 
@@ -255 +255 @@
 //---------------------------------------
 
+[ int, int ] div( int num, int denom ) { div_t qr = div( num, denom ); return [ qr.quot, qr.rem ]; }
+[ long int, long int ] div( long int num, long int denom ) { ldiv_t qr = ldiv( num, denom ); return [ qr.quot, qr.rem ]; }
+[ long long int, long long int ] div( long long int num, long long int denom ) { lldiv_t qr = lldiv( num, denom ); return [ qr.quot, qr.rem ]; }
 forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
-[ T, T ] div( T t1, T t2 ) { return [ t1 / t2, t1 % t2 ]; }
+[ T, T ] div( T num, T denom ) { return [ num / denom, num % denom ]; }
 
 //---------------------------------------

src/tests/.expect/32/math.txt

@@ -2 +2 @@
 remainder:-1 -1 -1
 remquo:7 0.0999999 7 0.1 7 0.0999999999999999999
-div:7 0.0999999 7 0.1 7 0.0999999999999999999
+div:7, 0.2 7, 0.2 7, 0.2
 fma:-2 -2 -2
 fdim:2 2 2
@@ -55 +55 @@
 frexp:0.5 3 0.5 3 0.5 3
 ldexp:8 8 8
-modf:2 0.3 2 0.3 2 0.3 nextafter:2 2 2
+modf:2 0.3 2 0.3 2 0.3
+modf:2, 0.3 2, 0.3 2, 0.3
+nextafter:2 2 2
 nexttoward:2 2 2
 scalbn:16 16 16

src/tests/.expect/64/math.txt

@@ -2 +2 @@
 remainder:-1 -1 -1
 remquo:7 0.0999999 7 0.1 7 0.0999999999999999999
-div:7 0.0999999 7 0.1 7 0.0999999999999999999
+div:7, 0.2 7, 0.2 7, 0.2
 fma:-2 -2 -2
 fdim:2 2 2
@@ -55 +55 @@
 frexp:0.5 3 0.5 3 0.5 3
 ldexp:8 8 8
-modf:2 0.3 2 0.3 2 0.3 nextafter:2 2 2
+modf:2 0.3 2 0.3 2 0.3
+modf:2, 0.3 2, 0.3 2, 0.3
+nextafter:2 2 2
 nexttoward:2 2 2
 scalbn:16 16 16

src/tests/designations.c

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Thu Jun 29 15:26:36 2017
-// Last Modified By : Rob Schluntz
-// Last Modified On : Thu Jun 29 15:27:05 2017
-// Update Count     : 2
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Jul 27 11:46:35 2017
+// Update Count     : 3
 //
 
@@ -89 +89 @@
 };
 
+struct Fred {
+    double i[3];
+    int j;
+    struct Mary {
+        struct Jane {
+            double j;
+        } j;
+        double i;
+    } m;
+};
+struct Fred s1 @= { .m.j : 3 };
+struct Fred s2 @= { .i : { [2] : 2 } };
+
 int main() {
         // simple designation case - starting from beginning of structure, leaves ptr default-initialized (zero)
@@ -199 +212 @@
         };
 #endif
-
+        // array designation
+        int i[2] = { [1] : 3 };
         // allowed to have 'too many' initialized lists - essentially they are ignored.
         int i1 = { 3 };
@@ -240 +254 @@
         const char * str0 = "hello";
         char str1[] = "hello";
+        const char c1[] = "abc";
+        const char c2[] = { 'a', 'b', 'c' };
+        const char c3[][2] = { { 'a', 'b' }, { 'c', 'd'}, { 'c', 'd'} };
 }
 

src/tests/except-0.c

@@ -6 +6 @@
 #include <stdbool.h>
 
+// Local type to mark exits from scopes. (see ERROR)
 struct signal_exit {
         const char * area;
@@ -19 +20 @@
 }
 
-void terminate(int except_value) {
+
+// Local Exception Types and manual vtable types.
+//#define TRIVIAL_EXCEPTION(name) //TRIVAL_EXCEPTION(yin)
+struct yin;
+struct yin_vtable {
+        struct exception_t_vtable const * parent;
+        size_t size;
+    void (*copy)(yin *this, yin * other);
+    void (*free)(yin *this);
+    const char (*msg)(yin *this);
+};
+struct yin {
+        struct yin_vtable const * parent;
+};
+void yin_msg(yin) {
+        return "in";
+}
+yin_vtable _yin_vtable_instance = {
+        &_exception_t_vtable_instance, sizeof(yin), ?{}, ^?{}, yin_msg
+}
+
+
+void terminate(exception * except_value) {
         signal_exit a = {"terminate function"};
         throw except_value;
@@ -25 +48 @@
 }
 
-void resume(int except_value) {
+void resume(exception * except_value) {
         signal_exit a = {"resume function"};
         throwResume except_value;

src/tests/math.c

@@ -10 +10 @@
 // Created On       : Fri Apr 22 14:59:21 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 21 10:32:04 2017
-// Update Count     : 73
+// Last Modified On : Wed Aug  9 07:20:49 2017
+// Update Count     : 77
 // 
 
@@ -31 +31 @@
         l = remquo( 3.6L, 0.5L, &quot );
         sout | quot | l | endl;
-        f = div( 3.6F, 0.5F, &quot );
-        sout | "div:" | quot | f;
-        d = div( 3.6D, 0.5F, &quot );
-        sout | quot | d;
-        l = div( 3.6L, 0.5L, &quot );
-        sout | quot | l | endl;
+        sout | "div:" | div( 3.6F, 0.5F ) | div( 3.6D, 0.5D ) | div( 3.6L, 0.5L ) | endl;
         sout | "fma:" | fma( 3.0F, -1.0F, 1.0F ) | fma( 3.0D, -1.0D, 1.0D ) | fma( 3.0L, -1.0L, , 1.0L ) | endl;
         sout | "fdim:" | fdim( 1.0F, -1.0F ) | fdim( 1.0D, -1.0D ) | fdim( 1.0L, -1.0L ) | endl;
@@ -137 +132 @@
         sout | di | d;
         l = modf( 2.3L, &ldi );
-        sout | ldi | l;
+        sout | ldi | l | endl;
+        sout | "modf:" | modf( 2.3F ) | modf( 2.3D ) | modf( 2.3L ) | endl;
         sout | "nextafter:" | nextafter( 2.0F, 3.0F ) | nextafter( 2.0D, 3.0D ) | nextafter( 2.0L, 3.0L ) | endl;
         sout | "nexttoward:" | nexttoward( 2.0F, 3.0F ) | nexttoward( 2.0D, 3.0D ) | nexttoward( 2.0L, 3.0L ) | endl;