Changeset 22f94a4 for src

Timestamp:

Aug 11, 2020, 4:40:15 PM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

0d070ca

Parents:

07d867b (diff), 129674b (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' into new-ast

Location:

src

Files:

• Common/PassVisitor.proto.h (modified) (1 diff)
• Common/ScopedMap.h (modified) (1 diff)
• Concurrency/Keywords.cc (modified) (5 diffs)
• Concurrency/Waitfor.cc (modified) (3 diffs)
• ControlStruct/ExceptTranslate.cc (modified) (19 diffs)
• ControlStruct/ExceptTranslate.h (modified) (2 diffs)
• GenPoly/InstantiateGeneric.cc (modified) (4 diffs)
• GenPoly/Specialize.cc (modified) (4 diffs)
• Makefile.in (deleted)
• Parser/DeclarationNode.cc (modified) (2 diffs)
• Parser/ExpressionNode.cc (modified) (7 diffs)
• Parser/ParseNode.h (modified) (2 diffs)
• Parser/module.mk (modified) (1 diff)
• Parser/parser.yy (modified) (13 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (2 diffs)
• ResolvExpr/ConversionCost.cc (modified) (3 diffs)
• ResolvExpr/ConversionCost.h (modified) (3 diffs)
• SynTree/Expression.h (modified) (1 diff)
• Virtual/ExpandCasts.cc (modified) (10 diffs)
• main.cc (modified) (3 diffs)

src/Common/PassVisitor.proto.h

@@ -38 +38 @@
         };
 
-        std::stack< cleanup_t, std::vector<cleanup_t> > cleanups;
+        std::stack< cleanup_t, std::vector< cleanup_t > > cleanups;
 };
 

src/Common/ScopedMap.h

@@ -93 +93 @@
 
                 reference operator* () { return *it; }
-                pointer operator-> () { return it.operator->(); }
+                pointer operator-> () const { return it.operator->(); }
 
                 iterator& operator++ () {

src/Concurrency/Keywords.cc

@@ -510 +510 @@
                                                 new CastExpr(
                                                         new VariableExpr( func->get_functionType()->get_parameters().front() ),
-                                                        func->get_functionType()->get_parameters().front()->get_type()->stripReferences()->clone()
+                                                        func->get_functionType()->get_parameters().front()->get_type()->stripReferences()->clone(),
+                                                        false
                                                 )
                                         )
@@ -888 +889 @@
                         new SingleInit( new UntypedExpr(
                                 new NameExpr( "get_monitor" ),
-                                {  new CastExpr( new VariableExpr( args.front() ), arg_type ) }
+                                {  new CastExpr( new VariableExpr( args.front() ), arg_type, false ) }
                         ))
                 );
@@ -909 +910 @@
                                         {
                                                 new SingleInit( new AddressExpr( new VariableExpr( monitors ) ) ),
-                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone() ) )
+                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone(), false ) )
                                         },
                                         noDesignators,
@@ -946 +947 @@
                                         return new SingleInit( new UntypedExpr(
                                                 new NameExpr( "get_monitor" ),
-                                                {  new CastExpr( new VariableExpr( var ), type ) }
+                                                {  new CastExpr( new VariableExpr( var ), type, false ) }
                                         ) );
                                 })
@@ -970 +971 @@
                                                 new SingleInit( new VariableExpr( monitors ) ),
                                                 new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) ),
-                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone() ) )
+                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone(), false ) )
                                         },
                                         noDesignators,

src/Concurrency/Waitfor.cc

@@ -384 +384 @@
                                                                 decl_monitor
                                                         )
-                                                )
+                                                ),
+                                                false
                                         );
 
@@ -408 +409 @@
                         new CompoundStmt({
                                 makeAccStatement( acceptables, index, "is_dtor", detectIsDtor( clause.target.function )                                    , indexer ),
-                                makeAccStatement( acceptables, index, "func"   , new CastExpr( clause.target.function, fptr_t )                            , indexer ),
+                                makeAccStatement( acceptables, index, "func"   , new CastExpr( clause.target.function, fptr_t, false )                     , indexer ),
                                 makeAccStatement( acceptables, index, "data"   , new VariableExpr( monitors )                                              , indexer ),
                                 makeAccStatement( acceptables, index, "size"   , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ), indexer ),
@@ -531 +532 @@
                                                                 decl_mask
                                                         )
-                                                )
+                                                ),
+                                                false
                                         ),
                                         timeout

src/ControlStruct/ExceptTranslate.cc

@@ -10 +10 @@
 // Created On       : Wed Jun 14 16:49:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Mar 27 11:58:00 2020
-// Update Count     : 13
+// Last Modified On : Wed Jun 24 11:18:00 2020
+// Update Count     : 17
 //
 
@@ -64 +64 @@
         }
 
-        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;
-
+        class ThrowMutatorCore : public WithGuards {
+                ObjectDecl * terminate_handler_except;
+                enum Context { NoHandler, TerHandler, ResHandler } cur_context;
+
+                // The helper functions for code/syntree generation.
+                Statement * create_either_throw(
+                        ThrowStmt * throwStmt, const char * throwFunc );
+                Statement * create_terminate_rethrow( ThrowStmt * throwStmt );
+
+        public:
+                ThrowMutatorCore() :
+                        terminate_handler_except( nullptr ),
+                        cur_context( NoHandler )
+                {}
+
+                void premutate( CatchStmt *catchStmt );
+                Statement * postmutate( ThrowStmt *throwStmt );
+        };
+
+        // ThrowStmt Mutation Helpers
+
+        Statement * ThrowMutatorCore::create_either_throw(
+                        ThrowStmt * throwStmt, const char * throwFunc ) {
+                // `throwFunc`( `throwStmt->get_name()` );
+                UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
+                call->get_args().push_back( throwStmt->get_expr() );
+                throwStmt->set_expr( nullptr );
+                delete throwStmt;
+                return new ExprStmt( call );
+        }
+
+        Statement * ThrowMutatorCore::create_terminate_rethrow(
+                        ThrowStmt *throwStmt ) {
+                // { `terminate_handler_except` = 0p; __rethrow_terminate(); }
+                assert( nullptr == throwStmt->get_expr() );
+                assert( terminate_handler_except );
+
+                CompoundStmt * result = new CompoundStmt();
+                result->labels =  throwStmt->labels;
+                result->push_back( new ExprStmt( UntypedExpr::createAssign(
+                        nameOf( terminate_handler_except ),
+                        new ConstantExpr( Constant::null(
+                                terminate_handler_except->get_type()->clone()
+                                ) )
+                        ) ) );
+                result->push_back( new ExprStmt(
+                        new UntypedExpr( new NameExpr( "__cfaehm_rethrow_terminate" ) )
+                        ) );
+                delete throwStmt;
+                return result;
+        }
+
+        // Visiting/Mutating Functions
+
+        void ThrowMutatorCore::premutate( CatchStmt *catchStmt ) {
+                // Validate the statement's form.
+                ObjectDecl * decl = dynamic_cast<ObjectDecl *>( catchStmt->get_decl() );
+                // Also checking the type would be nice.
+                if ( !decl || !dynamic_cast<PointerType *>( decl->type ) ) {
+                        std::string kind = (CatchStmt::Terminate == catchStmt->kind) ? "catch" : "catchResume";
+                        SemanticError( catchStmt->location, kind + " must have pointer to an exception type" );
+                }
+
+                // Track the handler context.
+                GuardValue( cur_context );
+                if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
+                        cur_context = TerHandler;
+
+                        GuardValue( terminate_handler_except );
+                        terminate_handler_except = decl;
+                } else {
+                        cur_context = ResHandler;
+                }
+        }
+
+        Statement * ThrowMutatorCore::postmutate( ThrowStmt *throwStmt ) {
+                // Ignoring throwStmt->get_target() for now.
+                if ( ThrowStmt::Terminate == throwStmt->get_kind() ) {
+                        if ( throwStmt->get_expr() ) {
+                                return create_either_throw( throwStmt, "$throw" );
+                        } else if ( TerHandler == cur_context ) {
+                                return create_terminate_rethrow( throwStmt );
+                        } else {
+                                abort("Invalid throw in %s at %i\n",
+                                        throwStmt->location.filename.c_str(),
+                                        throwStmt->location.first_line);
+                        }
+                } else {
+                        if ( throwStmt->get_expr() ) {
+                                return create_either_throw( throwStmt, "$throwResume" );
+                        } else if ( ResHandler == cur_context ) {
+                                // This has to be handled later.
+                                return throwStmt;
+                        } else {
+                                abort("Invalid throwResume in %s at %i\n",
+                                        throwStmt->location.filename.c_str(),
+                                        throwStmt->location.first_line);
+                        }
+                }
+        }
+
+        class TryMutatorCore {
                 // The built in types used in translation.
                 StructDecl * except_decl;
@@ -82 +172 @@
 
                 // 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 );
@@ -101 +185 @@
                 FunctionDecl * create_finally_wrapper( TryStmt * tryStmt );
                 ObjectDecl * create_finally_hook( FunctionDecl * finally_wrapper );
+                Statement * create_resume_rethrow( ThrowStmt * throwStmt );
 
                 // Types used in translation, make sure to use clone.
@@ -121 +206 @@
 
         public:
-                ExceptionMutatorCore() :
-                        cur_context( NoHandler ),
-                        handler_except_decl( nullptr ),
+                TryMutatorCore() :
                         except_decl( nullptr ), node_decl( nullptr ), hook_decl( nullptr ),
                         try_func_t( noQualifiers, false ),
@@ -132 +215 @@
                 {}
 
-                void premutate( CatchStmt *catchStmt );
                 void premutate( StructDecl *structDecl );
+                Statement * postmutate( TryStmt *tryStmt );
                 Statement * postmutate( ThrowStmt *throwStmt );
-                Statement * postmutate( TryStmt *tryStmt );
         };
 
-        void ExceptionMutatorCore::init_func_types() {
+        void TryMutatorCore::init_func_types() {
                 assert( except_decl );
 
@@ -196 +278 @@
         }
 
-        // ThrowStmt Mutation Helpers
-
-        Statement * ExceptionMutatorCore::create_given_throw(
-                        const char * throwFunc, ThrowStmt * throwStmt ) {
-                // `throwFunc`( `throwStmt->get_name` );
-                UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
-                call->get_args().push_back( throwStmt->get_expr() );
-                throwStmt->set_expr( nullptr );
-                delete throwStmt;
-                return new ExprStmt( call );
-        }
-
-        Statement * ExceptionMutatorCore::create_terminate_throw(
-                        ThrowStmt *throwStmt ) {
-                // __throw_terminate( `throwStmt->get_name()` ); }
-                return create_given_throw( "__cfaehm_throw_terminate", throwStmt );
-        }
-
-        Statement * ExceptionMutatorCore::create_terminate_rethrow(
-                        ThrowStmt *throwStmt ) {
-                // { `handler_except_decl` = NULL; __rethrow_terminate(); }
-                assert( nullptr == throwStmt->get_expr() );
-                assert( handler_except_decl );
-
-                CompoundStmt * result = new CompoundStmt();
-                result->labels =  throwStmt->labels;
-                result->push_back( new ExprStmt( UntypedExpr::createAssign(
-                        nameOf( handler_except_decl ),
-                        new ConstantExpr( Constant::null(
-                                new PointerType(
-                                        noQualifiers,
-                                        handler_except_decl->get_type()->clone()
-                                        )
-                                ) )
-                        ) ) );
-                result->push_back( new ExprStmt(
-                        new UntypedExpr( new NameExpr( "__cfaehm_rethrow_terminate" ) )
-                        ) );
-                delete throwStmt;
-                return result;
-        }
-
-        Statement * ExceptionMutatorCore::create_resume_throw(
-                        ThrowStmt *throwStmt ) {
-                // __throw_resume( `throwStmt->get_name` );
-                return create_given_throw( "__cfaehm_throw_resume", throwStmt );
-        }
-
-        Statement * ExceptionMutatorCore::create_resume_rethrow(
-                        ThrowStmt *throwStmt ) {
-                // return false;
-                Statement * result = new ReturnStmt(
-                        new ConstantExpr( Constant::from_bool( false ) )
-                        );
-                result->labels = throwStmt->labels;
-                delete throwStmt;
-                return result;
-        }
-
         // TryStmt Mutation Helpers
 
-        CompoundStmt * ExceptionMutatorCore::take_try_block( TryStmt *tryStmt ) {
+        CompoundStmt * TryMutatorCore::take_try_block( TryStmt *tryStmt ) {
                 CompoundStmt * block = tryStmt->get_block();
                 tryStmt->set_block( nullptr );
@@ -263 +286 @@
         }
 
-        FunctionDecl * ExceptionMutatorCore::create_try_wrapper(
+        FunctionDecl * TryMutatorCore::create_try_wrapper(
                         CompoundStmt *body ) {
 
@@ -270 +293 @@
         }
 
-        FunctionDecl * ExceptionMutatorCore::create_terminate_catch(
+        FunctionDecl * TryMutatorCore::create_terminate_catch(
                         CatchList &handlers ) {
                 std::list<CaseStmt *> handler_wrappers;
@@ -350 +373 @@
         // Create a single check from a moddified handler.
         // except_obj is referenced, modded_handler will be freed.
-        CompoundStmt * ExceptionMutatorCore::create_single_matcher(
+        CompoundStmt * TryMutatorCore::create_single_matcher(
                         DeclarationWithType * except_obj, CatchStmt * modded_handler ) {
                 // {
@@ -388 +411 @@
         }
 
-        FunctionDecl * ExceptionMutatorCore::create_terminate_match(
+        FunctionDecl * TryMutatorCore::create_terminate_match(
                         CatchList &handlers ) {
                 // int match(exception * except) {
@@ -425 +448 @@
         }
 
-        CompoundStmt * ExceptionMutatorCore::create_terminate_caller(
+        CompoundStmt * TryMutatorCore::create_terminate_caller(
                         FunctionDecl * try_wrapper,
                         FunctionDecl * terminate_catch,
@@ -443 +466 @@
         }
 
-        FunctionDecl * ExceptionMutatorCore::create_resume_handler(
+        FunctionDecl * TryMutatorCore::create_resume_handler(
                         CatchList &handlers ) {
                 // bool handle(exception * except) {
@@ -480 +503 @@
         }
 
-        CompoundStmt * ExceptionMutatorCore::create_resume_wrapper(
+        CompoundStmt * TryMutatorCore::create_resume_wrapper(
                         Statement * wraps,
                         FunctionDecl * resume_handler ) {
@@ -524 +547 @@
         }
 
-        FunctionDecl * ExceptionMutatorCore::create_finally_wrapper(
+        FunctionDecl * TryMutatorCore::create_finally_wrapper(
                         TryStmt * tryStmt ) {
-                // void finally() { <finally code> }
+                // void finally() { `finally->block` }
                 FinallyStmt * finally = tryStmt->get_finally();
                 CompoundStmt * body = finally->get_block();
@@ -537 +560 @@
         }
 
-        ObjectDecl * ExceptionMutatorCore::create_finally_hook(
+        ObjectDecl * TryMutatorCore::create_finally_hook(
                         FunctionDecl * finally_wrapper ) {
                 // struct __cfaehm_cleanup_hook __finally_hook
-                //      __attribute__((cleanup( finally_wrapper )));
+                //      __attribute__((cleanup( `finally_wrapper` )));
 
                 // Make Cleanup Attribute.
@@ -564 +587 @@
         }
 
+        Statement * TryMutatorCore::create_resume_rethrow( ThrowStmt *throwStmt ) {
+                // return false;
+                Statement * result = new ReturnStmt(
+                        new ConstantExpr( Constant::from_bool( false ) )
+                        );
+                result->labels = throwStmt->labels;
+                delete throwStmt;
+                return result;
+        }
+
         // 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() ) {
-                        SemanticError(catchStmt->location, "catch must have exception type");
-                } else {
-                        SemanticError(catchStmt->location, "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 ) {
+        void TryMutatorCore::premutate( StructDecl *structDecl ) {
                 if ( !structDecl->has_body() ) {
                         // Skip children?
@@ -604 +613 @@
                         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() ) {
-                        if ( throwStmt->get_expr() ) {
-                                return create_terminate_throw( throwStmt );
-                        } else if ( TerHandler == cur_context ) {
-                                return create_terminate_rethrow( throwStmt );
-                        } else {
-                                abort("Invalid throw in %s at %i\n",
-                                        throwStmt->location.filename.c_str(),
-                                        throwStmt->location.first_line);
-                        }
-                } else {
-                        if ( throwStmt->get_expr() ) {
-                                return create_resume_throw( throwStmt );
-                        } else if ( ResHandler == cur_context ) {
-                                return create_resume_rethrow( throwStmt );
-                        } else {
-                                abort("Invalid throwResume in %s at %i\n",
-                                        throwStmt->location.filename.c_str(),
-                                        throwStmt->location.first_line);
-                        }
-                }
-        }
-
-        Statement * ExceptionMutatorCore::postmutate( TryStmt *tryStmt ) {
+        }
+
+        Statement * TryMutatorCore::postmutate( TryStmt *tryStmt ) {
                 assert( except_decl );
                 assert( node_decl );
@@ -688 +669 @@
         }
 
-        void translateEHM( std::list< Declaration *> & translationUnit ) {
-                PassVisitor<ExceptionMutatorCore> translator;
+        Statement * TryMutatorCore::postmutate( ThrowStmt *throwStmt ) {
+                // Only valid `throwResume;` statements should remain. (2/3 checks)
+                assert( ThrowStmt::Resume == throwStmt->kind && ! throwStmt->expr );
+                return create_resume_rethrow( throwStmt );
+        }
+
+        void translateThrows( std::list< Declaration *> & translationUnit ) {
+                PassVisitor<ThrowMutatorCore> translator;
                 mutateAll( translationUnit, translator );
         }
+
+        void translateTries( std::list< Declaration *> & translationUnit ) {
+                PassVisitor<TryMutatorCore> translator;
+                mutateAll( translationUnit, translator );
+        }
 }

src/ControlStruct/ExceptTranslate.h

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Tus Jun 06 10:13:00 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:19:23 2017
-// Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Tus May 19 11:47:00 2020
+// Update Count     : 5
 //
 
@@ -21 +21 @@
 
 namespace ControlStruct {
-        void translateEHM( std::list< Declaration *> & translationUnit );
-        // Converts exception handling structures into their underlying C code.  Translation does use the exception
-        // handling header, make sure it is visible wherever translation occurs.
+        void translateThrows( std::list< Declaration *> & translationUnit );
+        /* Replaces all throw & throwResume statements with function calls.
+         * These still need to be resolved, so call this before the reslover.
+         */
+
+        void translateTries( std::list< Declaration *> & translationUnit );
+        /* Replaces all try blocks (and their many clauses) with function definitions and calls.
+         * This uses the exception built-ins to produce typed output and should take place after
+         * the resolver. It also produces virtual casts and should happen before they are expanded.
+         */
 }
 

src/GenPoly/InstantiateGeneric.cc

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Thu Aug 04 18:33:00 2016
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Thu Aug 04 18:33:00 2016
-// Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jul 16 10:17:00 2020
+// Update Count     : 2
 //
 #include "InstantiateGeneric.h"
@@ -297 +297 @@
         }
 
+        template< typename AggrInst >
+        static AggrInst * asForward( AggrInst * decl ) {
+                if ( !decl->body ) {
+                        return nullptr;
+                }
+                decl = decl->clone();
+                decl->body = false;
+                deleteAll( decl->members );
+                decl->members.clear();
+                return decl;
+        }
+
         void GenericInstantiator::stripDtypeParams( AggregateDecl *base, std::list< TypeDecl* >& baseParams, const std::list< TypeExpr* >& typeSubs ) {
                 substituteMembers( base->get_members(), baseParams, typeSubs );
@@ -373 +385 @@
                                 concDecl->set_body( inst->get_baseStruct()->has_body() );
                                 substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
-                                insert( inst, typeSubs, concDecl ); // must insert before recursion
+                                // Forward declare before recursion. (TODO: Only when needed, #199.)
+                                insert( inst, typeSubs, concDecl );
+                                if ( StructDecl *forwardDecl = asForward( concDecl ) ) {
+                                        declsToAddBefore.push_back( forwardDecl );
+                                }
                                 concDecl->acceptMutator( *visitor ); // recursively instantiate members
                                 declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first
@@ -423 +439 @@
                                 concDecl->set_body( inst->get_baseUnion()->has_body() );
                                 substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
-                                insert( inst, typeSubs, concDecl ); // must insert before recursion
+                                // Forward declare before recursion. (TODO: Only when needed, #199.)
+                                insert( inst, typeSubs, concDecl );
+                                if ( UnionDecl *forwardDecl = asForward( concDecl ) ) {
+                                        declsToAddBefore.push_back( forwardDecl );
+                                }
                                 concDecl->acceptMutator( *visitor ); // recursively instantiate members
                                 declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first

src/GenPoly/Specialize.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 Dec 13 23:40:49 2019
-// Update Count     : 32
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Jul  2 17:42:00 2020
+// Update Count     : 33
 //
 
@@ -42 +42 @@
 
 namespace GenPoly {
-        struct Specialize final : public WithConstTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef<Specialize> {
+        struct Specialize final : public WithConstTypeSubstitution,
+                        public WithDeclsToAdd, public WithVisitorRef<Specialize> {
                 Expression * postmutate( ApplicationExpr *applicationExpr );
                 Expression * postmutate( CastExpr *castExpr );
@@ -248 +249 @@
                 } // if
 
-                // handle any specializations that may still be present
-                std::string oldParamPrefix = paramPrefix;
-                paramPrefix += "p";
-                // save stmtsToAddBefore in oldStmts
-                std::list< Statement* > oldStmts;
-                oldStmts.splice( oldStmts.end(), stmtsToAddBefore );
-                appExpr->acceptMutator( *visitor );
-                paramPrefix = oldParamPrefix;
-                // write any statements added for recursive specializations into the thunk body
-                thunkFunc->statements->kids.splice( thunkFunc->statements->kids.end(), stmtsToAddBefore );
-                // restore oldStmts into stmtsToAddBefore
-                stmtsToAddBefore.splice( stmtsToAddBefore.end(), oldStmts );
+                // Handle any specializations that may still be present.
+                {
+                        std::string oldParamPrefix = paramPrefix;
+                        paramPrefix += "p";
+                        std::list< Declaration * > oldDecls;
+                        oldDecls.splice( oldDecls.end(), declsToAddBefore );
+
+                        appExpr->acceptMutator( *visitor );
+                        // Write recursive specializations into the thunk body.
+                        for ( Declaration * decl : declsToAddBefore ) {
+                                thunkFunc->statements->kids.push_back( new DeclStmt( decl ) );
+                        }
+
+                        declsToAddBefore = std::move( oldDecls );
+                        paramPrefix = oldParamPrefix;
+                }
 
                 // add return (or valueless expression) to the thunk
@@ -270 +275 @@
                 thunkFunc->statements->kids.push_back( appStmt );
 
-                // add thunk definition to queue of statements to add
-                stmtsToAddBefore.push_back( new DeclStmt( thunkFunc ) );
+                // Add the thunk definition (converted to DeclStmt if appproprate).
+                declsToAddBefore.push_back( thunkFunc );
                 // return address of thunk function as replacement expression
                 return new AddressExpr( new VariableExpr( thunkFunc ) );

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Dec 16 15:32:22 2019
-// Update Count     : 1133
+// Last Modified On : Tue Jun  9 20:26:55 2020
+// Update Count     : 1134
 //
 
@@ -1115 +1115 @@
         // SUE's cannot have function specifiers, either
         //
-        //    inlne _Noreturn struct S { ... };         // disallowed
-        //    inlne _Noreturn enum   E { ... };         // disallowed
+        //    inline _Noreturn struct S { ... };                // disallowed
+        //    inline _Noreturn enum   E { ... };                // disallowed
         if ( funcSpecs.any() ) {
                 SemanticError( this, "invalid function specifier for " );

src/Parser/ExpressionNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Dec 18 21:14:58 2019
-// Update Count     : 981
+// Last Modified On : Wed Jul 15 08:24:08 2020
+// Update Count     : 1046
 //
 
@@ -85 +85 @@
         } // if
         // remove "lL" for these cases because it may not imply long
-        str.erase( posn );                                                                      // remove length
+        str.erase( posn );                                                                      // remove length suffix and "uU"
 } // lnthSuffix
 
@@ -108 +108 @@
 } // valueToType
 
+static void scanbin( string & str, unsigned long long int & v ) {
+        v = 0;
+        size_t last = str.length() - 1;                                         // last subscript of constant
+        for ( unsigned int i = 2;; ) {                                          // ignore prefix
+                if ( str[i] == '1' ) v |= 1;
+                i += 1;
+          if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break;
+                v <<= 1;
+        } // for
+} // scanbin
+
 Expression * build_constantInteger( string & str ) {
         static const BasicType::Kind kind[2][6] = {
                 // short (h) must be before char (hh) because shorter type has the longer suffix
-                { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt128, },
-                { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt128, },
+                { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, /* BasicType::SignedInt128 */ BasicType::LongLongSignedInt, },
+                { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, /* BasicType::UnsignedInt128 */ BasicType::LongLongUnsignedInt, },
         };
 
@@ -120 +131 @@
         }; // lnthsInt
 
-        unsigned long long int v;                                                       // converted integral value
-        size_t last = str.length() - 1;                                         // last subscript of constant
-        Expression * ret;
-        //string fred( str );
+        string str2( "0x0" );
+        unsigned long long int v, v2 = 0;                                       // converted integral value
+        Expression * ret, * ret2;
 
         int type = -1;                                                                          // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
@@ -139 +149 @@
         } // if
 
+        string::size_type posn;
+
+        // 'u' can appear before or after length suffix
+        if ( str.find_last_of( "uU" ) != string::npos ) Unsigned = true;
+
+        if ( isdigit( str[str.length() - 1] ) ) {                       // no suffix ?
+                lnthSuffix( str, type, ltype );                                 // could have length suffix
+                if ( type == 5 && Unsigned ) str.erase( str.length() - 1 ); // L128 and terminating "uU" ?
+        } else {
+                // At least one digit in integer constant, so safe to backup while looking for suffix.
+
+                posn = str.find_last_of( "pP" );                                // pointer value
+                if ( posn != string::npos ) { ltype = 5; str.erase( posn, 1 ); goto FINI; }
+
+                posn = str.find_last_of( "zZ" );                                // size_t
+                if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; }
+
+                posn = str.rfind( "hh" );                                               // char
+                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
+
+                posn = str.rfind( "HH" );                                               // char
+                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
+
+                posn = str.find_last_of( "hH" );                                // short
+                if ( posn != string::npos ) { type = 0; str.erase( posn, 1 ); goto FINI; }
+
+                posn = str.find_last_of( "nN" );                                // int (natural number)
+                if ( posn != string::npos ) { type = 2; str.erase( posn, 1 ); goto FINI; }
+
+                if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) { type = 4; goto FINI; }
+
+                lnthSuffix( str, type, ltype );                                 // must be after check for "ll"
+          FINI: ;
+        } // if
+
         // Cannot be just "0"/"1"; sscanf stops at the suffix, if any; value goes over the wall => always generate
 
+#if ! defined(__SIZEOF_INT128__)
+        if ( type == 5 ) SemanticError( yylloc, "int128 constant is not supported on this target " + str );
+#endif // ! __SIZEOF_INT128__
+        
         if ( str[0] == '0' ) {                                                          // radix character ?
                 dec = false;
                 if ( checkX( str[1] ) ) {                                               // hex constant ?
-                        sscanf( (char *)str.c_str(), "%llx", &v );
+                        if ( type < 5 ) {                                                       // not L128 ?
+                                sscanf( (char *)str.c_str(), "%llx", &v );
+                        } else {                                                                        // hex int128 constant
+                                unsigned int len = str.length();
+                                if ( len > (2 + 16 + 16) ) SemanticError( yylloc, "128-bit hexadecimal constant to large " + str );
+                          if ( len <= (2 + 16) ) goto FHEX1;            // hex digits < 2^64
+                                str2 = "0x" + str.substr( len - 16 );
+                                sscanf( (char *)str2.c_str(), "%llx", &v2 );
+                                str = str.substr( 0, len - 16 );
+                          FHEX1: ;
+                                sscanf( (char *)str.c_str(), "%llx", &v );
+                        } // if
                         //printf( "%llx %llu\n", v, v );
                 } else if ( checkB( str[1] ) ) {                                // binary constant ?
-                        v = 0;                                                                          // compute value
-                        for ( unsigned int i = 2;; ) {                          // ignore prefix
-                                if ( str[i] == '1' ) v |= 1;
-                                i += 1;
-                          if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break;
-                                v <<= 1;
-                        } // for
+                        unsigned int len = str.length();
+                        if ( type == 5 && len > 2 + 64 ) {
+                                if ( len > 2 + 64 + 64 ) SemanticError( yylloc, "128-bit binary constant to large " + str );
+                                str2 = "0b" + str.substr( len - 64 );
+                                str = str.substr( 0, len - 64 );
+                                scanbin( str2, v2 );
+                        } // if
+                        scanbin( str, v );
                         //printf( "%#llx %llu\n", v, v );
                 } else {                                                                                // octal constant
-                        sscanf( (char *)str.c_str(), "%llo", &v );
+                        if ( type < 5 ) {                                                       // not L128 ?
+                                sscanf( (char *)str.c_str(), "%llo", &v );
+#if defined(__SIZEOF_INT128__)
+                        } else {                                                                        // octal int128 constant
+                                unsigned int len = str.length();
+                                if ( len > 1 + 43 || (len == 1 + 43 && str[0] > '3') ) SemanticError( yylloc, "128-bit octal constant to large " + str );
+                                if ( len <= 1 + 21 ) {                                  // value < 21 octal digitis
+                                        sscanf( (char *)str.c_str(), "%llo", &v ); // leave value in octal
+                                } else {
+                                        sscanf( &str[len - 21], "%llo", &v );
+                                        __int128 val = v;                                       // accumulate bits
+                                        str[len - 21] ='\0';                            // shorten string
+                                        sscanf( &str[len == 43 ? 1 : 0], "%llo", &v );
+                                        val |= (__int128)v << 63;                       // store bits
+                                        if ( len == 1 + 43 ) {                          // most significant 2 bits ?
+                                                str[2] = '\0';                                  // shorten string
+                                                sscanf( &str[1], "%llo", &v );  // process most significant 2 bits
+                                                val |= (__int128)v << 126;              // store bits
+                                        } // if
+                                        v = val >> 64; v2 = (uint64_t)val;      // replace octal constant with 2 hex constants
+                                        char buf[32];
+                                        sprintf( buf, "%#llx", v2 );
+                                        str2 = buf;
+                                        sprintf( buf, "%#llx", v );
+                                        str = buf;
+                                } // if
+#endif // __SIZEOF_INT128__
+                        } // if
                         //printf( "%#llo %llu\n", v, v );
                 } // if
         } else {                                                                                        // decimal constant ?
-                sscanf( (char *)str.c_str(), "%llu", &v );
+                if ( type < 5 ) {                                                               // not L128 ?
+                        sscanf( (char *)str.c_str(), "%llu", &v );
+#if defined(__SIZEOF_INT128__)
+                } else {                                                                                // decimal int128 constant
+                        #define P10_UINT64 10'000'000'000'000'000'000ULL // 19 zeroes
+                        unsigned int len = str.length();
+                        if ( str.length() == 39 && str > (Unsigned ? "340282366920938463463374607431768211455" : "170141183460469231731687303715884105727") )
+                                SemanticError( yylloc, "128-bit decimal constant to large " + str );
+                        if ( len <= 19 ) {                                                      // value < 19 decimal digitis
+                                sscanf( (char *)str.c_str(), "%llu", &v ); // leave value in decimal
+                        } else {
+                                sscanf( &str[len - 19], "%llu", &v );
+                                __int128 val = v;                                               // accumulate bits
+                                str[len - 19] ='\0';                                    // shorten string
+                                sscanf( &str[len == 39 ? 1 : 0], "%llu", &v );
+                                val += (__int128)v * (__int128)P10_UINT64; // store bits
+                                if ( len == 39 ) {                                              // most significant 2 bits ?
+                                        str[1] = '\0';                                          // shorten string
+                                        sscanf( &str[0], "%llu", &v );          // process most significant 2 bits
+                                        val += (__int128)v * (__int128)P10_UINT64 * (__int128)P10_UINT64; // store bits
+                                } // if
+                                v = val >> 64; v2 = (uint64_t)val;              // replace decimal constant with 2 hex constants
+                                char buf[32];
+                                sprintf( buf, "%#llx", v2 );
+                                str2 = buf;
+                                sprintf( buf, "%#llx", v );
+                                str = buf;
+                        } // if
+#endif // __SIZEOF_INT128__
+                } // if
                 //printf( "%llu\n", v );
         } // if
 
-        string::size_type posn;
-
-        if ( isdigit( str[last] ) ) {                                           // no suffix ?
-                lnthSuffix( str, type, ltype );                                 // could have length suffix
-                if ( type == -1 ) {                                                             // no suffix
-                        valueToType( v, dec, type, Unsigned );
-                } // if
-        } else {
-                // At least one digit in integer constant, so safe to backup while looking for suffix.
-
-                posn = str.find_last_of( "pP" );
-                if ( posn != string::npos ) { valueToType( v, dec, type, Unsigned ); ltype = 5; str.erase( posn, 1 ); goto FINI; }
-
-                posn = str.find_last_of( "zZ" );
-                if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; }
-
-                // 'u' can appear before or after length suffix
-                if ( str.find_last_of( "uU" ) != string::npos ) Unsigned = true;
-
-                posn = str.rfind( "hh" );
-                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
-
-                posn = str.rfind( "HH" );
-                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
-
-                posn = str.find_last_of( "hH" );
-                if ( posn != string::npos ) { type = 0; str.erase( posn, 1 ); goto FINI; }
-
-                posn = str.find_last_of( "nN" );
-                if ( posn != string::npos ) { type = 2; str.erase( posn, 1 ); goto FINI; }
-
-                if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) { type = 4; goto FINI; }
-
-                lnthSuffix( str, type, ltype );                                 // must be after check for "ll"
-                if ( type == -1 ) {                                                             // only 'u' suffix ?
-                        valueToType( v, dec, type, Unsigned );
-                } // if
-          FINI: ;
-        } // if
+        if ( type == -1 ) {                                                                     // no suffix => determine type from value size
+                valueToType( v, dec, type, Unsigned );
+        } // if
+        /* printf( "%s %llo %s %llo\n", str.c_str(), v, str2.c_str(), v2 ); */
 
         //if ( !( 0 <= type && type <= 6 ) ) { printf( "%s %lu %d %s\n", fred.c_str(), fred.length(), type, str.c_str() ); }
@@ -214 +296 @@
         } else if ( ltype != -1 ) {                                                     // explicit length ?
                 if ( ltype == 6 ) {                                                             // int128, (int128)constant
-                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
+//                      ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
+                        ret2 = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::LongLongSignedInt ), str2, v2 ) );
+                        ret = build_compoundLiteral( DeclarationNode::newBasicType( DeclarationNode::Int128 )->addType( DeclarationNode::newSignedNess( DeclarationNode::Unsigned ) ),
+                                                                                 new InitializerNode( (InitializerNode *)(new InitializerNode( new ExpressionNode( v2 == 0 ? ret2 : ret ) ))->set_last( new InitializerNode( new ExpressionNode( v2 == 0 ? ret : ret2 ) ) ), true ) );
                 } else {                                                                                // explicit length, (length_type)constant
                         ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][ltype], false ), false );
@@ -342 +427 @@
                 if ( str[1] == '8' ) goto Default;                              // utf-8 characters => array of char
                 // lookup type of associated typedef
-                strtype = new TypeInstType( Type::Qualifiers( Type::Const ), "char16_t", false );
+                strtype = new TypeInstType( Type::Qualifiers( ), "char16_t", false );
                 break;
           case 'U':
-                strtype = new TypeInstType( Type::Qualifiers( Type::Const ), "char32_t", false );
+                strtype = new TypeInstType( Type::Qualifiers( ), "char32_t", false );
                 break;
           case 'L':
-                strtype = new TypeInstType( Type::Qualifiers( Type::Const ), "wchar_t", false );
+                strtype = new TypeInstType( Type::Qualifiers( ), "wchar_t", false );
                 break;
           Default:                                                                                      // char default string type
           default:
-                strtype = new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char );
+                strtype = new BasicType( Type::Qualifiers( ), BasicType::Char );
         } // switch
         ArrayType * at = new ArrayType( noQualifiers, strtype,

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 17:56:02 2020
-// Update Count     : 891
+// Last Modified On : Mon Jul  6 09:33:32 2020
+// Update Count     : 892
 //
 
@@ -86 +86 @@
 class InitializerNode : public ParseNode {
   public:
-        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
+        InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr );
         InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
         InitializerNode( bool isDelete );

src/Parser/module.mk

@@ -17 +17 @@
 BUILT_SOURCES = Parser/parser.hh
 
-AM_YFLAGS = -d -t -v
+AM_YFLAGS = -d -t -v -Wno-yacc
 
 SRC += \

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Apr 27 12:25:42 2020
-// Update Count     : 4483
+// Last Modified On : Thu May 28 12:11:45 2020
+// Update Count     : 4500
 //
 
@@ -329 +329 @@
 %type<en> conditional_expression                constant_expression                     assignment_expression           assignment_expression_opt
 %type<en> comma_expression                              comma_expression_opt
-%type<en> argument_expression_list              argument_expression                     default_initialize_opt
+%type<en> argument_expression_list_opt          argument_expression                     default_initialize_opt
 %type<ifctl> if_control_expression
 %type<fctl> for_control_expression              for_control_expression_list
@@ -624 +624 @@
                 // equivalent to the old x[i,j].
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
-        | postfix_expression '{' argument_expression_list '}' // CFA, constructor call
+        | postfix_expression '{' argument_expression_list_opt '}' // CFA, constructor call
                 {
                         Token fn;
@@ -630 +630 @@
                         $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
                 }
-        | postfix_expression '(' argument_expression_list ')'
+        | postfix_expression '(' argument_expression_list_opt ')'
                 { $$ = new ExpressionNode( build_func( $1, $3 ) ); }
         | postfix_expression '`' identifier                                     // CFA, postfix call
@@ -662 +662 @@
         | '(' type_no_function ')' '@' '{' initializer_list_opt comma_opt '}' // CFA, explicit C compound-literal
                 { $$ = new ExpressionNode( build_compoundLiteral( $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
-        | '^' primary_expression '{' argument_expression_list '}' // CFA, destructor call
+        | '^' primary_expression '{' argument_expression_list_opt '}' // CFA, destructor call
                 {
                         Token fn;
@@ -670 +670 @@
         ;
 
-argument_expression_list:
+argument_expression_list_opt:
         // empty
                 { $$ = nullptr; }
         | argument_expression
-        | argument_expression_list ',' argument_expression
+        | argument_expression_list_opt ',' argument_expression
                 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
         ;
@@ -1196 +1196 @@
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
                                                 OperKinds::LThan, $1->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
-        | '=' comma_expression                                                                  // CFA
+        | '=' comma_expression                                                          // CFA
                 { $$ = forCtrl( $2, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
                                                 OperKinds::LEThan, $2->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
@@ -1203 +1203 @@
         | comma_expression inclexcl comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
+        | comma_expression ';'                                                          // CFA
+                { $$ = forCtrl( new ExpressionNode( build_constantInteger( *new string( "0u" ) ) ), $1, nullptr, OperKinds::LThan, nullptr, nullptr ); }
         | comma_expression ';' comma_expression                         // CFA
                 { $$ = forCtrl( $3, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
                                                 OperKinds::LThan, $3->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
-        | comma_expression ';' '=' comma_expression                             // CFA
+        | comma_expression ';' '=' comma_expression                     // CFA
                 { $$ = forCtrl( $4, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
                                                 OperKinds::LEThan, $4->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
@@ -1304 +1306 @@
 // If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so change syntax to "with mutex".
 mutex_statement:
-        MUTEX '(' argument_expression_list ')' statement
+        MUTEX '(' argument_expression_list_opt ')' statement
                 { SemanticError( yylloc, "Mutex statement is currently unimplemented." ); $$ = nullptr; }
         ;
@@ -1321 +1323 @@
         WAITFOR '(' cast_expression ')'
                 { $$ = $3; }
-//      | WAITFOR '(' cast_expression ',' argument_expression_list ')'
+//      | WAITFOR '(' cast_expression ',' argument_expression_list_opt ')'
 //              { $$ = (ExpressionNode *)$3->set_last( $5 ); }
-        | WAITFOR '(' cast_expression_list ':' argument_expression_list ')'
+        | WAITFOR '(' cast_expression_list ':' argument_expression_list_opt ')'
                 { $$ = (ExpressionNode *)($3->set_last( $5 )); }
         ;
@@ -1330 +1332 @@
         cast_expression
         | cast_expression_list ',' cast_expression
-                { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+                // { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+                { SemanticError( yylloc, "List of mutex member is currently unimplemented." ); $$ = nullptr; }
         ;
 
@@ -2095 +2098 @@
 
 aggregate_control:                                                                              // CFA
-        GENERATOR
+        MONITOR
+                { yyy = true; $$ = AggregateDecl::Monitor; }
+        | MUTEX STRUCT
+                { yyy = true; $$ = AggregateDecl::Monitor; }
+        | GENERATOR
                 { yyy = true; $$ = AggregateDecl::Generator; }
-        | MONITOR GENERATOR
+        | MUTEX GENERATOR
                 { SemanticError( yylloc, "monitor generator is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         | COROUTINE
                 { yyy = true; $$ = AggregateDecl::Coroutine; }
-        | MONITOR
-                { yyy = true; $$ = AggregateDecl::Monitor; }
-        | MONITOR COROUTINE
+        | MUTEX COROUTINE
                 { SemanticError( yylloc, "monitor coroutine is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         | THREAD
                 { yyy = true; $$ = AggregateDecl::Thread; }
-        | MONITOR THREAD
+        | MUTEX THREAD
                 { SemanticError( yylloc, "monitor thread is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         ;
@@ -2774 +2779 @@
         | attr_name
                 { $$ = DeclarationNode::newAttribute( $1 ); }
-        | attr_name '(' argument_expression_list ')'
+        | attr_name '(' argument_expression_list_opt ')'
                 { $$ = DeclarationNode::newAttribute( $1, $3 ); }
         ;

src/ResolvExpr/AlternativeFinder.cc

@@ -1216 +1216 @@
                         unify( castExpr->result, alt.expr->result, alt.env, needAssertions,
                                 haveAssertions, openVars, indexer );
-                        Cost thisCost = castCost( alt.expr->result, castExpr->result, alt.expr->get_lvalue(),
-                                indexer, alt.env );
+                        Cost thisCost =
+                                castExpr->isGenerated
+                                ? conversionCost( alt.expr->result, castExpr->result, alt.expr->get_lvalue(),   indexer, alt.env )
+                                : castCost( alt.expr->result, castExpr->result, alt.expr->get_lvalue(), indexer, alt.env );
                         PRINT(
                                 std::cerr << "working on cast with result: " << castExpr->result << std::endl;
@@ -1698 +1700 @@
 
                                 // unification run for side-effects
-                                unify( toType, alt.expr->result, newEnv, need, have, openVars, indexer );
+                                bool canUnify = unify( toType, alt.expr->result, newEnv, need, have, openVars, indexer );
+                                (void) canUnify;
                                 // xxx - do some inspecting on this line... why isn't result bound to initAlt.type?
 
-                                Cost thisCost = castCost( alt.expr->result, toType, alt.expr->get_lvalue(),
+                                Cost thisCost = computeConversionCost( alt.expr->result, toType, alt.expr->get_lvalue(),
                                         indexer, newEnv );
+
+                                PRINT(
+                                        Cost legacyCost = castCost( alt.expr->result, toType, alt.expr->get_lvalue(),
+                                                indexer, newEnv );
+                                        std::cerr << "Considering initialization:";
+                                        std::cerr << std::endl << "  FROM: "; alt.expr->result->print(std::cerr);
+                                        std::cerr << std::endl << "  TO: ";   toType          ->print(std::cerr);
+                                        std::cerr << std::endl << "  Unification " << (canUnify ? "succeeded" : "failed");
+                                        std::cerr << std::endl << "  Legacy cost " << legacyCost;
+                                        std::cerr << std::endl << "  New cost " << thisCost;
+                                        std::cerr << std::endl;
+                                )
+                                
                                 if ( thisCost != Cost::infinity ) {
                                         // count one safe conversion for each value that is thrown away

src/ResolvExpr/ConversionCost.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 07:06:19 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Oct  4 14:45:00 2019
+// Last Modified On : Wed Jul 29 16:11:00 2020
 // Update Count     : 28
 //
@@ -392 +392 @@
         void ConversionCost::postvisit( const FunctionType * ) {}
 
-        void ConversionCost::postvisit( const StructInstType * inst ) {
-                /*
-                if ( const StructInstType * destAsInst = dynamic_cast< const StructInstType * >( dest ) ) {
-                        if ( inst->name == destAsInst->name ) {
-                                cost = Cost::zero;
-                        } // if
-                } // if
-                */
-        }
-
-        void ConversionCost::postvisit( const UnionInstType * inst ) {
-                /*
-                if ( const UnionInstType * destAsInst = dynamic_cast< const UnionInstType * >( dest ) ) {
-                        if ( inst->name == destAsInst->name ) {
-                                cost = Cost::zero;
-                        } // if
-                } // if
-                */
-        }
-
         void ConversionCost::postvisit( const EnumInstType * ) {
                 static Type::Qualifiers q;
@@ -685 +665 @@
 }
 
-void ConversionCost_new::postvisit( const ast::StructInstType * structInstType ) {
-        /*
-        if ( const ast::StructInstType * dstAsInst =
-                        dynamic_cast< const ast::StructInstType * >( dst ) ) {
-                if ( structInstType->name == dstAsInst->name ) {
-                        cost = Cost::zero;
-                }
-        }
-        */
-}
-
-void ConversionCost_new::postvisit( const ast::UnionInstType * unionInstType ) {
-        /*
-        if ( const ast::UnionInstType * dstAsInst =
-                        dynamic_cast< const ast::UnionInstType * >( dst ) ) {
-                if ( unionInstType->name == dstAsInst->name ) {
-                        cost = Cost::zero;
-                }
-        }
-        */
-}
-
 void ConversionCost_new::postvisit( const ast::EnumInstType * enumInstType ) {
         (void)enumInstType;

src/ResolvExpr/ConversionCost.h

@@ -10 +10 @@
 // Created On       : Sun May 17 09:37:28 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Oct  4 14:59:00 2019
+// Last Modified On : Wed Jul 29 16:12:00 2020
 // Update Count     : 7
 //
@@ -51 +51 @@
                 void postvisit( const ReferenceType * refType );
                 void postvisit( const FunctionType * functionType );
-                void postvisit( const StructInstType * aggregateUseType );
-                void postvisit( const UnionInstType * aggregateUseType );
                 void postvisit( const EnumInstType * aggregateUseType );
                 void postvisit( const TraitInstType * aggregateUseType );
@@ -105 +103 @@
         void postvisit( const ast::ReferenceType * refType );
         void postvisit( const ast::FunctionType * functionType );
-        void postvisit( const ast::StructInstType * structInstType );
-        void postvisit( const ast::UnionInstType * unionInstType );
         void postvisit( const ast::EnumInstType * enumInstType );
         void postvisit( const ast::TraitInstType * traitInstType );

src/SynTree/Expression.h

@@ -206 +206 @@
   public:
         Expression * arg;
-        bool isGenerated = true; // cast generated implicitly by code generation or explicit in program
+
+        // Inidicates cast is introduced by the CFA type system.
+        // true for casts that the resolver introduces to force a return type
+        // false for casts from user code
+        // false for casts from desugaring advanced CFA features into simpler CFA
+        // example
+        //   int * p;     // declaration
+        //   (float *) p; // use, with subject cast
+        // subject cast isGenerated means we are considering an interpretation with a type mismatch
+        // subject cast not isGenerated means someone in charge wants it that way
+        bool isGenerated = true;
 
         CastExpr( Expression * arg, bool isGenerated = true );

src/Virtual/ExpandCasts.cc

@@ -10 +10 @@
 // Created On       : Mon Jul 24 13:59:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Tus Aug  2 14:59:00 2017
-// Update Count     : 1
+// Last Modified On : Fri Jul 31 10:29:00 2020
+// Update Count     : 4
 //
 
@@ -18 +18 @@
 #include <cassert>                 // for assert, assertf
 #include <iterator>                // for back_inserter, inserter
-#include <map>                     // for map, _Rb_tree_iterator, map<>::ite...
 #include <string>                  // for string, allocator, operator==, ope...
-#include <utility>                 // for pair
 
 #include "Common/PassVisitor.h"    // for PassVisitor
+#include "Common/ScopedMap.h"      // for ScopedMap
 #include "Common/SemanticError.h"  // for SemanticError
+#include "SymTab/Mangler.h"        // for mangleType
 #include "SynTree/Declaration.h"   // for ObjectDecl, StructDecl, FunctionDecl
 #include "SynTree/Expression.h"    // for VirtualCastExpr, CastExpr, Address...
@@ -31 +31 @@
 
 namespace Virtual {
+
+        // Indented until the new ast code gets added.
+
+        /// Maps virtual table types the instance for that type.
+        class VirtualTableMap final {
+                ScopedMap<std::string, ObjectDecl *> vtable_instances;
+        public:
+                void enterScope() {
+                        vtable_instances.beginScope();
+                }
+                void leaveScope() {
+                        vtable_instances.endScope();
+                }
+
+                ObjectDecl * insert( ObjectDecl * vtableDecl ) {
+                        std::string const & mangledName = SymTab::Mangler::mangleType( vtableDecl->type );
+                        ObjectDecl *& value = vtable_instances[ mangledName ];
+                        if ( value ) {
+                                if ( vtableDecl->storageClasses.is_extern ) {
+                                        return nullptr;
+                                } else if ( ! value->storageClasses.is_extern ) {
+                                        return value;
+                                }
+                        }
+                        value = vtableDecl;
+                        return nullptr;
+                }
+
+                ObjectDecl * lookup( const Type * vtableType ) {
+                        std::string const & mangledName = SymTab::Mangler::mangleType( vtableType );
+                        const auto it = vtable_instances.find( mangledName );
+                        return ( vtable_instances.end() == it ) ? nullptr : it->second;
+                }
+        };
 
         /* Currently virtual depends on the rather brittle name matching between
@@ -39 +73 @@
          */
 
+        namespace {
+
         std::string get_vtable_name( std::string const & name ) {
                 return name + "_vtable";
@@ -53 +89 @@
         std::string get_vtable_inst_name_root( std::string const & name ) {
                 return get_vtable_name_root( name.substr(1, name.size() - 10 ) );
-        }
-
-        bool is_vtable_name( std::string const & name ) {
-                return (name.substr( name.size() - 7 ) == "_vtable" );
         }
 
@@ -64 +96 @@
         }
 
+        } // namespace
+
         class VirtualCastCore {
-        std::map<std::string, ObjectDecl *> vtable_instances;
-        FunctionDecl *vcast_decl;
-        StructDecl *pvt_decl;
-
                 Type * pointer_to_pvt(int level_of_indirection) {
                         Type * type = new StructInstType(
@@ -80 +110 @@
         public:
                 VirtualCastCore() :
-                        vtable_instances(), vcast_decl( nullptr ), pvt_decl( nullptr )
+                        indexer(), vcast_decl( nullptr ), pvt_decl( nullptr )
                 {}
 
@@ -88 +118 @@
 
                 Expression * postmutate( VirtualCastExpr * castExpr );
+
+                VirtualTableMap indexer;
+        private:
+                FunctionDecl *vcast_decl;
+                StructDecl *pvt_decl;
         };
 
@@ -107 +142 @@
         void VirtualCastCore::premutate( ObjectDecl * objectDecl ) {
                 if ( is_vtable_inst_name( objectDecl->get_name() ) ) {
-                        vtable_instances[objectDecl->get_name()] = objectDecl;
-                }
-        }
+                        if ( ObjectDecl * existing = indexer.insert( objectDecl ) ) {
+                                std::string msg = "Repeated instance of virtual table, original found at: ";
+                                msg += existing->location.filename;
+                                msg += ":" + toString( existing->location.first_line );
+                                SemanticError( objectDecl->location, msg );
+                        }
+                }
+        }
+
+        namespace {
+
+        /// Better error locations for generated casts.
+        CodeLocation castLocation( const VirtualCastExpr * castExpr ) {
+                if ( castExpr->location.isSet() ) {
+                        return castExpr->location;
+                } else if ( castExpr->arg->location.isSet() ) {
+                        return castExpr->arg->location;
+                } else if ( castExpr->result->location.isSet() ) {
+                        return castExpr->result->location;
+                } else {
+                        return CodeLocation();
+                }
+        }
+
+        [[noreturn]] void castError( const VirtualCastExpr * castExpr, std::string const & message ) {
+                SemanticError( castLocation( castExpr ), message );
+        }
+
+        /// Get the virtual table type used in a virtual cast.
+        Type * getVirtualTableType( const VirtualCastExpr * castExpr ) {
+                const Type * objectType;
+                if ( auto target = dynamic_cast<const PointerType *>( castExpr->result ) ) {
+                        objectType = target->base;
+                } else if ( auto target = dynamic_cast<const ReferenceType *>( castExpr->result ) ) {
+                        objectType = target->base;
+                } else {
+                        castError( castExpr, "Virtual cast type must be a pointer or reference type." );
+                }
+                assert( objectType );
+
+                const StructInstType * structType = dynamic_cast<const StructInstType *>( objectType );
+                if ( nullptr == structType ) {
+                        castError( castExpr, "Virtual cast type must refer to a structure type." );
+                }
+                const StructDecl * structDecl = structType->baseStruct;
+                assert( structDecl );
+
+                const ObjectDecl * fieldDecl = nullptr;
+                if ( 0 < structDecl->members.size() ) {
+                        const Declaration * memberDecl = structDecl->members.front();
+                        assert( memberDecl );
+                        fieldDecl = dynamic_cast<const ObjectDecl *>( memberDecl );
+                        if ( fieldDecl && fieldDecl->name != "virtual_table" ) {
+                                fieldDecl = nullptr;
+                        }
+                }
+                if ( nullptr == fieldDecl ) {
+                        castError( castExpr, "Virtual cast type must have a leading virtual_table field." );
+                }
+                const PointerType * fieldType = dynamic_cast<const PointerType *>( fieldDecl->type );
+                if ( nullptr == fieldType ) {
+                        castError( castExpr, "Virtual cast type virtual_table field is not a pointer." );
+                }
+                assert( fieldType->base );
+                auto virtualStructType = dynamic_cast<const StructInstType *>( fieldType->base );
+                assert( virtualStructType );
+
+                // Here is the type, but if it is polymorphic it will have lost information.
+                // (Always a clone so that it may always be deleted.)
+                StructInstType * virtualType = virtualStructType->clone();
+                if ( ! structType->parameters.empty() ) {
+                        deleteAll( virtualType->parameters );
+                        virtualType->parameters.clear();
+                        cloneAll( structType->parameters, virtualType->parameters );
+                }
+                return virtualType;
+        }
+
+        } // namespace
 
         Expression * VirtualCastCore::postmutate( VirtualCastExpr * castExpr ) {
-                assertf( castExpr->get_result(), "Virtual Cast target not found before expansion." );
+                assertf( castExpr->result, "Virtual Cast target not found before expansion." );
 
                 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 during translation.
-                // Move to helper with more detailed error messages.
-                PointerType * target_type =
-                        dynamic_cast<PointerType *>( castExpr->get_result() );
-                assert( target_type );
-
-                StructInstType * target_struct =
-                        dynamic_cast<StructInstType *>( target_type->get_base() );
-                assert( target_struct );
-
-                StructDecl * target_decl = target_struct->get_baseStruct();
-
-                std::map<std::string, ObjectDecl *>::iterator found =
-                        vtable_instances.find(
-                                get_vtable_inst_name( target_decl->get_name() ) );
-                if ( vtable_instances.end() == found ) {
-                        assertf( false, "virtual table instance not found." );
-                }
-                ObjectDecl * table = found->second;
+                const Type * vtable_type = getVirtualTableType( castExpr );
+                ObjectDecl * table = indexer.lookup( vtable_type );
+                if ( nullptr == table ) {
+                        SemanticError( castLocation( castExpr ),
+                                "Could not find virtual table instance." );
+                }
 
                 Expression * result = new CastExpr(
-                        //new ApplicationExpr(
-                                //new AddressExpr( new VariableExpr( vcast_decl ) ),
-                                //new CastExpr( new VariableExpr( vcast_decl ),
-                                //      new PointerType( noQualifiers,
-                                //              vcast_decl->get_type()->clone()
-                                //              )
-                                //      ),
                         new ApplicationExpr( VariableExpr::functionPointer( vcast_decl ), {
                                         new CastExpr(
@@ -163 +252 @@
                 castExpr->set_result( nullptr );
                 delete castExpr;
+                delete vtable_type;
                 return result;
         }

src/main.cc

@@ -9 +9 @@
 // Author           : Peter Buhr and Rob Schluntz
 // Created On       : Fri May 15 23:12:02 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Feb  8 08:33:50 2020
-// Update Count     : 633
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue May 19 12:03:00 2020
+// Update Count     : 634
 //
 
@@ -312 +312 @@
                 } // if
 
+                PASS( "Translate Throws", ControlStruct::translateThrows( translationUnit ) );
                 PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
                 PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
@@ -360 +361 @@
                 PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
 
-                PASS( "Translate EHM" , ControlStruct::translateEHM( translationUnit ) );
+                PASS( "Translate Tries" , ControlStruct::translateTries( translationUnit ) );
 
                 PASS( "Gen Waitfor" , Concurrency::generateWaitFor( translationUnit ) );